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)