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