FSlice.h

Go to the documentation of this file.

#ifndef CLASSIC_FSlice_HH
#define CLASSIC_FSlice_HH
 
// ------------------------------------------------------------------------
// $RCSfile: FSlice.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.2.2 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: FSlice
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2004/11/12 18:57:54 $
// $Author: adelmann $
//
// ------------------------------------------------------------------------
 
#include <iterator>
 
// Class FSlice.
// ------------------------------------------------------------------------
 
template<class T, int S>
class FSlice {
 
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;
 
    explicit FSlice(T *);
 
    FSlice(const FSlice &);
    FSlice &operator=(const FSlice &);
    bool operator==(const FSlice &rhs) const;
    bool operator!=(const FSlice &rhs) const;
 
    FSlice &operator++();
 
    FSlice  operator++(int);
 
    FSlice &operator--();
 
    FSlice  operator--(int);
 
    FSlice &operator+=(std::ptrdiff_t);
 
    FSlice &operator-=(std::ptrdiff_t);
 
    FSlice operator+(std::ptrdiff_t);
 
    FSlice operator-(std::ptrdiff_t);
 
    difference_type operator-(const FSlice &) const;
 
    T &operator*() const;
 
    T &operator[](int) const;
 
private:
 
    T *cursor;
};
 
 
// Class FConstSlice.
// ------------------------------------------------------------------------
 
template<class T, int S>
class FConstSlice {
 
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;
 
    FConstSlice(const T *);
 
    FConstSlice(const FConstSlice &rhs);
    FConstSlice &operator=(const FConstSlice &);
    bool operator==(const FConstSlice &rhs) const;
    bool operator!=(const FConstSlice &rhs) const;
 
    FConstSlice &operator++();
 
    FConstSlice  operator++(int);
 
    FConstSlice &operator--();
 
    FConstSlice  operator--(int);
 
    FConstSlice &operator+=(std::ptrdiff_t);
 
    FConstSlice &operator-=(std::ptrdiff_t);
 
    FConstSlice operator+(std::ptrdiff_t) const;
 
    FConstSlice operator-(std::ptrdiff_t) const;
 
    difference_type operator-(const FConstSlice &) const;
 
    const T &operator*() const;
 
    const T &operator[](int) const;
 
private:
 
    mutable const T *cursor;
};
 
 
// Ancillary functions.
// ------------------------------------------------------------------------
 
template<class T, int S>
inline std::random_access_iterator_tag
iterator_category(const FSlice<T, S> &) {
    return std::random_access_iterator_tag();
}
 
template<class T, int S>
inline std::random_access_iterator_tag
iterator_category(const FConstSlice<T, S> &) {
    return std::random_access_iterator_tag();
}
 
template<class T, int S>
inline T *value_type(const FSlice<T, S> &) {
    return (T *)(0);
}
 
template<class T, int S>
inline T *value_type(const FConstSlice<T, S> &) {
    return (T *)(0);
}
 
 
// Template function implementation for FSlice.
// ------------------------------------------------------------------------
 
template<class T, int S>
inline FSlice<T, S>::FSlice(T *array):
    cursor(array)
{}
 
template<class T, int S>
inline FSlice<T, S>::FSlice(const FSlice &rhs):
    cursor(rhs.cursor)
{}
 
template<class T, int S>
inline FSlice<T, S> &FSlice<T, S>::operator=(const FSlice &rhs) {
    cursor = rhs.cursor;
    return *this;
}
 
template<class T, int S>
inline bool FSlice<T, S>::operator==(const FSlice &rhs) const {
    return cursor == rhs.cursor;
}
 
template<class T, int S>
inline bool FSlice<T, S>::operator!=(const FSlice &rhs) const {
    return cursor != rhs.cursor;
}
 
template<class T, int S>
inline FSlice<T, S> &FSlice<T, S>::operator++() {
    cursor += S;
    return *this;
}
 
template<class T, int S>
inline FSlice<T, S> FSlice<T, S>::operator++(int) {
    FSlice tmp(*this);
    cursor += S;
    return tmp;
}
 
template<class T, int S>
inline FSlice<T, S> &FSlice<T, S>::operator--() {
    cursor -= S;
    return *this;
}
 
