00001
00015 #ifndef _ITERATOR_H
00016 #define _ITERATOR_H
00017 #include <iterator>
00018 #include <error.H>
00019
00020 namespace xchen
00021 {
00025 template<typename T>
00026 class IteratorBase : public std::iterator<std::input_iterator_tag, T>
00027 {
00028 protected:
00029 public:
00030 T* ptr;
00031 IteratorBase(T* p=0) : ptr(p) { }
00032 T& operator*() { return *ptr;}
00033 const T& operator*() const { return *ptr; }
00034 bool operator== (const IteratorBase& rhs) { return rhs.ptr == ptr; }
00035 bool operator!= (const IteratorBase& rhs) { return rhs.ptr != ptr; }
00036 bool operator< (const IteratorBase& rhs) { return ((unsigned int)ptr) < ((unsigned int)rhs.ptr); }
00037 };
00038
00039 enum { invalid_stride = 0 };
00044 template<typename T, int Strd = invalid_stride>
00045 class Iterator : public IteratorBase<T>
00046 {
00047 int stride;
00048 public:
00049 Iterator(T* p=0) : IteratorBase<T>(p),stride(Strd) { ERR(Strd==invalid_stride, stride_not_given_in_constructor); }
00050 Iterator(T* p, int strd) : IteratorBase<T>(p), stride(strd) { ERR(Strd!=invalid_stride, stride_given_in_constructor); }
00051
00052 Iterator& operator++() { ptr += stride; return *this; }
00053 Iterator operator++(int) { T* p = ptr; ptr += stride; return Iterator<T>(p, stride); }
00054 Iterator operator+(int inc) { T* p = ptr + inc * stride; return Iterator<T>(p, stride); }
00055 Iterator& operator+=(int inc) { ptr += inc * stride; return *this; }
00056
00057 Iterator& operator--() { ptr -= stride; return *this; }
00058 Iterator operator--(int) { T* p = ptr; ptr -= stride; return Iterator<T>(p, stride); }
00059 Iterator operator-(int dec) { T* p = ptr - dec * stride; return Iterator<T>(p, stride); }
00060 Iterator& operator-=(int dec) { ptr -= dec * stride; return *this; }
00061 };
00062
00064 template<typename T, int Strd = invalid_stride>
00065 class ReverseIterator : public IteratorBase<T>
00066 {
00067 int stride;
00068 public:
00069 ReverseIterator(T* p=0) : IteratorBase<T>(p),stride(Strd) { ERR(Strd==invalid_stride, stride_not_given_in_constructor); }
00070 ReverseIterator(T* p, int strd) : IteratorBase<T>(p), stride(strd) { ERR(Strd!=invalid_stride, stride_given_in_constructor); }
00071
00072 ReverseIterator& operator++() { ptr -= stride; return *this; }
00073 ReverseIterator operator++(int) { T* p = ptr; ptr -= stride; return ReverseIterator<T>(p, stride); }
00074 ReverseIterator operator+(int inc) { T* p = ptr - inc * stride; return ReverseIterator<T>(p, stride); }
00075 ReverseIterator& operator+=(int inc) { ptr -= inc * stride; return *this; }
00076
00077 ReverseIterator& operator--() { ptr += stride; return *this; }
00078 ReverseIterator operator--(int) { T* p = ptr; ptr += stride; return ReverseIterator<T>(p, stride); }
00079 ReverseIterator operator-(int dec) { T* p = ptr + dec * stride; return ReverseIterator<T>(p, stride); }
00080 ReverseIterator& operator-=(int dec) { ptr += dec * stride; return *this; }
00081 };
00082
00084 template<typename T>
00085 class Iterator<T,1> : public IteratorBase<T>
00086 {
00087 public:
00088 Iterator(T* p=0) : IteratorBase<T>(p) { }
00089 Iterator& operator++() { ptr++; return *this; }
00090 Iterator operator++(int) { T* p = ptr; ptr++;return Iterator<T,1>(p); }
00091 Iterator operator+(int inc) { T* p = ptr + inc; return Iterator<T,1>(p); }
00092 Iterator& operator+=(int inc) { ptr += inc; return *this; }
00093
00094 Iterator& operator--() { ptr--; return *this; }
00095 Iterator operator--(int) { T* p = ptr; ptr--;return Iterator<T,1>(p); }
00096 Iterator operator-(int dec) { T* p = ptr - dec; return Iterator<T,1>(p); }
00097 Iterator& operator-=(int dec) { ptr -= dec; return *this; }
00098 };
00099
00101 template<typename T>
00102 class ReverseIterator<T,1> : public IteratorBase<T>
00103 {
00104 public:
00105 ReverseIterator(T* p) : IteratorBase<T>(p) { }
00106 ReverseIterator& operator++() { ptr--; return *this; }
00107 ReverseIterator operator++(int) { T* p = ptr; ptr--;return ReverseIterator<T,1>(p); }
00108 ReverseIterator operator+(int inc) { T* p = ptr - inc; return ReverseIterator<T,1>(p); }
00109 ReverseIterator& operator+=(int inc) { ptr -= inc; return *this; }
00110
00111 ReverseIterator& operator--() { ptr++; return *this; }
00112 ReverseIterator operator--(int) { T* p = ptr; ptr++;return ReverseIterator<T,1>(p); }
00113 ReverseIterator operator-(int dec) { T* p = ptr + dec; return ReverseIterator<T,1>(p); }
00114 ReverseIterator& operator-=(int dec) { ptr += dec; return *this; }
00115 };
00116
00117 }
00118
00119
00120 #endif
