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( ConstAlias<TRange> aRange,  {…}

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

    ~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  {…}

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

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

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

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

    ConstReverseIterator rend() const {
      return ConstReverseIterator(this->begin());
    }
    ConstReverseIterator rend() const  {…}
 
 
  }; //end class ConstRangeFromPointAdapter
  class ConstRangeFromPointAdapter {…};
 
} // namespace DGtal

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