reverseIterator.h

Go to the documentation of this file.

#ifndef BALL_LINALG_REVERSEITERATOR_H
#define BALL_LINALG_REVERSEITERATOR_H

#ifndef BALL_CONCEPT_RANDOMACCESSITERATOR_H
#include <BALL/CONCEPT/randomAccessIterator.h>
#endif

#include <BALL/MATHS/LINALG/linalgException.h>

namespace BALL 
{
    typedef int Distance;
    typedef int Index;

  template <typename Container, typename DataType, typename Position, typename Traits>
  class ConstReverseIterator
    : public ConstRandomAccessIterator<Container, DataType, Position, Traits>
  {
    public:


    typedef std::random_access_iterator_tag iterator_category;
    // convenience typedef
    typedef ConstRandomAccessIterator<Container, DataType, Position, Traits> Base;


    ConstReverseIterator() {}
  
    ConstReverseIterator(const ConstReverseIterator& iterator)
      : Base(iterator)
    {
    }

    ~ConstReverseIterator() {}



    
    ConstReverseIterator& operator += (Distance distance);

    ConstReverseIterator& operator -= (Distance distance);

    ConstReverseIterator operator + (Distance distance) const;

    ConstReverseIterator operator - (Distance distance) const;

    Distance operator - (const ConstReverseIterator& iterator) const;

    static ConstReverseIterator begin(const Container& container);

    static ConstReverseIterator end(const Container& container);

    static ConstReverseIterator rbegin(const Container& container);

    static ConstReverseIterator rend(const Container& container);

    ConstReverseIterator& operator ++ ();

    ConstReverseIterator operator ++ (int);

    ConstReverseIterator& operator -- ();

    ConstReverseIterator operator -- (int);




    bool operator + () const { return Base::getTraits().isValid(); }

    bool operator - () const { return !Base::getTraits().isValid(); }

    bool operator < (const ConstReverseIterator& iterator) const;

    bool operator <= (const ConstReverseIterator& iterator) const;

    bool operator >= (const ConstReverseIterator& iterator) const;

    bool operator > (const ConstReverseIterator& iterator) const;


      

    const DataType& operator [] (Index index) const;

    protected:

    ConstReverseIterator(const Container& container)
      : Base(container)
    {
    }
  };

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits>& 
    ConstReverseIterator<Container, DataType, Position, Traits>::operator ++ ()
  {
      if (!Base::getTraits().isValid())
      {
        Exception::InvalidIterator e;
        throw(e);
      }
    Base::getTraits().backward();
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> 
    ConstReverseIterator<Container, DataType, Position, Traits>::operator ++ (int)
  {
      if (!Base::getTraits().isValid())
      {
        Exception::InvalidIterator e;
        throw(e);
      }
    ConstReverseIterator iterator(*this);
    ++(*this);
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits>& 
    ConstReverseIterator<Container, DataType, Position, Traits>::operator -- ()
  { 
      if (Base::getTraits().isSingular())
      {
        Exception::SingularIterator e;
        throw(e);
      }
    Base::getTraits().forward();
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> 
    ConstReverseIterator<Container, DataType, Position, Traits>::operator -- (int)
  { 
      if (Base::getTraits().isSingular())
      {
        Exception::SingularIterator e;
        throw(e);
      }
    ConstReverseIterator iterator(*this);
    --(*this);
    return iterator;
  }
  
  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> operator + 
    (Distance distance, const ConstReverseIterator<Container, DataType, Position, Traits>& iterator) 
  {
    ConstReverseIterator<Container, DataType, Position, Traits> tmp_iterator(iterator);
    return (tmp_iterator += distance);
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  Distance ConstReverseIterator<Container, DataType, Position, Traits>::operator -
    (const ConstReverseIterator<Container, DataType, Position, Traits>& b) const
  {
    if (!Base::getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (!b.getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (Base::getTraits().getContainer() != b.getTraits().getContainer())
    {
      Exception::IncompatibleIterators e;
      throw e;
    }
    return Base::getTraits().getDistance(b.getTraits());
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits>&
    ConstReverseIterator<Container, DataType, Position, Traits>::operator += (Distance distance)
  {
    if (!Base::getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (distance < (Distance)0)
    {
      return (*this -= -distance);
    }
    Base::getTraits().backward(distance);
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits>&
    ConstReverseIterator<Container, DataType, Position, Traits>::operator -= (Distance distance)
  {
    if (Base::getTraits().isSingular())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (distance < (Distance)0)
    {
      return (*this += -distance);
    }
    if (Base::getTraits().isREnd() == true)
    {
      Base::getTraits().toBegin();
      Base::getTraits().forward(distance - 1);
    }
    else 
    {
      Base::getTraits().forward(distance);
    }
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits>
    ConstReverseIterator<Container, DataType, Position, Traits>::operator + (Distance distance) const
  {
    ConstReverseIterator iterator(*this);
    return (iterator += distance);
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> 
    ConstReverseIterator<Container, DataType, Position, Traits>::operator - (Distance distance) const
  {
    ConstReverseIterator iterator(*this);
    return (iterator -= distance);
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  bool ConstReverseIterator<Container, DataType, Position, Traits>::operator < 
    (const ConstReverseIterator& iterator) const
  {
    if (!Base::getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (!iterator.isValid())
    {
      Exception::InvalidIterator e;
      throw e;        
    }
    if (Base::getTraits().getContainer() != iterator.getContainer())
    {
      Exception::IncompatibleIterators e;
      throw e;
    }

    return !(Base::getTraits().operator < (iterator.getTraits()));
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  bool ConstReverseIterator<Container, DataType, Position, Traits>::operator <= 
    (const ConstReverseIterator& iterator) const
  {
    if (!Base::getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;  
    }
    if (!iterator.isValid())
    {
      Exception::InvalidIterator e;
      throw e;  
    }
    if (Base::getTraits().getContainer() != iterator.getContainer())
    {
      Exception::IncompatibleIterators e;
      throw e;
    }
    return (Base::getTraits().operator > (iterator.getTraits()));
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  bool ConstReverseIterator<Container, DataType, Position, Traits>::operator >= 
    (const ConstReverseIterator& iterator) const
  {
    if (!Base::getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (!iterator.isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (Base::getTraits().getContainer() != iterator.getContainer())
    {
      Exception::IncompatibleIterators e;
      throw e;
    }

    return (Base::getTraits().operator < (iterator.getTraits()));
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  bool ConstReverseIterator<Container, DataType, Position, Traits>::operator > 
    (const ConstReverseIterator& iterator) const
  {
    if (!Base::getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (!iterator.isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }
    if (Base::getTraits().getContainer() != iterator.getContainer())
    {
      Exception::IncompatibleIterators e;
      throw e;
    }

    return !(Base::getTraits().operator > (iterator.getTraits()));
  }

  
  template <typename Container, typename DataType, typename Position, typename Traits>
  const DataType& ConstReverseIterator<Container, DataType, Position, Traits>::operator [] (Index index) const
  {
    if (!Base::getTraits().isValid())
    {
      Exception::InvalidIterator e;
      throw e;
    }

    return Base::getTraits().getData(index);
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> 
    ConstReverseIterator<Container, DataType, Position, Traits>::begin(const Container& container)
  {
    ConstReverseIterator iterator(container);
    iterator.toRBegin();
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> 
    ConstReverseIterator<Container, DataType, Position, Traits>::end(const Container& container)
  {
    ConstReverseIterator iterator(container);
    iterator.toREnd();
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> 
    ConstReverseIterator<Container, DataType, Position, Traits>::rbegin(const Container& container)
  {
    ConstReverseIterator iterator(container);
    iterator.toBegin();
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstReverseIterator<Container, DataType, Position, Traits> 
    ConstReverseIterator<Container, DataType, Position, Traits>::rend(const Container& container)
  {
    ConstReverseIterator iterator(container);
    iterator.toEnd();
    return iterator;
  }


  template <typename Container, typename DataType, typename Position, typename Traits>
  class ReverseIterator
    : public ConstReverseIterator<Container, DataType, Position, Traits>
  {
    public:


          typedef DataType& reference;
    typedef DataType* pointer;
    typedef ConstReverseIterator<Container, DataType, Position, Traits> Base;


    ReverseIterator() {}
  
    ReverseIterator(const ReverseIterator& iterator)
      : Base(iterator)
    {
    }

    ~ReverseIterator() {}

    reference operator [] (Index index) const { return const_cast<reference>(Base::getTraits().getData(index)); }
    reference operator * () const { return const_cast<reference>(Base::getTraits().getData()); }
    pointer operator -> () const { return const_cast<pointer>(&Base::getTraits().getData()); }

    static ReverseIterator begin(const Container& container);

    static ReverseIterator end(const Container& container);

    static ReverseIterator rbegin(const Container& container);

    static ReverseIterator rend(const Container& container);

    protected:

    ReverseIterator(const Container& container)
      : Base(container)
    {
    }

  };
  
  template <typename Container, typename DataType, typename Position, typename Traits>
  ReverseIterator<Container, DataType, Position, Traits> 
    ReverseIterator<Container, DataType, Position, Traits>::begin(const Container& container)
  {
    ReverseIterator iterator(container);
    iterator.toRBegin();
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ReverseIterator<Container, DataType, Position, Traits> 
    ReverseIterator<Container, DataType, Position, Traits>::end(const Container& container)
  {
    ReverseIterator iterator(container);
    iterator.toREnd();
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ReverseIterator<Container, DataType, Position, Traits> 
    ReverseIterator<Container, DataType, Position, Traits>::rbegin(const Container& container)
  {
    ReverseIterator iterator(container);
    iterator.toBegin();
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ReverseIterator<Container, DataType, Position, Traits> 
    ReverseIterator<Container, DataType, Position, Traits>::rend(const Container& container)
  {
    ReverseIterator iterator(container);
    iterator.toEnd();
    return iterator;
  }

} // namespace BALL 

#endif // BALL_KERNEL_REVERSEITERATOR_H