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/ConstAlias.h"
#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( ConstAlias<TRange> aRange, 
                      ConstAlias<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)