TiledImageBidirectionalConstRangeFromPoint.h

 
#pragma once
 
#if defined(TiledImageBidirectionalConstRangeFromPoint_RECURSES)
#error Recursive header files inclusion detected in TiledImageBidirectionalConstRangeFromPoint.h
#else // defined(TiledImageBidirectionalConstRangeFromPoint_RECURSES)
 
#define TiledImageBidirectionalConstRangeFromPoint_RECURSES
 
#if !defined TiledImageBidirectionalConstRangeFromPoint_h
 
#define TiledImageBidirectionalConstRangeFromPoint_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"
 
namespace DGtal
{
 
 
  // class TiledImageBidirectionalConstRangeFromPoint
 
  template <typename TTiledImage>
 
  class TiledImageBidirectionalConstRangeFromPoint
  {
 
      BOOST_CONCEPT_ASSERT ( ( boost::BidirectionalIterator<typename TTiledImage::ConstIterator> ) );
 
      // ------------------------- inner types --------------------------------
 
    public:
      
      typedef TTiledImage TiledImage;
 
      typedef typename TiledImage::Point Point;
 
      typedef typename TiledImage::ConstIterator ConstIterator;
      typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;
 
      typedef Circulator<ConstIterator> ConstCirculator;
      typedef std::reverse_iterator<ConstCirculator> ConstReverseCirculator;
 
      // ------------------------- standard services --------------------------------
      
      TiledImageBidirectionalConstRangeFromPoint ( const TiledImage *ti )
        : myti ( ti ) {}
 
      TiledImageBidirectionalConstRangeFromPoint ( const TiledImageBidirectionalConstRangeFromPoint & other )
          : myti ( other.myti ) {}
 
      TiledImageBidirectionalConstRangeFromPoint& operator= ( const TiledImageBidirectionalConstRangeFromPoint & other )
      {
        if ( this != &other )
        {
          myti = other.myti;
        }
 
        return *this;
      }
 
      ~TiledImageBidirectionalConstRangeFromPoint() {}
 
      bool isValid() const
      {
        return true;
      }
 
      // ------------------------- display --------------------------------
      void selfDisplay ( std::ostream & out ) const
      {
        typedef typename IteratorCirculatorTraits<ConstIterator>::Value Value;
        out << "[TiledImageBidirectionalConstRangeFromPoint]" << std::endl;
        out << "\t";
        std::copy ( myti->begin(), myti->end(), std::ostream_iterator<Value> ( out, ", " ) );
        out << std::endl;
      }
 
      std::string className() const
      {
        return "TiledImageBidirectionalConstRangeFromPoint";
      }
 
 
      // ------------------------- private data --------------------------------
 
    private:
      
      const TTiledImage *myti;
 
    // ------------------------- iterator services --------------------------------
 
    public:
 
      ConstIterator begin() const
      {
        return ConstIterator ( myti->begin() );
      }
 
      ConstIterator begin ( const Point &aPoint ) const
      {
        return ConstIterator ( myti->begin(aPoint) );
      }
 
      ConstIterator end() const
      {
        return ConstIterator ( myti->end() );
      }
 
      ConstReverseIterator rbegin() const
      {
        return ConstReverseIterator ( this->end() );
      }
 
      ConstReverseIterator rbegin ( const Point &aPoint ) const
      {
        return ConstReverseIterator ( myti->rbegin(aPoint) );
      }
 
      ConstReverseIterator rend() const
      {
        return ConstReverseIterator ( this->begin() );
      }
 
      ConstCirculator c() const
      {
        return ConstCirculator ( this->begin(), this->begin(), this->end() );
      }
 
      ConstReverseCirculator rc() const
      {
        return ConstReverseCirculator ( this->c() );
      }
 
  }; //end class TiledImageBidirectionalConstRangeFromPoint
 
} // namespace DGtal
 
 
 
#endif // !defined TiledImageBidirectionalConstRangeFromPoint_h
 
#undef TiledImageBidirectionalConstRangeFromPoint_RECURSES
#endif // else defined(TiledImageBidirectionalConstRangeFromPoint_RECURSES)