IndirectIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_IndirectIterator_h__)
#define __ads_IndirectIterator_h__

#include "AdaptedIterator.h"

BEGIN_NAMESPACE_ADS


template<typename _Iterator>
class IndirectIterator :
  public AdaptedIterator<
  _Iterator,
  typename std::iterator_traits<_Iterator>::iterator_category,
  typename std::iterator_traits< 
  typename std::iterator_traits<_Iterator>::value_type >::value_type,
  typename std::iterator_traits<_Iterator>::difference_type,
  /*
  typename std::iterator_traits< 
  typename std::iterator_traits<Iterator>::value_type >::pointer,
  */
  typename std::iterator_traits<_Iterator>::value_type,
  typename std::iterator_traits< 
  typename std::iterator_traits<_Iterator>::value_type >::reference> {
private:

  //
  // Private types.
  //

  typedef AdaptedIterator<
  _Iterator,
  typename std::iterator_traits<_Iterator>::iterator_category,
  typename std::iterator_traits< 
    typename std::iterator_traits<_Iterator>::value_type >::value_type,
  typename std::iterator_traits<_Iterator>::difference_type,
  typename std::iterator_traits<_Iterator>::value_type,
  typename std::iterator_traits< 
    typename std::iterator_traits<_Iterator>::value_type >::reference>
  Base;

public:

  //
  // Public types.
  //

  typedef typename Base::Iterator Iterator;

  // The following five types are required to be defined for any iterator.

  typedef typename Base::iterator_category iterator_category;
  typedef typename Base::value_type value_type;
  typedef typename Base::difference_type difference_type;
  typedef typename Base::pointer pointer;
  typedef typename Base::reference reference;

public:
  
  //--------------------------------------------------------------------------


  IndirectIterator() :
    Base()
  {}

  IndirectIterator(const IndirectIterator& other) :
    Base(other)
  {}

  IndirectIterator& 
  operator=(const IndirectIterator& other) {
    Base::operator=(other);
    return *this;
  }

  explicit
  IndirectIterator(const Iterator& i) :
    Base(i)
  {}

  IndirectIterator& 
  operator=(const Iterator& i) {
    Base::operator=(i);
    return *this;
  }

  //--------------------------------------------------------------------------


  const Iterator&
  base() const {
    return Base::base();
  }

  //--------------------------------------------------------------------------


  //
  // Trivial iterator requirements.
  //

  reference
  operator*() const {
    return **Base::_iterator;
  }

  pointer
  operator->() const {
    return *Base::_iterator;
  }

  //
  // Forward iterator requirements.
  //

  IndirectIterator&
  operator++() {
    ++Base::_iterator;
    return *this;
  }

  IndirectIterator
  operator++(int) {
    IndirectIterator tmp = *this;
    ++Base::_iterator;
    return tmp;
  }

  //
  // Bi-directional iterator requirements.
  //

  IndirectIterator&
  operator--() {
    --Base::_iterator;
    return *this;
  }

  IndirectIterator
  operator--(int) {
    IndirectIterator tmp = *this;
    --Base::_iterator;
    return tmp;
  }

  //
  // Random access iterator requirements.
  //

  value_type
  operator[](const difference_type& n) const {
    return *Base::_iterator[n];
  }

  IndirectIterator&
  operator+=(const difference_type& n) {
    Base::_iterator += n;
    return *this;
  }

  IndirectIterator
  operator+(const difference_type& n) const {
    return IndirectIterator(Base::_iterator + n);
  }

  IndirectIterator&
  operator-=(const difference_type& n) {
    Base::_iterator -= n;
    return *this;
  }

  IndirectIterator
  operator-(const difference_type& n) const {
    return IndirectIterator(Base::_iterator - n);
  }

};

//
// Random access iterator requirements.
//


template<typename _Iterator>
inline
IndirectIterator<_Iterator>
operator+(typename IndirectIterator<_Iterator>::difference_type n,
          const IndirectIterator<_Iterator>& x) {
  return x + n;
}


template<typename _Iterator>
inline
IndirectIterator<_Iterator>
constructIndirectIterator() {
  return IndirectIterator<_Iterator>();
}


template<typename _Iterator>
inline
IndirectIterator<_Iterator>
constructIndirectIterator(const _Iterator& i) {
  return IndirectIterator<_Iterator>(i);
}












