CONCEPT/bidirectionalIterator.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_CONCEPT_BIDIRECTIONALITERATOR_H
#define BALL_CONCEPT_BIDIRECTIONALITERATOR_H

#ifndef BALL_CONCEPT_FORWARDITERATOR_H
# include <BALL/CONCEPT/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;   


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

    BALL_INLINE ~ConstBidirectionalIterator()  {}


    BALL_INLINE void toBegin();

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

    void toEnd();

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

    void toRBegin();

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

    void toREnd();

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

    BALL_INLINE ConstBidirectionalIterator& operator ++ ();

    BALL_INLINE ConstBidirectionalIterator operator ++ (int);

    BALL_INLINE ConstBidirectionalIterator& operator -- ();

    BALL_INLINE 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:

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

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toBegin()
  {
    BALL_PRECONDITION_EXCEPTION(!Base::getTraits().isSingular(), "cannot set unbound iterator to begin")
    Base::getTraits().toBegin();
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toEnd()
  {
    BALL_PRECONDITION_EXCEPTION(!Base::getTraits().isSingular(), "cannot set unbound iterator to end")
    Base::getTraits().toEnd();
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toRBegin()
  {
    BALL_PRECONDITION_EXCEPTION(!Base::getTraits().isSingular(), "cannot set unbound iterator to reverse begin")
    Base::getTraits().toRBegin();
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  void ConstBidirectionalIterator<Container, DataType, Position, Traits>::toREnd()
  { 
    BALL_PRECONDITION_EXCEPTION(!Base::getTraits().isSingular(), "cannot set unbound iterator to reverse end")
    Base::getTraits().toREnd();
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  ConstBidirectionalIterator<Container, DataType, Position, Traits>& 
    ConstBidirectionalIterator<Container, DataType, Position, Traits>::operator ++ ()
  {
    BALL_PRECONDITION_EXCEPTION(Base::getTraits().isValid(), "cannot increment an invalid iterator")
    Base::getTraits().forward();
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  ConstBidirectionalIterator<Container, DataType, Position, Traits> 
    ConstBidirectionalIterator<Container, DataType, Position, Traits>::operator ++ (int)
  {
    BALL_PRECONDITION_EXCEPTION(Base::getTraits().isValid(), "cannot increment an invalid iterator")
    ConstBidirectionalIterator iterator(*this);
    ++(*this);
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  ConstBidirectionalIterator<Container, DataType, Position, Traits>& 
    ConstBidirectionalIterator<Container, DataType, Position, Traits>::operator -- ()
  {
    BALL_PRECONDITION_EXCEPTION(!Base::getTraits().isSingular(), "cannot decrement unbound iterator")
    Base::getTraits().backward();
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  ConstBidirectionalIterator<Container, DataType, Position, Traits> 
    ConstBidirectionalIterator<Container, DataType, Position, Traits>::operator -- (int)
  {
    BALL_PRECONDITION_EXCEPTION(!Base::getTraits().isSingular(), "cannot decrement an unbound iterator")
    ConstBidirectionalIterator iterator(*this);
    --(*this);
    return iterator;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  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>
  BALL_INLINE
  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>
  BALL_INLINE
  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>
  BALL_INLINE
  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;


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

    BALL_INLINE ~BidirectionalIterator()  {}



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

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

    BALL_INLINE BidirectionalIterator& operator ++ ();

    BALL_INLINE BidirectionalIterator operator ++ (int);

    BALL_INLINE BidirectionalIterator& operator -- ();

    BALL_INLINE 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:

    BALL_INLINE BidirectionalIterator(const Container& container) ;
  };


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

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  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>
  BALL_INLINE
  BidirectionalIterator<Container, DataType, Position, Traits>& 
    BidirectionalIterator<Container, DataType, Position, Traits>::operator -- ()
  {
    Base::operator -- ();
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  BALL_INLINE
  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>
  BALL_INLINE
  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>
  BALL_INLINE
  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>
  BALL_INLINE
  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>
  BALL_INLINE
  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>
  BALL_INLINE
  BidirectionalIterator<Container, DataType, Position, Traits>::BidirectionalIterator(const Container& container)
    
    : ConstBidirectionalIterator<Container, DataType, Position, Traits>(container)
  {
  }


} // namespace BALL 

#endif // BALL_CONCEPT_BIDIRECTIONALITERATOR_H