ArrayIndexIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_ArrayIndexIterator_h__)
#define __ads_ArrayIndexIterator_h__

// If we are debugging the whole ads package.
#if defined(DEBUG_ads) && !defined(DEBUG_ads_ArrayIndexIterator)
#define DEBUG_ads_ArrayIndexIterator
#endif

#include "ArrayIndexingBase.h"

#include <iterator>

BEGIN_NAMESPACE_ADS


template<int N>
class ArrayIndexIterator :
  public std::iterator<std::random_access_iterator_tag,
                       typename ArrayIndexingBase<N>::index_type,
                       std::ptrdiff_t,
                       const typename ArrayIndexingBase<N>::index_type*,
                       const typename ArrayIndexingBase<N>::index_type&> {
  //
  // Private types.
  //

private:
  
  typedef 
  std::iterator<std::random_access_iterator_tag,
                typename ArrayIndexingBase<N>::index_type,
                std::ptrdiff_t,
                const typename ArrayIndexingBase<N>::index_type*,
                const typename ArrayIndexingBase<N>::index_type&> 
  Base;
  typedef ArrayIndexingBase<N> ArrayType;

  //
  // Public types.
  //

public:

  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;

  //
  // Member data.
  //

private:

  int _container_index;
  mutable value_type _array_index;
  const ArrayType& _array;

  //
  // Not implemented.
  //

private:

  // Default constructor not implemented.
  ArrayIndexIterator();

public:

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


  ArrayIndexIterator(const ArrayType& x) :
    Base(),
    _container_index(0),
    _array_index(),
    _array(x)
  {}

  ArrayIndexIterator(const ArrayIndexIterator& x) :
    Base(),
    _container_index(x._container_index),
    _array_index(),
    _array(x._array)
  {}    

  ArrayIndexIterator&
  operator=(const ArrayIndexIterator& x)
  {
#ifdef DEBUG_ArrayIndexing
    assert(_array == x._array);
#endif
    if (&x != this) {
      _container_index = x._container_index;
    }
    return *this;
  }

  ~ArrayIndexIterator()
  {}

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


  reference
  operator*() const 
  {
    // Update the array index.
    _array.index_to_indices(_container_index, _array_index);
    // Then return a constant reference to it.
    return _array_index;
  }

  pointer
  operator->() const 
  {
    // Update the array index.
    _array.index_to_indices(_container_index, _array_index);
    // Then return a constant pointer to it.
    return &_array_index;
  }
  
  ArrayIndexIterator&
  operator++() 
  { 
    ++_container_index; 
    return *this; 
  }
      

  ArrayIndexIterator
  operator++(int) 
  {
    ArrayIndexIterator x(*this); 
    ++*this;
    return x;
  }
      
  //--------------------------------------------------------------------------


  ArrayIndexIterator&
  operator--() 
  { 
    --_container_index; 
    return *this; 
  }
      

  ArrayIndexIterator
  operator--(int) 
  {
    ArrayIndexIterator x(*this); 
    --*this;
    return x;
  }
      
  //--------------------------------------------------------------------------


  reference
  operator[](const difference_type n) const
  { 
    // Update the array index with the requested offset value.
    _array.index_to_indices(int(_container_index + n), _array_index);
    // Then return a constant reference to it.
    return _array_index;
  }
  
  ArrayIndexIterator&
  operator+=(const difference_type n)
  { 
    _container_index += int(n);
    return *this; 
  }


  ArrayIndexIterator
  operator+(const difference_type n) const
  { 
    ArrayIndexIterator x(*this); 
    x += n;
    return x;
  }
      
  ArrayIndexIterator&
  operator-=(const difference_type n)
  { 
    _container_index -= int(n);
    return *this; 
  }


  ArrayIndexIterator
  operator-(const difference_type n) const
  { 
    ArrayIndexIterator x(*this); 
    x -= n;
    return x;
  }

  int
  base() const 
  {
    return _container_index;
  }

};


//
// Forward iterator requirements
//

template<int N>
inline 
bool
operator==(const ArrayIndexIterator<N>& x, const ArrayIndexIterator<N>& y) { 
  return x.base() == y.base(); 
}

template<int N>
inline 
bool
operator!=(const ArrayIndexIterator<N>& x, const ArrayIndexIterator<N>& y) { 
  return !(x == y);
}

//
// Random access iterator requirements
//

template<int N>
inline 
bool 
operator<(const ArrayIndexIterator<N>& x, const ArrayIndexIterator<N>& y) { 
  return x.base() < y.base(); 
}

template<int N>
inline 
bool
operator>(const ArrayIndexIterator<N>& x, const ArrayIndexIterator<N>& y) { 
  return x.base() > y.base(); 
}

template<int N>
inline 
bool
operator<=(const ArrayIndexIterator<N>& x, const ArrayIndexIterator<N>& y) { 
  return x.base() <= y.base(); 
}

template<int N>
inline bool
operator>=(const ArrayIndexIterator<N>& x, const ArrayIndexIterator<N>& y) { 
  return x.base() >= y.base(); 
}

template<int N>
inline 
typename ArrayIndexIterator<N>::difference_type
operator-(const ArrayIndexIterator<N>& x, const ArrayIndexIterator<N>& y) { 
  return x.base() - y.base(); 
}

template<int N>
inline 
ArrayIndexIterator<N>
operator+(typename ArrayIndexIterator<N>::difference_type n,
          const ArrayIndexIterator<N>& i) { 
  ArrayIndexIterator<N> x(i); 
  x += n;
  return x;
}


END_NAMESPACE_ADS

#endif

---