ConstImageFunctorHolder.h

 
#pragma once

 
#if defined(ConstImageFunctorHolder_RECURSES)
#error Recursive header files inclusion detected in ConstImageFunctorHolder.h
#else // defined(ConstImageFunctorHolder_RECURSES)
#define ConstImageFunctorHolder_RECURSES
 
#if !defined ConstImageFunctorHolder_h
#define ConstImageFunctorHolder_h

// Inclusions
#include <iostream>
#include <type_traits>
#include <utility>
#include <iterator>
 
#include <boost/iterator/transform_iterator.hpp>
#include <boost/concept/assert.hpp>
#include <boost/iterator/reverse_iterator.hpp>
 
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/base/FunctorHolder.h"
 
namespace DGtal
{
namespace functors
{

template <
  typename TDomain,
  typename TValue,
  typename TFunctor
>
class ConstImageFunctorHolder
{
  BOOST_CONCEPT_ASSERT(( DGtal::concepts::CDomain<TDomain> ));
 
  // ----------------------- Interface --------------------------------------
public:
 
  // DGtal types
  using Self      = ConstImageFunctorHolder<TDomain, TValue, TFunctor>;
  using Domain    = TDomain;
  using Point     = typename Domain::Point;
  using Vector    = typename Domain::Vector;
  using Integer   = typename Domain::Integer;
  using Size      = typename Domain::Size;
  using Dimension = typename Domain::Dimension;
  using Vertex    = Point;
  using Value     = TValue;
  using Functor   = TFunctor;
 
  using ConstIterator = boost::transform_iterator< std::reference_wrapper<const Self>, typename Domain::ConstIterator >;
  using ConstReverseIterator = boost::reverse_iterator< ConstIterator >;
  class ConstRange;
 
  BOOST_STATIC_CONSTANT( Dimension, dimension = Domain::Space::dimension );
 
  // ------------------------- Private Datas --------------------------------
  // Private members moved to the beginning of the class because of
  //  the SFINAE trick in the operator() methods.
private:
  Domain  myDomain;   
  Functor myFunctor;  
 
  // ----------------------- Standard services ------------------------------
public:

  template < class TGivenFunctor >
  explicit ConstImageFunctorHolder( Domain const& aDomain, TGivenFunctor && aFunctor )
    : myDomain( aDomain )
    , myFunctor( std::forward<TGivenFunctor>(aFunctor) )
  {
  }
  explicit ConstImageFunctorHolder( Domain const& aDomain, TGivenFunctor && aFunctor ) {…}
 
  // ----------------------- Interface --------------------------------------
public:

  inline
  Domain const& domain() const
    {
      return myDomain;
    }
  Domain const& domain() const {…}


  template <typename TPoint> // Needed template parameter to enable SFINAE trick
  inline
  auto operator() ( TPoint const& aPoint ) const
      -> decltype( myFunctor( aPoint ) ) // Using SFINAE to enable this overload for unary functor
    {
      ASSERT_MSG(
          myDomain.isInside(aPoint),
          "The point is outside the domain."
      );
      return myFunctor( aPoint );
    }
  auto operator() ( TPoint const& aPoint ) const {…}
 
  template <typename TPoint> // Needed template parameter to enable SFINAE trick
  inline
  auto operator() ( TPoint const& aPoint ) const
      -> decltype( myFunctor( aPoint, myDomain ) ) // Using SFINAE to enable this overload for binary functor
    {
      ASSERT_MSG(
          myDomain.isInside(aPoint),
          "The point is outside the domain."
      );
      return myFunctor( aPoint, myDomain );
    }
  auto operator() ( TPoint const& aPoint ) const {…}


  inline
  ConstRange constRange() const
    {
      return ConstRange( *this );
    }
  ConstRange constRange() const {…}

  inline
  void selfDisplay ( std::ostream & out ) const
    {
      out << "[ConstImageFunctorHolder] holding a " << myFunctor << " on domain " << myDomain;
    }
  void selfDisplay ( std::ostream & out ) const {…}

