Package: Sequence       

---

Container/function-adapter.h

#ifndef NMWR_GB_FUNCTION_ADAPTER_H
#define NMWR_GB_FUNCTION_ADAPTER_H



/* ------------------------------------------------------------

    Copyright (C) 1997 - 2009 Guntram Berti

    This file is part of the Grid Algorithms Library (GrAL),
    available at http://gral.berti-cmm.de

    GrAL is distributed under the MIT license,
    see the file LICENSE or http://gral.berti-cmm.de/license

--------------------------------------------------------------- */


#include "Utility/pre-post-conditions.h"
#include "Utility/ref-ptr.h"

namespace GrAL {

template<class F>
class unary_fct_ref {
private:
  const F* f;
public:
  typedef typename F::argument_type argument_type;
  typedef typename F::result_type   result_type;

  unary_fct_ref() :            f(0) {}
  unary_fct_ref(const F& ff) : f(&ff) {}

  result_type operator()(const argument_type& x) const  { 
    REQUIRE((f != 0), "No function!\n",1);
    return (*f)(x);
  }
};

template<class F>
inline unary_fct_ref<F> make_unary_fct_ref(const F& f) 
{ return unary_fct_ref<F>(f); }


template<class M1, class M2>
class unary_map_composition {
private:
  M1 const* m1;
  M2 const* m2;

public:
  typedef typename M2::argument_type argument_type;
  typedef typename M1::result_type   result_type;
  typedef typename M2::domain_type   domain_type;
  typedef typename M1::range_type    range_type;

  unary_map_composition(M1 const& mm1,M2 const& mm2) : m1(&mm1), m2(&mm2) {}

  result_type operator()(argument_type const& x) const { return (*m1)((*m2)(x));}

  domain_type const& domain() const { return m2->domain();}
  
  range_type  const& range()  const { return m1->range();}
};


template<class M1, class M2>
inline
unary_map_composition<M1,M2>
compose_map( M1 const& m1, M2 const& m2)
{ return unary_map_composition<M1,M2>(m1,m2);}




 
template<class ARG, class RES> 
class constant : public std::unary_function<ARG,RES> {
  RES r;
public:
  constant() {}
  constant(RES rr) : r(rr) {}

  RES operator()(ARG const&) const { return r;}
};



template<class F, class ARG = typename F::argument_type, class RES = typename F::result_type>
class map_is_equal {
public:
  typedef F   mapping_type;
  typedef ARG argument_type;
  typedef RES map_result_type;
  typedef bool result_type;

private:
  ref_ptr<mapping_type const> f;
  map_result_type             res;
public:
  map_is_equal() {}
  map_is_equal(mapping_type const& ff, map_result_type r) : f(ff), res(r) {}
  map_is_equal(ref_ptr<mapping_type const> ff, map_result_type r) : f(ff), res(r) {}

  bool operator()(argument_type a) const { return (*f)(a) == res;}
};


template<class P1, class P2>
class and_pred : public std::unary_function<typename P1::argument_type, bool> 
{
public:
  typedef typename std::unary_function<typename P1::argument_type, bool>::result_type   result_type;
  typedef typename std::unary_function<typename P1::argument_type, bool>::argument_type argument_type;
private:
  P1 p1;
  P2 p2;
public:
  and_pred() {}
  and_pred(P1 pp1, P2 pp2) : p1(pp1), p2(pp2) {}

  bool operator()(argument_type a) const { return p1(a) && p2(a);}
};

template<class P1, class P2>
class or_pred : public std::unary_function<typename P1::argument_type, bool> 
{
public:
  typedef typename std::unary_function<typename P1::argument_type, bool>::result_type   result_type;
  typedef typename std::unary_function<typename P1::argument_type, bool>::argument_type argument_type;
private:
  P1 p1;
  P2 p2;
public:
  or_pred() {}
  or_pred(P1 pp1, P2 pp2) : p1(pp1), p2(pp2) {}

  bool operator()(argument_type const& a) const { return p1(a) || p2(a);}
};


template<class P1>
class not_pred : public std::unary_function<typename P1::argument_type, bool> 
{
public:
  typedef typename std::unary_function<typename P1::argument_type, bool>::result_type   result_type;
  typedef typename std::unary_function<typename P1::argument_type, bool>::argument_type argument_type;
private:
  P1 p1;
public:
  not_pred() {}
  not_pred(P1 pp1) : p1(pp1) {}

  bool operator()(argument_type const& a) const { return ! p1(a);}
};


template<class F1, class ARG1, class RES1, class P2>
inline and_pred<map_is_equal<F1,ARG1,RES1>, P2>
operator&&(map_is_equal<F1,ARG1,RES1> p1, P2 p2)
{ return and_pred<map_is_equal<F1,ARG1,RES1>, P2>(p1,p2);}

template<class F1, class ARG1, class RES1, class P2>
inline or_pred<map_is_equal<F1,ARG1,RES1>, P2>
operator||(map_is_equal<F1,ARG1,RES1> p1, P2 p2)
{ return or_pred<map_is_equal<F1,ARG1,RES1>, P2>(p1,p2);}

template<class F1, class ARG1, class RES1>
inline not_pred<map_is_equal<F1,ARG1,RES1> >
operator!(map_is_equal<F1,ARG1,RES1> p1)
{ return not_pred<map_is_equal<F1,ARG1,RES1> >(p1);}




/*
template<class Map>
class set_value_mutator {
private:
  typedef typename Map::value_type value_type;
  typedef typename Map::index_type index_type;
  Map* m;
  value_type t;
  
public:
  set_value_mutator(Map& mm, const value_type& tt) : m(&mm), t(tt) {}
  void operator()(const index_type& i) { (*m)[i] = t;}
};
*/

} // namespace GrAL 

#endif

---

©  Guntram Berti 1997-2009. See the GrAL Homepage for up-to-date information.

---