MATHS/LINALG/randomAccessIterator.h

Go to the documentation of this file.

#ifndef BALL_LINALG_RANDOMACCESSITERATOR_H
#define BALL_LINALG_RANDOMACCESSITERATOR_H

#ifndef BALL_CONCEPT_BIDIRECTIONALITERATOR_H
#include <BALL/CONCEPT/bidirectionalIterator.h>
#endif

namespace BALL 
{
    typedef int Distance;
    typedef int Index;

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


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


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

    ~ConstRandomAccessIterator() {}



    
    ConstRandomAccessIterator& operator += (Distance distance);

    ConstRandomAccessIterator& operator -= (Distance distance);

    ConstRandomAccessIterator operator + (Distance distance) const;

    ConstRandomAccessIterator operator - (Distance distance) const;

    Distance operator - (const ConstRandomAccessIterator& iterator) const;

    static ConstRandomAccessIterator begin(const Container& container);

    static ConstRandomAccessIterator end(const Container& container);

    static ConstRandomAccessIterator rbegin(const Container& container);

    static ConstRandomAccessIterator rend(const Container& container);



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

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

    bool operator < (const ConstRandomAccessIterator& iterator) const;

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

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

    bool operator > (const ConstRandomAccessIterator& iterator) const;


      

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

    protected:

    ConstRandomAccessIterator(const Container& container)
      : Base(container)
    {
    }
  };
  
  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstRandomAccessIterator<Container, DataType, Position, Traits> operator + 
    (Distance distance, const ConstRandomAccessIterator<Container, DataType, Position, Traits>& iterator) 
  {
    ConstRandomAccessIterator<Container, DataType, Position, Traits> tmp_iterator(iterator);
    return (tmp_iterator += distance);
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  Distance ConstRandomAccessIterator<Container, DataType, Position, Traits>::operator -
    (const ConstRandomAccessIterator<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>
  ConstRandomAccessIterator<Container, DataType, Position, Traits>&
    ConstRandomAccessIterator<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().forward(distance);
    return *this;
  }

  template <typename Container, typename DataType, typename Position, typename Traits>
  ConstRandomAccessIterator<Container, DataType, Position, Traits>&
    ConstRandomAccessIterator<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().isEnd() == true)
    {
      Base::getTraits().toRBegin();
      Base::getTraits().backward(distance - 1);
    }
    else 
    {
      Base::getTraits().backward(distance);
    }
    return *this;
  }

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

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

  template <typename Container, typename DataType, typename Position, typename Traits>
  bool ConstRandomAccessIterator<Container, DataType, Position, Traits>::operator < 
    (const ConstRandomAccessIterator& 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 ConstRandomAccessIterator<Container, DataType, Position, Traits>::operator <= 
    (const ConstRandomAccessIterator& 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 ConstRandomAccessIterator<Container, DataType, Position, Traits>::operator >= 
    (const ConstRandomAccessIterator& 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 ConstRandomAccessIterator<Container, DataType, Position, Traits>::operator > 
    (const ConstRandomAccessIterator& 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& ConstRandomAccessIterator<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>
  ConstRandomAccessIterator<Container, DataType, Position, Traits> 
    ConstRandomAccessIterator<Container, DataType, Position, Traits>::begin(const Container& container)
  {
    ConstRandomAccessIterator iterator(container);
    iterator.toBegin();
    return iterator;
  }

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

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

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


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


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


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

    ~RandomAccessIterator() {}

    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 RandomAccessIterator begin(const Container& container);

    static RandomAccessIterator end(const Container& container);

    static RandomAccessIterator rbegin(const Container& container);

    static RandomAccessIterator rend(const Container& container);

    protected:

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

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

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

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

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

} // namespace BALL 

#endif // BALL_KERNEL_RANDOMACCESSITERATOR_H