SimpleRandomAccessConstRangeFromPoint.h

 
#pragma once

 
#if defined(SimpleRandomAccessConstRangeFromPoint_RECURSES)
#error Recursive header files inclusion detected in SimpleRandomAccessConstRangeFromPoint.h
#else // defined(SimpleRandomAccessConstRangeFromPoint_RECURSES)
#define SimpleRandomAccessConstRangeFromPoint_RECURSES
 
#if !defined SimpleRandomAccessConstRangeFromPoint_h
#define SimpleRandomAccessConstRangeFromPoint_h

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

  // class SimpleRandomAccessConstRangeFromPoint

  template <typename TConstIterator, typename DistanceFunctor>
 
  class SimpleRandomAccessConstRangeFromPoint
  {
 
      BOOST_CONCEPT_ASSERT ( ( boost::RandomAccessIterator<TConstIterator> ) );
      BOOST_CONCEPT_ASSERT ( ( boost::UnaryFunction<DistanceFunctor,typename DistanceFunctor::Difference,typename DistanceFunctor::Point > ) );
 
      // ------------------------- inner types --------------------------------
 
    public:
 
 
      typedef typename DistanceFunctor::Point Point;
 
      typedef TConstIterator ConstIterator;
      typedef boost::reverse_iterator<ConstIterator> ConstReverseIterator;
 
      typedef Circulator<ConstIterator> ConstCirculator;
      typedef boost::reverse_iterator<ConstCirculator> ConstReverseCirculator;
 
      // ------------------------- standard services --------------------------------

      SimpleRandomAccessConstRangeFromPoint ( const TConstIterator& itb, const TConstIterator& ite, const DistanceFunctor & aDistance )
          : myBegin ( itb ), myEnd ( ite ), myDistance ( aDistance ) {}

      SimpleRandomAccessConstRangeFromPoint ( const SimpleRandomAccessConstRangeFromPoint & other )
          : myBegin ( other.myBegin ), myEnd ( other.myEnd ), myDistance ( other.myDistance ) {}

      SimpleRandomAccessConstRangeFromPoint& operator= ( const SimpleRandomAccessConstRangeFromPoint & other )
      {
        if ( this != &other )
        {
          myBegin = other.myBegin;
          myEnd = other.myEnd;
          myDistance = other.myDistance;
        }
 
        return *this;
      }

      ~SimpleRandomAccessConstRangeFromPoint() {}

      bool isValid() const
      {
        return true;
      }
 
      // ------------------------- display --------------------------------
      void selfDisplay ( std::ostream & out ) const
      {
        typedef typename IteratorCirculatorTraits<ConstIterator>::Value Value;
        out << "[SimpleRandomAccessConstRangeFromPoint]" << std::endl;
        out << "\t";
        std::copy ( myBegin, myEnd, std::ostream_iterator<Value> ( out, ", " ) );
        out << std::endl;
      }

      std::string className() const
      {
        return "SimpleRandomAccessConstRangeFromPoint";
      }
 
 
      // ------------------------- private data --------------------------------
 
    private:
      TConstIterator myBegin;
      TConstIterator myEnd;

      DistanceFunctor myDistance;
 
      // ------------------------- iterator services --------------------------------
 
    public:

      ConstIterator begin() const
      {
        return ConstIterator ( myBegin );
      }
 

      ConstIterator begin ( const Point &aPoint ) const
      {
        return ConstIterator ( myBegin ) + myDistance ( aPoint );
      }

      ConstIterator end() const
      {
        return ConstIterator ( myEnd );
      }

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

      ConstReverseIterator rbegin ( const Point &aPoint ) const
      {
        return ConstReverseIterator ( myBegin + myDistance ( aPoint ) + 1 );
      }
 

      ConstReverseIterator rend() const
      {
        return ConstReverseIterator ( myBegin );
      }

      ConstCirculator c() const
      {
        return ConstCirculator ( this->begin(), this->begin(), this->end() );
      }

      ConstReverseCirculator rc() const
      {
        return ConstReverseCirculator ( this->c() );
      }
 
  }; //end class SimpleRandomAccessConstRangeFromPoint
 
} // namespace DGtal

 
 
#endif // !defined SimpleRandomAccessConstRangeFromPoint_h
 
#undef SimpleRandomAccessConstRangeFromPoint_RECURSES
#endif // else defined(SimpleRandomAccessConstRangeFromPoint_RECURSES)