functional.h

Go to the documentation of this file.

#ifndef _DLR_COMMON_FUNCTIONAL_H_
#define _DLR_COMMON_FUNCTIONAL_H_

#include <algorithm>
#include <functional>
#include <utility>

namespace dlr {

  namespace common {
    
    template <class Functor0, class Functor1, class Functor2>
    class BinaryComposeFunctor
      : public std::binary_function<typename Functor1::argument_type,
                                    typename Functor2::argument_type,
                                    typename Functor0::result_type>
    {
    public:
      BinaryComposeFunctor(const Functor0& functor0, const Functor1& functor1,
                           const Functor2& functor2)
        : m_functor0(functor0), m_functor1(functor1), m_functor2(functor2) {}

      typename Functor0::result_type
      operator()(const typename Functor1::argument_type& argument0,
                 const typename Functor2::argument_type& argument1) {
        return m_functor0(m_functor1(argument0), m_functor2(argument1));
      }

    protected:

      Functor0 m_functor0;

      Functor1 m_functor1;

      Functor1 m_functor2;
    };


    template <class Functor0, class Functor1>
    class ComposeFunctor_1_2
      : public std::binary_function<typename Functor1::first_argument_type,
                                    typename Functor1::second_argument_type,
                                    typename Functor0::result_type>
    {
    public:
      ComposeFunctor_1_2(const Functor0& functor0, const Functor1& functor1)
        : m_functor0(functor0), m_functor1(functor1) {}

    
      typename Functor0::result_type
      operator()(const typename Functor1::first_argument_type& argument0,
                 const typename Functor1::second_argument_type& argument1) {
        return m_functor0(m_functor1(argument0, argument1));
      }

    protected:

      Functor0 m_functor0;

      Functor1 m_functor1;
    };


    template <class Type0, class Type1>
    class ExtractFirstFunctor
      : public std::unary_function<std::pair<Type0, Type1>, Type0>
    {
    public:
      ExtractFirstFunctor() {}

    
      Type0
      operator()(const std::pair<Type0, Type1>& argument) {
        return argument.first;
      }


      Type0&
      operator()(std::pair<Type0, Type1>& argument) {
        return argument.first;
      }
    };


    template <class Type0, class Type1>
    class ExtractSecondFunctor
      : public std::unary_function<std::pair<Type0, Type1>, Type1>
    {
    public:
      ExtractSecondFunctor() {}

    
      Type1
      operator()(const std::pair<Type0, Type1>& argument) {
        return argument.second;
      }


      Type1&
      operator()(std::pair<Type0, Type1>& argument) {
        return argument.second;
      }
    };
  

    template <class Type>
    class ApproximatelyEqualFunctor
      : public std::binary_function<Type, Type, bool>
    {
    public:
      ApproximatelyEqualFunctor(const Type& epsilon=static_cast<Type>(0))
        : m_epsilon(epsilon) {}

      inline bool
      operator()(const Type& argument0, const Type& argument1) {
        Type difference = argument0 - argument1;
        return ((difference <= m_epsilon) && (difference >= (-m_epsilon)));
      }

    protected:

      Type m_epsilon;
    };

  
    template <class ArgumentType0, class ArgumentType1, class ResultType>
    class PointerToBinaryFunctionRA
      : public std::binary_function<ArgumentType0, ArgumentType0, ResultType>
    {
    public:
      typedef ResultType (*FunctionPtrType)(const ArgumentType0&,
                                            const ArgumentType1&);

      explicit
      PointerToBinaryFunctionRA(FunctionPtrType functionPtr)
        : m_functionPtr(functionPtr) {}

      inline ResultType
      operator()(const ArgumentType0& argument0,
                 const ArgumentType0& argument1) const {
        return m_functionPtr(argument0, argument1);
      }

    private:
      FunctionPtrType m_functionPtr;
    };

  
    template <class TypeIn, class TypeOut>
    struct StaticCastFunctor : public std::unary_function<TypeIn, TypeOut> {

      inline TypeOut
      operator()(const TypeIn& input) {
        return static_cast<TypeOut>(input);
      }
    };

  
    template <class Functor0, class Functor1>
    class UnaryComposeFunctor
      : public std::unary_function<typename Functor1::argument_type,
                                   typename Functor0::result_type>
    {
    public:
      UnaryComposeFunctor(const Functor0& functor0, const Functor1& functor1)
        : m_functor0(functor0), m_functor1(functor1) {}

      typename Functor0::result_type
      operator()(const typename Functor1::argument_type& argument) {
        return m_functor0(m_functor1(argument));
      }

    protected:

      Functor0 m_functor0;

      Functor1 m_functor1;
    };

  
    // =================== Helper functions =================== //

    template<class Type>
    inline bool
    approximatelyEqual(const Type& argument0, const Type& argument1,
                       const Type& epsilon) {
      return (ApproximatelyEqualFunctor<Type>(epsilon))(argument0, argument1);
    }

    
    template <class Functor0, class Functor1, class Functor2>
    inline BinaryComposeFunctor<Functor0, Functor1, Functor2>
    binaryComposeFunctor(const Functor0& functor0,
                         const Functor1& functor1,
                         const Functor2& functor2) {
      return BinaryComposeFunctor<Functor0, Functor1, Functor2>(
        functor0, functor1, functor2);
    }


    template <class Type>
    Type
    clip(Type value, Type lowerBound, Type upperBound) {
#ifdef WIN32
      return std::_cpp_max(std::_cpp_min(value, upperBound), lowerBound);
#else
      return std::max(std::min(value, upperBound), lowerBound);
#endif
    }

    
    template <class Functor0, class Functor1>
    inline ComposeFunctor_1_2<Functor0, Functor1>
    composeFunctor_1_2(const Functor0& functor0,
                       const Functor1& functor1) {
      return ComposeFunctor_1_2<Functor0, Functor1>(functor0, functor1);
    }

  
    template <class Functor0, class Functor1>
    inline UnaryComposeFunctor<Functor0, Functor1>
    unaryComposeFunctor(const Functor0& functor0,
                        const Functor1& functor1) {
      return UnaryComposeFunctor<Functor0, Functor1>(functor0, functor1);
    }

    
  } // namespace common
    
}  // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using common::BinaryComposeFunctor;
  using common::ComposeFunctor_1_2;
  using common::ExtractFirstFunctor;
  using common::ExtractSecondFunctor;
  using common::ApproximatelyEqualFunctor;
  using common::PointerToBinaryFunctionRA;
  using common::StaticCastFunctor;
  using common::UnaryComposeFunctor;
  using common::approximatelyEqual;
  using common::binaryComposeFunctor;
  using common::composeFunctor_1_2;
  using common::unaryComposeFunctor;

} // namespace dlr
  
/* ================= Specializations =================== */

#include <dlrCommon/types.h>

namespace dlr {

  namespace common {
    
    template <>
    inline bool
        ApproximatelyEqualFunctor<bool>::
    operator()(const bool& argument0, const bool& argument1) {
        return argument0 == argument1;
        }


        template<>
        inline bool
        ApproximatelyEqualFunctor<size_t>::
        operator()(const size_t& argument0, const size_t& argument1) {
        Int64 difference = static_cast<Int64>(argument0) - static_cast<Int64>(argument1);
        return ((difference <= static_cast<Int64>(m_epsilon)) 
                        && (difference >= (-static_cast<Int64>(m_epsilon))));
      }

  } // namespace common
  
}  // namespace dlr

#endif // #ifndef _DLR_COMMON_FUNCTIONAL_H_