  inline constexpr
  bool isValid() const
    {
      return true;
    }
  bool isValid() const {…}
 
public:
  class ConstRange
    {
  public:
      ConstRange( Self const& aConstImageFunctorHolder )
        : myConstImageFunctorHolder( aConstImageFunctorHolder )
      {}
      ConstRange( Self const& aConstImageFunctorHolder ) {…}
 
      using ConstIterator = typename Self::ConstIterator;
      using ConstReverseIterator = typename Self::ConstReverseIterator;
      using Point = typename Self::Point;
 
      inline ConstIterator begin()  const { return { myConstImageFunctorHolder.myDomain.begin(), myConstImageFunctorHolder }; }
      inline ConstIterator begin( Point const& aPoint ) const { return { myConstImageFunctorHolder.myDomain.begin(aPoint), myConstImageFunctorHolder }; }
      inline ConstIterator end()    const { return { myConstImageFunctorHolder.myDomain.end(), myConstImageFunctorHolder }; }
 
      inline ConstReverseIterator rbegin()  const { return ConstReverseIterator( end() ); }
      inline ConstReverseIterator rbegin( Point const& aPoint ) const { return ConstReverseIterator( ++begin(aPoint) ); }
      inline ConstReverseIterator rend()    const { return ConstReverseIterator( begin() ); }
 
  private:
      Self const& myConstImageFunctorHolder;
    }; // End of class ConstRange
  class ConstRange {…};
}; // End of class ConstImageFunctorHolder
class ConstImageFunctorHolder {…};

template <typename TDomain, typename TValue, typename TFunctor>
std::ostream&
operator<< ( std::ostream & out, const ConstImageFunctorHolder<TDomain, TValue, TFunctor> & object )
{
  object.selfDisplay(out);
  return out;
}
std::ostream& {…}

template <
  typename TValue,
  typename TDomain,
  typename TFunctor
>
inline auto
holdConstImageFunctor( TDomain const& aDomain, TFunctor && aFunctor )
    -> ConstImageFunctorHolder<TDomain, TValue, decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))>
  {
    return ConstImageFunctorHolder<TDomain, TValue, decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))>{ aDomain, holdFunctor(std::forward<TFunctor>(aFunctor)) };
  }
holdConstImageFunctor( TDomain const& aDomain, TFunctor && aFunctor ) {…}


 
// Auto-deduction of the return type in case of an unary functor.
template <
  typename TDomain,
  typename TFunctor
>
inline auto
holdConstImageFunctor( TDomain const& aDomain, TFunctor && aFunctor )
    -> ConstImageFunctorHolder<
          TDomain,
          typename std::decay<decltype(aFunctor(std::declval<typename TDomain::Point>()))>::type,
          decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))
        >
  {
    return ConstImageFunctorHolder<
        TDomain,
        typename std::decay<decltype(aFunctor(std::declval<typename TDomain::Point>()))>::type,
        decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))
      >{ aDomain, holdFunctor(std::forward<TFunctor>(aFunctor)) };
  }
holdConstImageFunctor( TDomain const& aDomain, TFunctor && aFunctor ) {…}
 
// Auto-deduction of the return type in case of a binary functor.
template <
  typename TDomain,
  typename TFunctor
>
inline auto
holdConstImageFunctor( TDomain const& aDomain, TFunctor && aFunctor )
    -> ConstImageFunctorHolder<
          TDomain,
          typename std::decay<decltype(aFunctor(std::declval<typename TDomain::Point>(), aDomain))>::type,
          decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))
        >
  {
    return ConstImageFunctorHolder<
        TDomain,
        typename std::decay<decltype(aFunctor(std::declval<typename TDomain::Point>(), aDomain))>::type,
        decltype(holdFunctor(std::forward<TFunctor>(aFunctor)))
      >{ aDomain, holdFunctor(std::forward<TFunctor>(aFunctor)) };
  }

 
} // namespace functors
} // namespace DGtal
 
#endif // !defined ConstImageFunctorHolder_h
 
#undef ConstImageFunctorHolder_RECURSES
#endif // else defined(ConstImageFunctorHolder_RECURSES)