SliceIterator.h

Go to the documentation of this file.

#ifndef CLASSIC_SliceIterator_HH
#define CLASSIC_SliceIterator_HH

// ------------------------------------------------------------------------
// $RCSfile: SliceIterator.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: SliceIterator
//
// ------------------------------------------------------------------------
// Class category: Algebra
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:32 $
// $Author: fci $
//
// ------------------------------------------------------------------------

#include <iterator>

// Class SliceIterator.
// ------------------------------------------------------------------------
//  An iterator permitting to iterate on a non-constant array
//  with a stride different from 1.

template<class T>
class SliceIterator {

public:

    typedef std::random_access_iterator_tag iterator_category;

    typedef T value_type;

    typedef std::ptrdiff_t difference_type;

    typedef T *pointer;

    typedef T &reference;

    //  Construct iterator for [b]array[/b], given a [b]stride[/b].
    SliceIterator(T *array, std::ptrdiff_t stride);

    SliceIterator(const SliceIterator<T> &);
    SliceIterator<T> &operator=(const SliceIterator<T> &);
    bool operator==(const SliceIterator<T> &rhs) const;
    bool operator!=(const SliceIterator<T> &rhs) const;

    SliceIterator<T> &operator++();

    SliceIterator<T>  operator++(int);

    SliceIterator<T> &operator--();

    SliceIterator<T>  operator--(int);

    SliceIterator<T> &operator+=(std::ptrdiff_t);

    SliceIterator<T> &operator-=(std::ptrdiff_t);

    SliceIterator<T> operator+(std::ptrdiff_t);

    SliceIterator<T> operator-(std::ptrdiff_t);

    difference_type operator-(const SliceIterator<T> &) const;

    T &operator*() const;

    T &operator[](int) const;

private:

    T *cursor;
    std::ptrdiff_t stride;
};


// Class ConstSliceIterator.
// ------------------------------------------------------------------------
//  An iterator permitting to iterate on a constant array
//  with a stride different from 1.

template<class T>
class ConstSliceIterator {

public:

    typedef std::random_access_iterator_tag iterator_category;

    typedef const T value_type;

    typedef std::ptrdiff_t difference_type;

    typedef const T *pointer;

    typedef const T &reference;

    //  Construct iterator for [b]array[/b], given a [b]stride[/b].
    ConstSliceIterator(const T *array, std::ptrdiff_t stride);

    ConstSliceIterator(const ConstSliceIterator<T> &rhs);
    ConstSliceIterator<T> &operator=(const ConstSliceIterator<T>&);
    bool operator==(const ConstSliceIterator<T> &rhs) const;
    bool operator!=(const ConstSliceIterator<T> &rhs) const;

    ConstSliceIterator<T> &operator++();

    ConstSliceIterator<T>  operator++(int);

    ConstSliceIterator<T> &operator--();

    ConstSliceIterator<T>  operator--(int);

    ConstSliceIterator<T> &operator+=(std::ptrdiff_t);

    ConstSliceIterator<T> &operator-=(std::ptrdiff_t);

    ConstSliceIterator<T> operator+(std::ptrdiff_t) const;

    ConstSliceIterator<T> operator-(std::ptrdiff_t) const;

    difference_type operator-(const ConstSliceIterator<T> &) const;

    const T &operator*() const;

    const T &operator[](int) const;

private:

    mutable const T *cursor;
    mutable std::ptrdiff_t stride;
};


// Ancillary functions.
// ------------------------------------------------------------------------

template<class T>
inline std::random_access_iterator_tag
iterator_category(const SliceIterator<T> &) {
    return std::random_access_iterator_tag();
}

template<class T>
inline std::random_access_iterator_tag
iterator_category(const ConstSliceIterator<T> &) {
    return std::random_access_iterator_tag();
}

template<class T>
inline T *value_type(const SliceIterator<T> &) {
    return (T *)(0);
}

template<class T>
inline T *value_type(const ConstSliceIterator<T> &) {
    return (T *)(0);
}


// Template function implementation for SliceIterator.
// ------------------------------------------------------------------------

template<class T>
inline SliceIterator<T>::SliceIterator(T *array, std::ptrdiff_t n):
    cursor(array), stride(n)
{}

template<class T>
inline SliceIterator<T>::SliceIterator(const SliceIterator<T> &rhs):
    cursor(rhs.cursor), stride(rhs.stride)
{}

template<class T>
inline SliceIterator<T> &SliceIterator<T>::operator=
(const SliceIterator<T> &rhs) {
    cursor = rhs.cursor;
    stride = rhs.stride;
    return *this;
}

template<class T>
inline bool SliceIterator<T>::operator==(const SliceIterator<T> &rhs) const {
    return cursor == rhs.cursor;
}

