BasicFunctors.h

#pragma once

#if defined(BasicFunctors_RECURSES)
#error Recursive header files inclusion detected in BasicFunctors.h
#else // defined(BasicFunctors_RECURSES)

#define BasicFunctors_RECURSES

#if !defined BasicFunctors_h

#define BasicFunctors_h

// Inclusions
#include <algorithm>
#include <functional>
#include <cmath>

#include "BasicBoolFunctions.h"

namespace DGtal 
{

  template<typename T>
  struct MinFunctor
  {
    inline
    T operator() (const T&a, const T&b) const
    { return /*std::*/min(a,b); }
  };
  
  template<typename T>
  struct MaxFunctor
  {
    inline
    T operator() (const T&a, const T&b) const
    { return /*std::*/max(a,b); }
  };

  template <class T> 
  struct MinusFunctor : binary_function <T,T,T>
  {
    T operator() (const T& x, const T& y) const
    {return x-y;}
  };

  template <class T>
  struct AbsFunctor : unary_function<T,T>
  { 
   inline
   T operator() (const T &x) const
    {
      if (x < 0)
  return -x;
      else 
  return x;
    }
  };

// Some basic unary functors that may be useful

  struct DefaultFunctor
  {
    template <typename T >
    inline
    T operator()(const T& aT) const
    {
      return aT;
    }
  };

  template <typename TValue>
  class ConstValueFunctor
  {
  public:
    typedef TValue Value;

    ConstValueFunctor(const Value& aValue = 0)
      :myValue(aValue) {};
    
    template <typename TInput>
    inline
    Value operator()(const TInput& /*aInput*/) const
    {
      return myValue;
    }

  private:
    Value myValue;
    
  };


  template <typename TOutput >
  struct CastFunctor
  {
    template<typename TInput>
    inline
    TOutput operator()(const TInput& aInput) const
    {
      return static_cast<TOutput>(aInput);
    }
  }; 


  template <typename TFunctor1, typename TFunctor2, typename ReturnType >
  class Composer
  {
  public:
    Composer(): myF1(NULL), myF2(NULL) {}
    Composer(const TFunctor1& aF1, const TFunctor2& aF2): myF1(&aF1), myF2(&aF2) {}
    Composer(const Composer& other): myF1(other.myF1), myF2(other.myF2) {}

    Composer& operator=(const Composer& other)
    {
      if (this != &other)
        {
          myF1 = other.myF1; 
          myF2 = other.myF2;
        }
    return *this;
    }


    template<typename TInput>
    inline
    ReturnType operator()(const TInput& aInput) const
    {
      ASSERT( myF1 ); 
      ASSERT( myF2 ); 
      return myF2->operator()( myF1->operator()( aInput ) );
    }

  private:
    const TFunctor1* myF1;
    const TFunctor2* myF2;
  };

template <typename T, bool isLower = true, bool isEqual = true >
class Thresholder {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));

    typedef T Input; 

    Thresholder(const Input& aT = 0):myT(aT) {};
    bool operator()(const Input& aI) const {
      std::less_equal<Input> c;
      return c(aI,myT); 
    }
  private:
   Input myT;
};

//specializations
template <typename T>
struct Thresholder<T,false,false> {

  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));

    typedef T Input; 

    Thresholder(const Input& aT = 0):myT(aT) {};

    bool operator()(const Input& aI) const {
    std::greater<Input> c;
    return c(aI,myT);
    }

  private:
    Input myT;
};
template <typename T>
struct Thresholder<T,false,true> {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));

    typedef T Input; 

    Thresholder(const Input& aT = 0):myT(aT) {};
    bool operator()(const Input& aI) const {
    std::greater_equal<Input> c;
    return c(aI,myT);
    }

  private:
    Input myT;
};

template <typename T>
struct Thresholder<T,true,false> {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));

    typedef T Input; 

    Thresholder(const Input& aT = 0):myT(aT) {};

    bool operator()(const Input& aI) const {
    std::less<Input> c;
    return c(aI,myT);
    }

  private:
    Input myT;
};

template <typename T>
struct Thresholder<T,true,true> {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));

    typedef T Input; 

    Thresholder(const Input& aT = 0):myT(aT) {};

    bool operator()(const Input& aI) const {
    std::less_equal<Input> c;
    return c(aI,myT);
    }

  private:
    Input myT;
};

  // template class PredicateCombiner
  template <typename TPredicate1, typename TPredicate2, 
            typename TBinaryFunctor = BoolFunction2 >
  struct PredicateCombiner
  {
    typedef TPredicate1 Predicate1;
    typedef TPredicate2 Predicate2;

    PredicateCombiner( const Predicate1 & pred1,
        const Predicate2 & pred2,
        const TBinaryFunctor & boolFunctor )
      : myPred1( &pred1 ), myPred2( &pred2 ), myBoolFunctor( &boolFunctor )
    {
    }

    PredicateCombiner(  const PredicateCombiner& other )
      : myPred1( other.pred1 ), myPred2( other.pred2 ), myBoolFunctor( other.boolFunctor )
    {
    }

    PredicateCombiner& operator=( const PredicateCombiner& other )
    {
      if (this != &other)
        {
          myPred1 = other.myPred1; 
          myPred2 = other.myPred2; 
          myBoolFunctor = other.myBoolFunctor; 
        }
    return *this;
    }

    ~PredicateCombiner() {}

    template<typename T>
    bool operator()( const T & t ) const 
    {
      return myBoolFunctor->operator()( myPred1->operator()( t ), 
                                        myPred2->operator()( t ) );
    }

    const Predicate1* myPred1;
    const Predicate2* myPred2;
    const TBinaryFunctor* myBoolFunctor;
  };

template <typename T>
class IntervalThresholder 
{
public:
  BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
  BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));

  typedef T Input; 

  typedef Thresholder<T,false,true> Tlow; 
  typedef Thresholder<T,true,true> Tup; 
  typedef PredicateCombiner<Tlow,Tup,AndBoolFct2 > CombinedPredicate; 
    
  IntervalThresholder(const Input& low, const Input& up)
    : myTlow( low), myTup ( up ), 
      myPred( myTlow, myTup, AndBoolFct2() ) {};

  bool operator()(const Input& aI) const 
  {
    return myPred(aI); 
  }
private:
  Tlow myTlow;
  Tup myTup;
  CombinedPredicate myPred;
};


  template <typename ReturnType>
  class Pair1st
  {
  public:
    
    template <typename TPair>
    inline
    ReturnType operator()(const TPair& aPair) const
    {
      return aPair.first;
    }
    
  };

  template <typename ReturnType>
  class Pair2nd
  {
  public:
    
    template <typename TPair>
    inline
    ReturnType operator()(const TPair& aPair) const
    {
      return aPair.second;
    }
    
  };

  template <typename ReturnType>
  class Pair1stMutator
  {
  public:
    
    template <typename TPair>
    inline
    ReturnType& operator()(TPair& aPair) const
    {
      return aPair.first;
    }

    template <typename TPair>
    inline
    const ReturnType& operator()(const TPair& aPair) const
    {
      return aPair.first;
    }
    
  };

  template <typename ReturnType>
  class Pair2ndMutator
  {
  public:
    
    template <typename TPair>
    inline
    ReturnType& operator()(TPair& aPair) const
    {
      return aPair.second;
    }

    template <typename TPair>
    inline
    const ReturnType& operator()(const TPair& aPair) const
    {
      return aPair.second;
    }
    
  }; 

}


#endif // !defined BasicFunctors_h

#undef BasicFunctors_RECURSES
#endif // else defined(BasicFunctors_RECURSES)