IndexIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_array_IndexIterator_h__)
#define __ads_array_IndexIterator_h__

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

#include "IndexRange.h"

#include <iterator>


BEGIN_NAMESPACE_ADS


template<int N, typename T = int>
class IndexIterator :
  public std::iterator<std::bidirectional_iterator_tag, // iterator tag
                       FixedArray<N,T>, // value
                       std::ptrdiff_t, // pointer difference
                       const FixedArray<N,T>*, // pointer
                       const FixedArray<N,T>&> { // reference
  //
  // Private types.
  //

private:
  
  typedef 
  std::iterator<std::bidirectional_iterator_tag, // iterator tag
                FixedArray<N,T>, // value
                std::ptrdiff_t, // pointer difference
                const FixedArray<N,T>*, // pointer
                const FixedArray<N,T>&> // reference
  Base;

  //
  // 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;

  typedef iterator_category IteratorCategory;
  typedef value_type Value;
  typedef difference_type Difference;
  typedef pointer Pointer;
  typedef reference Reference;

  typedef ads::IndexRange<N,T> IndexRange;

  //
  // Member data.
  //

private:

  Value _index;
  IndexRange _index_range;

  //
  // Not implemented.
  //

private:

  // The default constructor is not implemented.
  IndexIterator();

public:

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



  IndexIterator(const IndexRange& index_range) :
    Base(),
    _index(index_range.lbounds()),
    _index_range(index_range)
  {}

  IndexIterator(const IndexIterator& x) :
    Base(),
    _index(x._index),
    _index_range(x._index_range)
  {}    

  IndexIterator&
  operator=(const IndexIterator& other) {
    if (&other != this) {
      _index = other._index;
      _index_range = other._index_range;
    }
    // Return this to assignments can chain.
    return *this;
  }

  ~IndexIterator()
  {}

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


  Reference
  operator*() const {
    // Return a constant reference to the index.
    return _index;
  }

  Pointer
  operator->() const {
    // Return a const pointer to the index.
    return &_index;
  }
  
  IndexIterator&
  operator++() {
    increment();
    return *this; 
  }
      

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


  IndexIterator&
  operator--() {
    decrement();
    return *this; 
  }
      

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


  Reference
  index() const {
    return _index;
  }

  const IndexRange&
  index_range() const {
    return _index_range;
  }

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


  void
  set_begin() {
    _index = _index_range.lbounds();
  }

  void
  set_end() {
    _index = _index_range.lbounds();
    _index[N-1] = _index_range.ubound(N - 1);
  }


private:

  void
  increment() {
    ++_index[0];
    for (int n = 0; n != N-1; ++n) {
      if (_index[n] == _index_range.ubound(n)) {
        _index[n] = _index_range.lbound(n);
        ++_index[n+1];
      }
    }
  }

  void
  decrement() {
    --_index[0];
    for (int n = 0; n != N-1; ++n) {
      if (_index[n] == _index_range.lbound(n) - 1) {
        _index[n] = _index_range.ubound(n) - 1;
        --_index[n+1];
      }
    }
  }

};


//
// Forward iterator requirements
//


template<int N, typename T>
inline 
bool
operator==(const IndexIterator<N,T>& x, const IndexIterator<N,T>& y) {
#ifdef DEBUG_IndexIterator
  assert(x.index_range() == y.index_range());
#endif
  return x.index() == y.index(); 
}


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


END_NAMESPACE_ADS

#endif

---