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 Data --------------------------------
  protected:
 
    Iterator myCurrentIt;
    Iterator myBeginIt;
    Iterator myEndIt;
    bool myFlagIsValid;
 
    // ------------------------- Private Data --------------------------------
  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)