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/IteratorCirculatorTraits.h"
 
namespace DGtal
{
 
 
  // template class Circulator
  template <typename TIterator>
  class Circulator
  {
 
    BOOST_STATIC_ASSERT(( boost::is_same< 
                            typename IteratorCirculatorTraits<TIterator>::Type, 
                            IteratorType >::value ));
 
    // ----------------------- Types ------------------------------
  public:
 
      typedef TIterator                                           Iterator;
      typedef Circulator<TIterator>                               Self;
 
      typedef CirculatorType                                      Type; 
 
      typedef typename boost::iterator_category<TIterator>::type
                                                                     iterator_category;
 
    typedef typename std::iterator_traits<TIterator>::value_type        value_type;
    typedef typename std::iterator_traits<TIterator>::difference_type   difference_type;
    typedef typename std::iterator_traits<TIterator>::pointer           pointer;
    typedef typename std::iterator_traits<TIterator>::reference         reference;
 
 
 
    // ----------------------- Standard services ------------------------------
  public:
 
    Circulator() : myCurrentIt(), myBeginIt(), myEndIt(), myFlagIsValid(false) {}
 
 
    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 ( ( (!isValid())&&(!other.isValid()) )
               || 
               ( ( isValid() && other.isValid())
                 &&
                 ( (myBeginIt == other.begin())
                   &&(myEndIt == other.end())
                   &&(myCurrentIt == other.base())
                   )
                 )
               ); 
    }
    bool operator!=( const Self& other) const { return !(*this == other); }
 
    template<typename OtherIterator>
    bool operator==( const OtherIterator& other) const 
    { 
      return ( ( (!isValid())&&(!other.isValid()) )
               || 
               ( ( isValid() && other.isValid())
                 &&
                 ( (myBeginIt == other.begin())
                   &&(myEndIt == other.end())
                   &&(myCurrentIt == other.base())
                   )
                 )
               ); 
    }
    template<typename OtherIterator>
    bool operator!=( const OtherIterator& other) const { return !(*this == other); }
 
 
    // ----------------------- Random access operators --------------------------------------
  public:
 
    Self& operator+=( difference_type d ) 
    {
      if ( isValid() )
        {
          //size range
          typename Iterator::difference_type n = myEndIt - myBeginIt;
          ASSERT( n > 0 );
          //difference modulo n
          if ( (d >= n)||(-d >= n) )
            d = d%n; 
          ASSERT( (d < n)&&(-d < n) );
          //position of the current iterator
          typename Iterator::difference_type j = myCurrentIt - myBeginIt;
          ASSERT( (j >= 0) && (j < n) );
          //deviation between the position of the past-the-end value 
          //and the current iterator
          typename Iterator::difference_type e = n - j;
          if (d >= 0)
            { //in case of positive distance
              if (d < e) j += d;
              else j = d - e; 
            }
          else 
            { //in case of negative distance
              if (-d <= j) j += d; 
              else j = j + d + n; 
            }
          ASSERT( (j >= 0) && (j < n) );
          myCurrentIt = myBeginIt + j;
          return *this;
        }
      else
        return *this; 
    }
 
    Self& operator-=( difference_type d) { return operator+=( -d); }
 
    Self operator+( difference_type d) const 
    {
        Self tmp = *this;
        return tmp += d;
    }
 
    Self operator-( difference_type d) const 
    {
        Self tmp = *this;
        return tmp += -d;
    }
 
    difference_type operator-( const Self& c) const 
    {
        typename Iterator::difference_type d = (myCurrentIt - c.myCurrentIt);
        if (d >= 0)
          return d; 
        else 
          {
            typename Iterator::difference_type n = myEndIt - myBeginIt;
            ASSERT( n > 0 );
            return (n + d); 
          }
    }
    reference operator[]( difference_type d) const 
    {
        Self tmp = *this;
        tmp += d;
        return *tmp;
    }
 
    // ----------------------- Comparisons operators --------------------------------------
    bool operator<( const Self& /*c*/) const 
    {
      return true; 
    }
    bool operator<=( const Self& /*c*/) const 
    {
      return true; 
    }
    bool operator>( const Self& c) const 
    {
      return !operator<=(c); 
    }
    bool operator>=( const Self& c) const 
    {
      return !operator>(c); 
    }
 
 
    // ------------------------- Protected Datas --------------------------------
  protected:
 
    Iterator myCurrentIt; 
    Iterator myBeginIt; 
    Iterator myEndIt; 
    bool myFlagIsValid; 
 
    // ------------------------- Private Datas --------------------------------
  private:
 
 
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
 
 
  private:
 
 
  }; // end of class Circulator
 
 
  template <typename TIterator>
  Circulator<TIterator> 
  operator+(typename IteratorCirculatorTraits<TIterator>::Difference d, 
            Circulator<TIterator> & object )
  {
    Circulator<TIterator> tmp = object;
    return tmp += d;
  }
 
 
} // 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)