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(), 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 {
      return ConstReverseCirculator( this->c() );
    }

  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)