IntIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__IntIterator_h__)
#define __IntIterator_h__

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

#include "../defs.h"

#include <iterator>

BEGIN_NAMESPACE_ADS


template<typename T = int>
class IntIterator :
  public std::iterator<std::random_access_iterator_tag,
                       T,
                       std::ptrdiff_t,
                       const T*,
                       const T&> {
  //
  // Private types.
  //

private:
  
  typedef std::iterator<std::random_access_iterator_tag,
                        T,
                        std::ptrdiff_t,
                        const T*,
                        const T&> 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;

  //
  // Member data.
  //

private:

  value_type _value;

public:

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


  // Default constructor.  The value is initialized to zero.
  IntIterator() :
    _value(0)
  {}

  IntIterator(const value_type x) :
    _value(x)
  {}

  IntIterator(const IntIterator& x) :
    _value(x._value)
  {}

  IntIterator&
  operator=(const IntIterator& other) {
    if (&other != this) {
      _value = other._value;
    }
    return *this;
  }

  ~IntIterator()
  {}

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


  reference
  operator*() const {
    // Return a reference to the value.
    return _value;
  }

  pointer
  operator->() const {
    // Return a pointer to the value.
    return &_value;
  }
  
  IntIterator&
  operator++() { 
    ++_value; 
    return *this; 
  }
      

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


  IntIterator&
  operator--() { 
    --_value; 
    return *this; 
  }
      

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


  value_type
  operator[](const difference_type n) { 
    // Return the value offset by n.
    return value_type(_value + n);
  }
  
  IntIterator&
  operator+=(const difference_type n) { 
    _value += value_type(n);
    return *this; 
  }


  IntIterator
  operator+(const difference_type n) const { 
    IntIterator x(*this); 
    x += n;
    return x;
  }
      
  IntIterator&
  operator-=(const difference_type n) { 
    _value -= value_type(n);
    return *this; 
  }


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

  value_type
  base() const {
    return _value;
  }

};

//
// Convenience functions.
//


template<typename T>
IntIterator<T>
constructIntIterator(const T x) {
  IntIterator<T> i(x);
  return i;
}

//
// Forward iterator requirements
//


template<typename T>
inline 
bool
operator==(const IntIterator<T>& x, const IntIterator<T>& y) { 
  return x.base() == y.base(); 
}


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

//
// Random access iterator requirements
//


template<typename T>
inline 
bool 
operator<(const IntIterator<T>& x, const IntIterator<T>& y) { 
  return x.base() < y.base(); 
}


template<typename T>
inline 
bool
operator>(const IntIterator<T>& x, const IntIterator<T>& y) { 
  return x.base() > y.base(); 
}


template<typename T>
inline 
bool
operator<=(const IntIterator<T>& x, const IntIterator<T>& y) { 
  return x.base() <= y.base(); 
}

template<typename T>
inline bool
operator>=(const IntIterator<T>& x, const IntIterator<T>& y) { 
  return x.base() >= y.base(); 
}


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


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

END_NAMESPACE_ADS

#endif

---