SimpleRandomAccessRangeFromPoint.h

#pragma once

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

#define SimpleRandomAccessRangeFromPoint_RECURSES

#if !defined SimpleRandomAccessRangeFromPoint_h

#define SimpleRandomAccessRangeFromPoint_h

// Inclusions
#include "DGtal/base/BasicFunctors.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/base/IteratorAdapter.h"
#include "DGtal/base/CBidirectionalRangeFromPoint.h"
#include "boost/concept_check.hpp"

namespace DGtal
{


  // class SimpleRandomAccessRangeFromPoint

  template <typename TConstIterator, typename TIterator, typename DistanceFunctor>

  class SimpleRandomAccessRangeFromPoint
  {

      BOOST_CONCEPT_ASSERT ( ( boost::RandomAccessIterator<TIterator> ) );
      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 TIterator Iterator;
      typedef TConstIterator ConstIterator;

      typedef std::reverse_iterator<Iterator> ReverseIterator;
      typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;

      typedef TIterator OutputIterator;
      typedef std::reverse_iterator<Iterator> ReverseOutputIterator;

      // typedef Circulator<Iterator> Circulator;
      // typedef std::reverse_iterator<Circulator> ReverseCirculator;

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

      SimpleRandomAccessRangeFromPoint ( const TIterator& itb,
                                         const TIterator& ite,
                                         const DistanceFunctor & aDistance )
          : myBegin ( itb ), myEnd ( ite ), myDistance ( aDistance ) {}

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

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

        return *this;
      }

      ~SimpleRandomAccessRangeFromPoint() {}

      bool isValid() const
      {
        return true;
      }

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

      std::string className() const
      {
        return "SimpleRandomAccessRangeFromPoint";
      }


      // ------------------------- private data --------------------------------

    private:
      TIterator myBegin;
      TIterator myEnd;

      DistanceFunctor myDistance;

      // ------------------------- iterator services --------------------------------

    public:

      Iterator begin()
      {
        return Iterator ( myBegin );
      }


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

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


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

      Iterator end()
      {
        return Iterator ( myEnd );
      }

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

      OutputIterator outputIterator()
      {
        return OutputIterator ( myBegin );
      }

      OutputIterator outputIterator ( const Point &aPoint )
      {
        return OutputIterator ( myBegin ) + myDistance ( aPoint ) ;
      }

      ReverseOutputIterator routputIterator()
      {
        return ReverseOutputIterator ( myBegin );
      }

      ReverseOutputIterator routputIterator ( const Point &aPoint )
      {
        return ReverseOutputIterator ( myBegin ) + myDistance ( aPoint ) ;
      }



      ReverseIterator rbegin()
      {
        return ReverseIterator ( this->end() );
      }

      ReverseIterator rbegin ( const Point &aPoint )
      {
        return ReverseIterator ( this->end() + myDistance ( aPoint ) );
      }


      ReverseIterator rend()
      {
        return ReverseIterator ( this->begin() );
      }


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

      ConstReverseIterator rbegin ( const Point &aPoint ) const
      {
        return ConstReverseIterator ( this->end() + myDistance ( aPoint ) );
      }


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

      // /**
      //  * Circulator service.
      //  * @return a circulator
      //  */
      // Circulator c() const
      // {
      //   return Circulator ( this->begin(), this->begin(), this->end() );
      // }

      // /**
      //  * Circulator service.
      //  * @return a reverse circulator
      //  */
      // ReverseCirculator rc() const
      // {
      //   return ReverseCirculator ( this->c() );
      // }

  }; //end class SimpleRandomAccessRangeFromPoint

} // namespace DGtal



#endif // !defined SimpleRandomAccessRangeFromPoint_h

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