template<class T, int S>
inline FSlice<T, S> FSlice<T, S>::operator--(int) {
    FSlice tmp(*this);
    cursor -= S;
    return tmp;
}
 
template<class T, int S>
inline FSlice<T, S> &FSlice<T, S>::operator+=(std::ptrdiff_t n) {
    cursor += n * S;
    return *this;
}
 
template<class T, int S>
inline FSlice<T, S> &FSlice<T, S>::operator-=(std::ptrdiff_t n) {
    cursor -= n * S;
    return *this;
}
 
template<class T, int S>
inline FSlice<T, S> FSlice<T, S>::operator+(std::ptrdiff_t n) {
    FSlice tmp(*this);
    return tmp += n;
}
 
template<class T, int S>
inline FSlice<T, S> FSlice<T, S>::operator-(std::ptrdiff_t n) {
    FSlice tmp(*this);
    return tmp -= n;
}
 
template<class T, int S>
inline typename FSlice<T, S>::difference_type
FSlice<T, S>::operator-(const FSlice &rhs) const {
    return (cursor - rhs.cursor) / S;
}
 
template<class T, int S>
inline T &FSlice<T, S>::operator*() const {
    return *cursor;
}
 
template<class T, int S>
inline T &FSlice<T, S>::operator[](int n) const {
    return cursor[n*S];
}
 
 
// Template function implementation for FConstSlice.
// ------------------------------------------------------------------------
 
template<class T, int S>
inline FConstSlice<T, S>::FConstSlice(const T *array):
    cursor(array)
{}
 
template<class T, int S>
inline FConstSlice<T, S>::FConstSlice(const FConstSlice &rhs):
    cursor(rhs.cursor)
{}
 
template<class T, int S>
inline FConstSlice<T, S> &FConstSlice<T, S>::operator=(const FConstSlice &rhs) {
    cursor = rhs.cursor;
    return *this;
}
 
template<class T, int S>
inline bool FConstSlice<T, S>::operator==(const FConstSlice &rhs) const {
    return cursor == rhs.cursor;
}
 
template<class T, int S>
inline bool FConstSlice<T, S>::operator!=(const FConstSlice &rhs) const {
    return cursor != rhs.cursor;
}
 
template<class T, int S>
inline FConstSlice<T, S> &FConstSlice<T, S>::operator++() {
    cursor += S;
    return *this;
}
 
template<class T, int S>
inline FConstSlice<T, S> FConstSlice<T, S>::operator++(int) {
    FConstSlice tmp(*this);
    cursor += S;
    return tmp;
}
 
template<class T, int S>
inline FConstSlice<T, S> &FConstSlice<T, S>::operator--() {
    cursor -= S;
    return *this;
}
 
template<class T, int S>
inline FConstSlice<T, S> FConstSlice<T, S>::operator--(int) {
    FConstSlice tmp(*this);
    cursor -= S;
    return tmp;
}
 
template<class T, int S>
inline FConstSlice<T, S> &FConstSlice<T, S>::operator+=(std::ptrdiff_t n) {
    cursor += n * S;
    return *this;
}
 
template<class T, int S>
inline FConstSlice<T, S> &FConstSlice<T, S>::operator-=(std::ptrdiff_t n) {
    cursor -= n * S;
    return *this;
}
 
template<class T, int S> inline
FConstSlice<T, S> FConstSlice<T, S>::operator+(std::ptrdiff_t n) const {
    FConstSlice tmp(*this);
    return tmp += n;
}
 
template<class T, int S> inline
FConstSlice<T, S> FConstSlice<T, S>::operator-(std::ptrdiff_t n) const {
    FConstSlice tmp(*this);
    return tmp -= n;
}
 
template<class T, int S>
inline typename FConstSlice<T, S>::difference_type
FConstSlice<T, S>::operator-(const FConstSlice<T, S> &rhs) const {
    return (cursor - rhs.cursor) / S;
}
 
template<class T, int S>
inline const T &FConstSlice<T, S>::operator*() const {
    return *cursor;
}
 
template<class T, int S>
inline const T &FConstSlice<T, S>::operator[](int n) const {
    return cursor[n*S];
}
 
#endif // CLASSIC_FSlice_HH