template<class T>
inline bool SliceIterator<T>::operator!=(const SliceIterator<T> &rhs) const {
    return cursor != rhs.cursor;
}

template<class T>
inline SliceIterator<T> &SliceIterator<T>::operator++() {
    cursor += stride;
    return *this;
}

template<class T>
inline SliceIterator<T> SliceIterator<T>::operator++(int) {
    SliceIterator<T> tmp(*this);
    cursor += stride;
    return tmp;
}

template<class T>
inline SliceIterator<T> &SliceIterator<T>::operator--() {
    cursor -= stride;
    return *this;
}

template<class T>
inline SliceIterator<T> SliceIterator<T>::operator--(int) {
    SliceIterator<T> tmp(*this);
    cursor -= stride;
    return tmp;
}

template<class T>
inline SliceIterator<T> &SliceIterator<T>::operator+=(std::ptrdiff_t n) {
    cursor += n * stride;
    return *this;
}

template<class T>
inline SliceIterator<T> &SliceIterator<T>::operator-=(std::ptrdiff_t n) {
    cursor -= n * stride;
    return *this;
}

template<class T>
inline SliceIterator<T> SliceIterator<T>::operator+(std::ptrdiff_t n) {
    SliceIterator<T> tmp(*this);
    return tmp += n;
}

template<class T>
inline SliceIterator<T> SliceIterator<T>::operator-(std::ptrdiff_t n) {
    SliceIterator<T> tmp(*this);
    return tmp -= n;
}

template<class T>
inline typename SliceIterator<T>::difference_type
SliceIterator<T>::operator-(const SliceIterator<T> &rhs) const {
    return (cursor - rhs.cursor) / stride;
}

template<class T>
inline T &SliceIterator<T>::operator*() const {
    return *cursor;
}

template<class T>
inline T &SliceIterator<T>::operator[](int n) const {
    return cursor[n*stride];
}


// Template function implementation for ConstSliceIterator.
// ------------------------------------------------------------------------

template<class T>
inline ConstSliceIterator<T>::ConstSliceIterator
(const T *array, std::ptrdiff_t n):
    cursor(array), stride(n)
{}

template<class T>
inline ConstSliceIterator<T>::ConstSliceIterator
(const ConstSliceIterator<T> &rhs):
    cursor(rhs.cursor), stride(rhs.stride)
{}

template<class T>
inline ConstSliceIterator<T> &ConstSliceIterator<T>::operator=
(const ConstSliceIterator<T> &rhs) {
    cursor = rhs.cursor;
    stride = rhs.stride;
    return *this;
}

template<class T>
inline bool ConstSliceIterator<T>::operator==
(const ConstSliceIterator<T> &rhs) const {
    return cursor == rhs.cursor;
}

template<class T>
inline bool ConstSliceIterator<T>::operator!=
(const ConstSliceIterator<T> &rhs) const {
    return cursor != rhs.cursor;
}

template<class T>
inline ConstSliceIterator<T> &ConstSliceIterator<T>::operator++() {
    cursor += stride;
    return *this;
}

template<class T>
inline ConstSliceIterator<T> ConstSliceIterator<T>::operator++(int) {
    ConstSliceIterator<T> tmp(*this);
    cursor += stride;
    return tmp;
}

template<class T>
inline ConstSliceIterator<T> &ConstSliceIterator<T>::operator--() {
    cursor -= stride;
    return *this;
}

template<class T>
inline ConstSliceIterator<T> ConstSliceIterator<T>::operator--(int) {
    ConstSliceIterator<T> tmp(*this);
    cursor -= stride;
    return tmp;
}

template<class T>
inline ConstSliceIterator<T> &ConstSliceIterator<T>::operator+=
(std::ptrdiff_t n) {
    cursor += n * stride;
    return *this;
}

template<class T>
inline ConstSliceIterator<T> &ConstSliceIterator<T>::operator-=
(std::ptrdiff_t n) {
    cursor -= n * stride;
    return *this;
}

template<class T> inline
ConstSliceIterator<T> ConstSliceIterator<T>::operator+(std::ptrdiff_t n) const {
    ConstSliceIterator<T> tmp(*this);
    return tmp += n;
}

template<class T> inline
ConstSliceIterator<T> ConstSliceIterator<T>::operator-(std::ptrdiff_t n) const {
    ConstSliceIterator<T> tmp(*this);
    return tmp -= n;
}

template<class T>
inline typename ConstSliceIterator<T>::difference_type
ConstSliceIterator<T>::operator-(const ConstSliceIterator<T> &rhs) const {
    return (cursor - rhs.cursor) / stride;
}

template<class T>
inline const T &ConstSliceIterator<T>::operator*() const {
    return *cursor;
}

template<class T>
inline const T &ConstSliceIterator<T>::operator[](int n) const {
    return cursor[n*stride];
}

#endif // CLASSIC_SliceIterator_HH