Circulator.h

#pragma once

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

#define Circulator_RECURSES

#if !defined Circulator_h

#define Circulator_h

// Inclusions
#include<iterator>
#include "DGtal/base/IteratorTraits.h"

namespace DGtal
{


  // template class Circulator
  template <typename TIterator>
  class Circulator
  {

    // ----------------------- Types ------------------------------
  public:

      typedef TIterator                                           Iterator;
      typedef Circulator<TIterator>                               Self;

      typedef CirculatorType                                      Type; 

      typedef typename boost::iterator_category<TIterator>::type
                                                                     iterator_category;

      typedef typename iterator_traits<TIterator>::value_type        value_type;
      typedef typename iterator_traits<TIterator>::difference_type   difference_type;
      typedef typename iterator_traits<TIterator>::pointer           pointer;
      typedef typename iterator_traits<TIterator>::reference         reference;



    // ----------------------- Standard services ------------------------------
  public:

    Circulator() : myCurrentIt(), myBeginIt(), myEndIt(), myFlagIsValid(false) {}


    explicit
    Circulator(const Iterator& i,
               const Iterator& itb, 
               const Iterator& ite) 
     : myCurrentIt(i), myBeginIt(itb), myEndIt(ite), myFlagIsValid(true) 
    { if (myBeginIt == myEndIt) myFlagIsValid = false; }

    ~Circulator() {}

    Circulator ( const Circulator & other )
    : myCurrentIt(other.myCurrentIt), 
      myBeginIt(other.myBeginIt), myEndIt(other.myEndIt), 
      myFlagIsValid(other.myFlagIsValid)  
    {}

    template<typename other_Iterator>
    Circulator ( const Circulator<other_Iterator>& other )
    : myCurrentIt(other.base()), 
      myBeginIt(other.begin()), myEndIt(other.end()), 
      myFlagIsValid(other.isValid())  
    {}

    Circulator & operator= ( const Circulator & other ) 
    {
      if ( this != &other )
        {
          myCurrentIt = other.myCurrentIt;
          myBeginIt = other.myBeginIt;
          myEndIt = other.myEndIt;
          if (myBeginIt != myEndIt) 
            myFlagIsValid = true; 
          else 
            myFlagIsValid = false;
        }
      return *this;
    }

    template<typename other_Iterator>
    Circulator & operator= ( const Circulator<other_Iterator>& other )
    {
      if ( this != &other )
        {
          myCurrentIt = other.base();
          myBeginIt = other.begin();
          myEndIt = other.end();
          if (myBeginIt != myEndIt) 
            myFlagIsValid = true; 
          else 
            myFlagIsValid = false;
        }
      return *this;
    }

    bool isValid() const 
    { return myFlagIsValid; }


    // ----------------------- Interface --------------------------------------
  public:

    Iterator base() const
    { return myCurrentIt; }

    Iterator begin() const
    { return myBeginIt; }

    Iterator end() const
    { return myEndIt; }

    reference operator*() const { 
     //ASSERT( myCurrentIt != myEndIt ); //myCurrentIt == myEndIt when using reverse iterators on circulators
     ASSERT( isValid() ); 
     return *myCurrentIt; 
    }

    pointer operator->() const { 
     //ASSERT( myCurrentIt != myEndIt ); //myCurrentIt == myEndIt when using reverse iterators on circulators
     ASSERT( isValid() ); 
     return myCurrentIt.operator->(); 
    }


    // ----------------------- Incrementation/Decrementation --------------------------------------
  public:

      Self& operator++()
      {
        ASSERT( isValid() ); 
        ++myCurrentIt;
        if (myCurrentIt == myEndIt) myCurrentIt = myBeginIt;
        return *this;
      }

      Self operator++(int)
      {
        Self tmp = *this;
        operator++(); 
        return tmp;
      }


      Self& operator--()
      {
        ASSERT( isValid() ); 
        if (myCurrentIt == myBeginIt) myCurrentIt = myEndIt;
        --myCurrentIt;
        return *this;
      }

      Self operator--(int)
      {
        Self tmp = *this;
        operator--(); 
        return tmp;
      }

    // ----------------------- Equality operators --------------------------------------
  public:

    //'true' if their three underlying iterators are equal
    //or if their underlying ranges are both empty,
    //'false' otherwise
    bool operator==( const Self& other) const { 
        return ( ( (myBeginIt == other.begin())
                 &&(myEndIt == other.end())
                 &&(myCurrentIt == other.base()) ) 
               ||( (!isValid())&&(!other.isValid()) ) ); 
    }
    bool operator!=( const Self& other) const { return !(*this == other); }

    template<typename OtherIterator>
    bool operator==( const OtherIterator& other) const { 
        return ( ( (myBeginIt == other.begin())
                 &&(myEndIt == other.end())
                 &&(myCurrentIt == other.base()) ) 
               ||( (!isValid())&&(!other.isValid()) ) ); 
    }
    template<typename OtherIterator>
    bool operator!=( const OtherIterator& other) const { return !(*this == other); }


    // ----------------------- Random access operators --------------------------------------
  public:

    Self& operator+=( difference_type d ) {
        ASSERT( isValid() ); 
        typename Iterator::difference_type j = myCurrentIt - myBeginIt;
        typename Iterator::difference_type n = myEndIt - myBeginIt;
        ASSERT( n > 0 );
        ASSERT( (j >= 0) && (j < n) );
        typename Iterator::difference_type e = n - j;        
        if (d < e) j += d;
        else j = d - e; 
        ASSERT( (j >= 0) && (j < n) );
        myCurrentIt = myBeginIt + j;
        return *this;
    }
    Self operator+( difference_type d) const {
        Self tmp = *this;
        return tmp += d;
    }
    Self operator-( difference_type d) const {
        Self tmp = *this;
        return tmp += -d;
    }
    Self& operator-=( difference_type d) { return operator+=( -d); }

    difference_type operator-( const Self& c) const {
        ASSERT( isValid() );
        ASSERT( c.isValid() );
        return myCurrentIt - c.myCurrentIt;
    }
    reference operator[]( difference_type d) const {
        Self tmp = *this;
        tmp += d;
        return *tmp;
    }

    // ----------------------- Comparisons operators --------------------------------------
    // Contrary to iterators, random access circulators have no comparison operators. 


    // ------------------------- Protected Datas --------------------------------
  protected:

    Iterator myCurrentIt; 
    Iterator myBeginIt; 
    Iterator myEndIt; 
    bool myFlagIsValid; 

    // ------------------------- Private Datas --------------------------------
  private:



    // ------------------------- Hidden services ------------------------------
  protected:



  private:


  }; // end of class Circulator


} // namespace DGtal

#include "DGtal/base/IteratorFunctions.h"

// Includes inline functions.
//#include "DGtal/base/Circulator.ih"

//                                                                           //

#endif // !defined Circulator_h

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