MATHS/LINALG/bidirectionalIterator.h

Go to the documentation of this file.

#ifndef BALL_LINALG_BIDIRECTIONALITERATOR_H
#define BALL_LINALG_BIDIRECTIONALITERATOR_H

#ifndef BALL_LINALG_FORWARDITERATOR_H
# include <BALL/MATHS/LINALG/forwardIterator.h>
#endif

namespace BALL 
{


  template <typename Container, typename DataType, typename Position, typename Traits>
  class ConstBidirectionalIterator
    : public ConstForwardIterator<Container, DataType, Position, Traits>
  {
    public:


    typedef std::bidirectional_iterator_tag iterator_category;
    // convenience typedef
    typedef ConstForwardIterator<Container, DataType, Position, Traits> Base;   


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

    ~ConstBidirectionalIterator() {}


    void toBegin();

    bool isBegin() const { return Base::getTraits().isBegin(); }

    void toEnd();

    bool isEnd() const { return Base::getTraits().isEnd(); }

    void toRBegin();

    bool isRBegin() const { return Base::getTraits().isRBegin(); }

    void toREnd();

    bool isREnd() const { return Base::getTraits().isREnd(); }

    ConstBidirectionalIterator& operator ++ ();

    ConstBidirectionalIterator operator ++ (int);

    ConstBidirectionalIterator& operator -- ();

    ConstBidirectionalIterator operator -- (int);

    static ConstBidirectionalIterator begin(const Container& container);

    static ConstBidirectionalIterator end(const Container& container);

    static ConstBidirectionalIterator rbegin(const Container& container);

    static ConstBidirectionalIterator rend(const Container& container);

    protected:

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

  template <typename Container, typename DataType, typename Position, typename Traits>
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toBegin()
  {
      if (Base::getTraits().isSingular())
      {
        Exception::SingularIterator e;
        throw(e);
      }
    Base::getTraits().toBegin();
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toEnd()
  {
      if (Base::getTraits().isSingular())
      {
        Exception::SingularIterator e;
        throw(e);
      }
    Base::getTraits().toEnd();
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toRBegin()
  {
      if (Base::getTraits().isSingular())
      {
        Exception::SingularIterator e;
        throw(e);
      }
    Base::getTraits().toRBegin();
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toREnd()
  { 
      if (Base::getTraits().isSingular())
      {
        Exception::SingularIterator e;
        throw(e);
      }
    Base::getTraits().toREnd();
  }

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

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

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

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

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

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

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

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

  template <typename Container, typename DataType, typename Position, typename Traits>
  class BidirectionalIterator
    : public ConstBidirectionalIterator<Container, DataType, Position, Traits>
  {
    public:

    
    typedef DataType& reference;
    typedef DataType* pointer;
    // convenience typedef
    typedef ConstBidirectionalIterator<Container, DataType, Position, Traits> Base;


    BidirectionalIterator() {}
  
    BidirectionalIterator(const BidirectionalIterator& iterator)
      : ConstBidirectionalIterator<Container, DataType, Position, Traits>(iterator)
    {
    }

    ~BidirectionalIterator() {}



    reference operator * () const { return (reference)Base::getTraits().getData(); }

    pointer operator -> () const { return (pointer)&Base::getTraits().getData(); }

    BidirectionalIterator& operator ++ ();

    BidirectionalIterator operator ++ (int);

    BidirectionalIterator& operator -- ();

    BidirectionalIterator operator -- (int);

    static BidirectionalIterator begin(const Container& container);

    static BidirectionalIterator end(const Container& container);

    static BidirectionalIterator rbegin(const Container& container);

    static BidirectionalIterator rend(const Container& container);

    protected:

    BidirectionalIterator(const Container& container);
  };


  template <typename Container, typename DataType, typename Position, typename Traits>
  BidirectionalIterator<Container, DataType, Position, Traits>& 
    BidirectionalIterator<Container, DataType, Position, Traits>::operator ++ ()
  {
    Base::operator ++ ();
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BidirectionalIterator<Container, DataType, Position, Traits> 
    BidirectionalIterator<Container, DataType, Position, Traits>::operator ++ (int)
  {
    BidirectionalIterator iterator(*this);
    this->operator ++ ();
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BidirectionalIterator<Container, DataType, Position, Traits>& 
    BidirectionalIterator<Container, DataType, Position, Traits>::operator -- ()
  {
    Base::operator -- ();
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BidirectionalIterator<Container, DataType, Position, Traits> 
    BidirectionalIterator<Container, DataType, Position, Traits>::operator -- (int)
  {
    BidirectionalIterator iterator(*this);
    this->operator -- ();
    return iterator;
  }

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

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

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

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

  template <typename Container, typename DataType, typename Position, typename Traits>
  BidirectionalIterator<Container, DataType, Position, Traits>::BidirectionalIterator(const Container& container)
    : ConstBidirectionalIterator<Container, DataType, Position, Traits>(container)
  {
  }


} // namespace BALL 

#endif // BALL_KERNEL_BIDIRECTIONALITERATOR_H