ConstRangeAdapter.h

 
#pragma once
 
#if defined(ConstRangeAdapter_RECURSES)
#error Recursive header files inclusion detected in ConstRangeAdapter.h
#else // defined(ConstRangeAdapter_RECURSES)
#define ConstRangeAdapter_RECURSES
 
#if !defined ConstRangeAdapter_h
#define ConstRangeAdapter_h
 
// Inclusions
#include "DGtal/base/BasicFunctors.h"
//#include "boost/iterator/reverse_iterator.hpp"
#include "DGtal/base/ReverseIterator.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/base/ConstIteratorAdapter.h"
#include "boost/concept_check.hpp"
 
namespace DGtal 
{
 
 
  // class ConstRangeAdapter
 
  template <typename TIterator, typename TFunctor, typename TReturnType>
  class ConstRangeAdapter
  {
 
  BOOST_CONCEPT_ASSERT(( boost_concepts::ReadableIteratorConcept<TIterator> ));
  BOOST_CONCEPT_ASSERT(( boost_concepts::BidirectionalTraversalConcept<TIterator> ));
 
    // ------------------------- inner types --------------------------------
  public: 
  
    typedef ConstIteratorAdapter<TIterator,TFunctor,TReturnType> ConstIterator; 
    typedef ReverseIterator<ConstIterator> ConstReverseIterator;
 
    typedef Circulator<ConstIterator> ConstCirculator;
    typedef ReverseIterator<ConstCirculator> ConstReverseCirculator;
 
    typedef typename IteratorCirculatorTraits<ConstIterator>::Difference Difference; 
    // ------------------------- standard services --------------------------------
 
    ConstRangeAdapter(const TIterator& itb, const TIterator& ite, 
                      const TFunctor& aFunctor )
      : myBegin(itb), myEnd(ite), myFunctor(&aFunctor), myFlagIsOwned(false) {}
 
    ConstRangeAdapter(const TIterator& itb, const TIterator& ite, 
                      const TFunctor* aFunctorPtr )
      : myBegin(itb), myEnd(ite), myFunctor(aFunctorPtr), myFlagIsOwned(true) {}
 
    ConstRangeAdapter( const ConstRangeAdapter & other )
      : myBegin(other.myBegin), myEnd(other.myEnd), myFlagIsOwned(other.myFlagIsOwned) 
      { 
  if (myFlagIsOwned)
    myFunctor = new TFunctor( *other.myFunctor ); //owned copy
  else
    myFunctor = other.myFunctor; //copy of the alias
      }    
 
    ~ConstRangeAdapter() 
      {
        if (myFlagIsOwned) delete myFunctor; 
      }
 
    bool isValid() const { return true; }
 
    Difference size() const
      {
        typedef typename IteratorCirculatorTraits<TIterator>::Category Category; 
        return size( myBegin, myEnd, Category() );
      }
  
    // ------------------------- display --------------------------------
    void selfDisplay ( std::ostream & out ) const 
    {
      out << "[ConstRangeAdapter]" << std::endl; 
      out << "\t"; 
      std::copy( this->begin(), this->end(), std::ostream_iterator<TReturnType>(out, ", ") ); 
      out << std::endl; 
    }
 
    std::string className() const
    {
      return "ConstRangeAdapter";
    }
  
 
    // ------------------------- private data --------------------------------
  private: 
    TIterator myBegin; 
    TIterator myEnd; 
    const TFunctor* myFunctor; 
    bool myFlagIsOwned; 
 
    // ------------------------- private methods --------------------------------
   private:
  
    ConstRangeAdapter& operator= ( const ConstRangeAdapter & other );
 
    // ------------------------- iterator services --------------------------------
  public:
 
    ConstIterator begin() const {
      return ConstIterator( myBegin, *myFunctor );
    }
 
    ConstIterator end() const {
      return ConstIterator( myEnd, *myFunctor );
    }
 
    ConstReverseIterator rbegin() const {
      return ConstReverseIterator(this->end());
    }
 
    ConstReverseIterator rend() const {
      return ConstReverseIterator(this->begin());
    }
 
    ConstCirculator c() const {
      return ConstCirculator( this->begin(), this->begin(), this->end() );
    }
 
    ConstReverseCirculator rc() const {
      //implemented so that *rc() == *c()
      ConstCirculator tmp = this->c();
      ++tmp; 
      return ConstReverseCirculator( tmp );
    }
 
  private: 
 
    Difference size(const TIterator& itb, const TIterator& ite,  RandomAccessCategory) const
      {
        return (ite-itb); 
      }
 
    Difference size(const TIterator& itb, const TIterator& ite,  BidirectionalCategory) const
      {
        TIterator it = itb; 
        unsigned int d = 0;
        for ( ; it != ite; ++it, ++d)
          {}
        return d; 
      }
 
  }; //end class ConstRangeAdapter
 
  template <typename TIterator, typename TFunctor, typename TReturnType>
  std::ostream&
  operator<< ( std::ostream & out, const ConstRangeAdapter<TIterator, TFunctor, TReturnType> & object )
   {
     object.selfDisplay( out ); 
     return out; 
   } 
 
  template <typename A, typename B>
  std::ostream&
  operator<< ( std::ostream & out, const std::pair<A, B> & object )
   {
     out << object.first << "|" << object.second; 
     return out; 
   } 
} // namespace DGtal
 
 
 
#endif // !defined ConstRangeAdapter_h
 
#undef ConstRangeAdapter_RECURSES
#endif // else defined(ConstRangeAdapter_RECURSES)