template<typename _Iterator>
class IndirectIterator2 :
  public AdaptedIterator<
  _Iterator,
  typename std::iterator_traits<_Iterator>::iterator_category,
  typename std::iterator_traits<
  typename std::iterator_traits<
  typename std::iterator_traits<_Iterator>::value_type>::value_type >::value_type,
  typename std::iterator_traits<_Iterator>::difference_type,
  typename std::iterator_traits< 
  typename std::iterator_traits<
  typename std::iterator_traits<_Iterator>::value_type>::value_type >::pointer,
  typename std::iterator_traits< 
  typename std::iterator_traits<
  typename std::iterator_traits<_Iterator>::value_type>::value_type >::reference>
{
private:

  //
  // Private types.
  //

  typedef AdaptedIterator<
  _Iterator,
    typename std::iterator_traits<_Iterator>::iterator_category,
    typename std::iterator_traits<
    typename std::iterator_traits<
    typename std::iterator_traits<_Iterator>::value_type>::value_type >::value_type,
    typename std::iterator_traits<_Iterator>::difference_type,
    typename std::iterator_traits< 
    typename std::iterator_traits<
    typename std::iterator_traits<_Iterator>::value_type>::value_type >::pointer,
    typename std::iterator_traits< 
    typename std::iterator_traits<
    typename std::iterator_traits<_Iterator>::value_type>::value_type >::reference>
  Base;

public:

  //
  // Public types.
  //

  typedef typename Base::Iterator Iterator;

  // The following five types are required to be defined for any iterator.

  typedef typename Base::iterator_category iterator_category;
  typedef typename Base::value_type value_type;
  typedef typename Base::difference_type difference_type;
  typedef typename Base::pointer pointer;
  typedef typename Base::reference reference;

public:
  
  //--------------------------------------------------------------------------


  IndirectIterator2() :
    Base()
  {}

  IndirectIterator2(const IndirectIterator2& x) :
    Base(x)
  {}

  IndirectIterator2& 
  operator=(const IndirectIterator2& other) {
    Base::operator=(other);
    return *this;
  }

  explicit
  IndirectIterator2(const Iterator& i) :
    Base(i)
  {}

  IndirectIterator2& 
  operator=(const Iterator& other) {
    Base::operator=(other);
    return *this;
  }

  //--------------------------------------------------------------------------


  const Iterator&
  base() const {
    return Base::base();
  }

  //--------------------------------------------------------------------------


  //
  // Trivial iterator requirements.
  //

  reference
  operator*() const {
    return ***Base::_iterator;
  }

  pointer
  operator->() const {
    return **Base::_iterator;
  }

  //
  // Forward iterator requirements.
  //

  IndirectIterator2&
  operator++() {
    ++Base::_iterator;
    return *this;
  }

  IndirectIterator2
  operator++(int) {
    IndirectIterator2 tmp = *this;
    ++Base::_iterator;
    return tmp;
  }

  //
  // Bi-directional iterator requirements.
  //

  IndirectIterator2&
  operator--() {
    --Base::_iterator;
    return *this;
  }

  IndirectIterator2
  operator--(int) {
    IndirectIterator2 tmp = *this;
    --Base::_iterator;
    return tmp;
  }

  //
  // Random access iterator requirements.
  //

  value_type
  operator[](const difference_type& n) const {
    return **Base::_iterator[n];
  }

  IndirectIterator2&
  operator+=(const difference_type& n) {
    Base::_iterator += n;
    return *this;
  }

  IndirectIterator2
  operator+(const difference_type& n) const {
    return IndirectIterator2(Base::_iterator + n);
  }

  IndirectIterator2&
  operator-=(const difference_type& n) {
    Base::_iterator -= n;
    return *this;
  }

  IndirectIterator2
  operator-(const difference_type& n) const {
    return IndirectIterator2(Base::_iterator - n);
  }

};

//
// Random access iterator requirements.
//


template<typename _Iterator>
inline
IndirectIterator2<_Iterator>
operator+(typename IndirectIterator2<_Iterator>::difference_type n,
          const IndirectIterator2<_Iterator>& x) {
  return x + n;
}


template<typename _Iterator>
inline
IndirectIterator2<_Iterator>
constructIndirectIterator2() {
  return IndirectIterator2<_Iterator>();
}


template<typename _Iterator>
inline
IndirectIterator2<_Iterator>
constructIndirectIterator2(const _Iterator& i) {
  return IndirectIterator2<_Iterator>(i);
}

END_NAMESPACE_ADS

#endif

---