ConstRangeFromPointAdapter.h

#pragma once

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

#define ConstRangeFromPointAdapter_RECURSES

#if !defined ConstRangeFromPointAdapter_h

#define ConstRangeFromPointAdapter_h

// Inclusions
#include "DGtal/base/BasicFunctors.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/base/CConstBidirectionalRangeFromPoint.h"
#include "DGtal/base/ConstIteratorAdapter.h"
#include "boost/concept_check.hpp"

namespace DGtal 
{


  // class ConstRangeFromPointAdapter

  template <typename TRange, typename TFunctor, typename TReturnType>
  class ConstRangeFromPointAdapter
  {

    BOOST_CONCEPT_ASSERT(( CConstBidirectionalRangeFromPoint<TRange> )); 

    // ------------------------- inner types --------------------------------
  public: 

    typedef typename TRange::Point Point;   
    typedef ConstIteratorAdapter<typename TRange::ConstIterator,TFunctor,TReturnType> ConstIterator; 
    typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;

    // ------------------------- standard services --------------------------------

    ConstRangeFromPointAdapter(const TRange& aRange, 
                      const TFunctor& aFunctor )
      : myRangePtr(&aRange), myFunctorPtr(&aFunctor) {}

    ConstRangeFromPointAdapter( const ConstRangeFromPointAdapter & other )
      : myRangePtr(other.myRangePtr), myFunctorPtr(other.myFunctorPtr) {}
  
    ConstRangeFromPointAdapter& operator= ( const ConstRangeFromPointAdapter & other )
    {  
      if ( this != &other )
        {
          myRangePtr = other.myRangePtr;
          myFunctorPtr = other.myFunctorPtr;
        }
      return *this;
    }

    ~ConstRangeFromPointAdapter() {}

    bool isValid() const { return true; }
  

    // ------------------------- private data --------------------------------
  private: 
    const TRange* myRangePtr; 
    const TFunctor* myFunctorPtr; 

    // ------------------------- iterator services --------------------------------
  public:

    ConstIterator begin() const {
      return ConstIterator( myRangePtr->begin(), *myFunctorPtr );
    }

    ConstIterator begin(const Point& aPoint) const {
      return ConstIterator( myRangePtr->begin(aPoint), *myFunctorPtr );
    }

    ConstIterator end() const {
      return ConstIterator( myRangePtr->end(), *myFunctorPtr );
    }

    ConstReverseIterator rbegin() const {
      return ConstReverseIterator(this->end());
    }

    ConstReverseIterator rbegin(const Point& aPoint) const {
      ConstIterator it( myRangePtr->begin(aPoint), *myFunctorPtr ); 
      if ( it != this->end() ) ++it; 
      return ConstReverseIterator( it );
    }

    ConstReverseIterator rend() const {
      return ConstReverseIterator(this->begin());
    }


  }; //end class ConstRangeFromPointAdapter

} // namespace DGtal



#endif // !defined ConstRangeFromPointAdapter_h

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