00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef CIRCULAR_ITERATOR_HH
00020 #define CIRCULAR_ITERATOR_HH
00021
00022 #include <iterator>
00023
00024 template<typename T>
00025 class const_circular_iter : public std::iterator<std::bidirectional_iterator_tag,typename T::value_type>
00026 {
00027 typedef typename T::const_iterator iterator;
00028 typedef typename T::value_type value_type;
00029 protected:
00030 iterator iter;
00031 iterator begin;
00032 iterator end;
00033 public:
00034 const_circular_iter(T& t) : iter(t.begin()), begin(t.begin()), end(t.end()) {};
00035 const_circular_iter(iterator b,iterator e) : iter(b), begin(b), end(e) {};
00036 const_circular_iter(iterator b,iterator e,iterator pos) : iter(pos), begin(b), end(e) {};
00037 operator iterator(){
00038 return iter;
00039 }
00040 const_circular_iter<T>& operator++()
00041 {
00042 ++iter;
00043
00044 if (iter == end)
00045 iter = begin;
00046
00047 return(*this);
00048 }
00049
00050 const_circular_iter<T> operator++(int)
00051 {
00052 const_circular_iter<T> t=*this;
00053 ++(*this);
00054 return(t);
00055 }
00056 const_circular_iter<T>& operator--()
00057 {
00058 if (iter == begin)
00059 iter = end;
00060
00061 --iter;
00062
00063 return(*this);
00064 }
00065
00066 const_circular_iter<T> operator--(int)
00067 {
00068 const_circular_iter<T> t=*this;
00069 --(*this);
00070 return(t);
00071 }
00072
00073 const_circular_iter<T> operator-(int n)
00074 {
00075 const_circular_iter<T> t=*this;
00076 for(unsigned int i=0;i<n;++i)
00077 --t;
00078 return t;
00079 }
00080 const_circular_iter<T> operator+(int n)
00081 {
00082 const_circular_iter<T> t=*this;
00083 for(unsigned int i=0;i<n;++i)
00084 ++t;
00085 return t;
00086 }
00087
00088 const value_type operator*() const
00089 {return (*iter);}
00090
00091 bool operator==(const const_circular_iter<T>& rhs) const
00092 {return (iter == rhs.iter);}
00093
00094 bool operator!=(const const_circular_iter<T>& rhs) const
00095 {return ! operator==(rhs); }
00096 };
00097
00098
00099 template<typename T>
00100 class circular_iter : public std::iterator<std::bidirectional_iterator_tag,typename T::value_type>
00101 {
00102 typedef typename T::iterator iterator;
00103 typedef typename T::value_type value_type;
00104 private:
00105 iterator iter;
00106 iterator begin;
00107 iterator end;
00108 public:
00109 circular_iter(T& t) : iter(t.begin()), begin(t.begin()), end(t.end()) {};
00110 circular_iter(iterator b, iterator e) : iter(b), begin(b), end(e) {};
00111 circular_iter(iterator b, iterator e, iterator pos) : iter(pos), begin(b), end(e) {};
00112
00113 circular_iter<T>& operator++()
00114 {
00115 ++iter;
00116
00117 if (iter == end)
00118 iter = begin;
00119
00120 return(*this);
00121 }
00122
00123 circular_iter<T> operator++(int)
00124 {
00125 circular_iter<T> t=*this;
00126 ++(*this);
00127 return(t);
00128 }
00129 circular_iter<T>& operator--()
00130 {
00131 if (iter == begin)
00132 iter = end;
00133
00134 --iter;
00135
00136 return(*this);
00137 }
00138
00139 circular_iter<T> operator--(int)
00140 {
00141 circular_iter<T> t=*this;
00142 --(*this);
00143 return(t);
00144 }
00145 circular_iter<T> operator-(int n)
00146 {
00147 circular_iter<T> t=*this;
00148 for(unsigned int i=0;i<n;++i)
00149 --t;
00150 return t;
00151 }
00152 circular_iter<T> operator+(int n)
00153 {
00154 circular_iter<T> t=*this;
00155 for(unsigned int i=0;i<n;++i)
00156 ++t;
00157 return t;
00158 }
00159
00160 const value_type operator*() const
00161 {return (*iter);}
00162
00163 value_type& operator*()
00164 {return (*iter);}
00165
00166 bool operator==(const circular_iter<T>& rhs) const
00167 {return (iter == rhs.iter);}
00168
00169 bool operator!=(const circular_iter<T>& rhs) const {return ! operator==(rhs); }
00170 operator iterator(){
00171 return iter;
00172 }
00173 };
00174
00175 #endif
00176