PointFunctorHolder.h

 
#pragma once
 
#if defined(PointFunctorHolder_RECURSES)
#error Recursive header files inclusion detected in PointFunctorHolder.h
#else // defined(PointFunctorHolder_RECURSES)
#define PointFunctorHolder_RECURSES
 
#if !defined PointFunctorHolder_h
#define PointFunctorHolder_h
 
// Inclusions
#include <iostream>
#include <type_traits>
#include <utility>
 
#include "DGtal/base/FunctorHolder.h"
 
namespace DGtal
{
namespace functors
{
 
template <
  typename TPoint,
  typename TValue,
  typename TFunctor
>
class PointFunctorHolder
{
  // ----------------------- Interface --------------------------------------
public:
 
  // DGtal types
  using Self    = PointFunctorHolder<TPoint, TValue, TFunctor>;
  using Point   = TPoint;
  using Value   = TValue;
  using Functor = TFunctor;
 
  // ----------------------- Standard services ------------------------------
public:
 
  template <
    typename Function,
    // SFINAE trick to disable this constructor in a copy/move construction context.
    typename std::enable_if<!std::is_base_of<PointFunctorHolder, typename std::decay<Function>::type>::value, int>::type = 0
  >
  explicit PointFunctorHolder(Function && fn)
      : myFunctor(std::forward<Function>(fn))
  {
  }
 
  // ----------------------- Interface --------------------------------------
public:
 
  inline
  Value operator() ( Point const& aPoint ) const
    {
      return myFunctor( aPoint );
    }
 
  inline
  void selfDisplay ( std::ostream & out ) const
    {
      out << "[PointFunctorHolder] holding a " << myFunctor;
    }
 
  inline constexpr
  bool isValid() const
    {
      return true;
    }
 
 
  // ------------------------- Private Datas --------------------------------
private:
  Functor myFunctor; 
 
}; // End of class PointFunctorHolder
 
 
template <typename TPoint, typename TValue, typename TFunctor>
std::ostream&
operator<< ( std::ostream & out, const PointFunctorHolder<TPoint, TValue, TFunctor> & object )
{
  object.selfDisplay(out);
  return out;
}
 
 
template <
  typename TPoint,
  typename TValue,
  typename TFunctor
>
inline auto
holdPointFunctor( TFunctor && aFunctor )
    -> PointFunctorHolder<TPoint, TValue, decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))>
  {
    return PointFunctorHolder<TPoint, TValue, decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))>{
        holdFunctor(std::forward<TFunctor>(aFunctor))
    };
  }
 
template <
  typename TPoint,
  typename TFunctor
>
inline auto
holdPointFunctor( TFunctor && aFunctor )
    -> PointFunctorHolder<
          TPoint,
          typename std::decay<decltype(aFunctor(std::declval<TPoint>()))>::type,
          decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))
        >
  {
    return PointFunctorHolder<
        TPoint,
        typename std::decay<decltype(aFunctor(std::declval<TPoint>()))>::type,
        decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))
      >{ holdFunctor(std::forward<TFunctor>(aFunctor)) };
  }
 
} // namespace functors
} // namespace DGtal
 
#endif // !defined PointFunctorHolder_h
 
#undef PointFunctorHolder_RECURSES
#endif // else defined(PointFunctorHolder_RECURSES)