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"
#include "boost/iterator/reverse_iterator.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 boost::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)