00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00031 #ifndef __CLAW_ITERATOR_HPP__
00032 #define __CLAW_ITERATOR_HPP__
00033
00034 #include <iterator>
00035
00036 namespace claw
00037 {
00038
00043 template< typename Category, typename Value, typename Iterator,
00044 typename Function >
00045 class wrapped_iterator_by_category
00046 {
00047
00048 };
00049
00050
00055 template<typename Value, typename Iterator, typename Function>
00056 class wrapped_iterator_by_category
00057 <std::forward_iterator_tag, Value, Iterator, Function>
00058 {
00059 public:
00060 typedef typename std::iterator_traits<Iterator>::difference_type
00061 difference_type;
00062 typedef Value value_type;
00063 typedef value_type* pointer;
00064 typedef value_type& reference;
00065 typedef typename std::iterator_traits<Iterator>::iterator_category
00066 iterator_category;
00067
00068 typedef
00069 wrapped_iterator_by_category
00070 <std::forward_iterator_tag, Value, Iterator, Function>
00071 self_type;
00072
00073 public:
00074 wrapped_iterator_by_category() {}
00075 wrapped_iterator_by_category( const Iterator& it )
00076 : m_it(it)
00077 { }
00078 wrapped_iterator_by_category( const Iterator& it, const Function& f )
00079 : m_it(it), m_fun(f)
00080 { }
00081 template<typename C, typename V, typename I, typename F>
00082 wrapped_iterator_by_category
00083 ( const wrapped_iterator_by_category<C, V, I, F>& that )
00084 : m_it(that.get_iterator()), m_fun(that.get_function())
00085 { }
00086
00087 const Iterator& get_iterator() const { return m_it; }
00088 const Function& get_function() const { return m_fun; }
00089
00090 self_type& operator++()
00091 {
00092 ++m_it;
00093 return *this;
00094 }
00095
00096 self_type operator++(int)
00097 {
00098 self_type tmp(*this);
00099 ++m_it;
00100 return tmp;
00101 }
00102
00103 reference operator*() const { return m_fun(*m_it); }
00104 pointer operator->() const { return &m_fun(*m_it); }
00105
00106 bool operator==( const self_type& that ) const { return m_it == that.m_it; }
00107 bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
00108 bool operator==( const Iterator& it ) const { return m_it == it; }
00109 bool operator!=( const Iterator& it ) const { return m_it != it; }
00110
00111 private:
00113 Iterator m_it;
00114
00116 Function m_fun;
00117
00118 };
00119
00120
00126 template<typename Value, typename Iterator, typename Function>
00127 class wrapped_iterator_by_category
00128 <std::bidirectional_iterator_tag, Value, Iterator, Function>
00129 {
00130 public:
00131 typedef typename std::iterator_traits<Iterator>::difference_type
00132 difference_type;
00133 typedef Value value_type;
00134 typedef value_type* pointer;
00135 typedef value_type& reference;
00136 typedef typename std::iterator_traits<Iterator>::iterator_category
00137 iterator_category;
00138
00139 typedef
00140 wrapped_iterator_by_category
00141 <std::bidirectional_iterator_tag, Value, Iterator, Function> self_type;
00142
00143 public:
00144 wrapped_iterator_by_category() {}
00145 wrapped_iterator_by_category( const Iterator& it )
00146 : m_it(it)
00147 { }
00148 wrapped_iterator_by_category( const Iterator& it, const Function& f )
00149 : m_it(it), m_fun(f)
00150 { }
00151 template<typename C, typename V, typename I, typename F>
00152 wrapped_iterator_by_category
00153 ( const wrapped_iterator_by_category<C, V, I, F>& that )
00154 : m_it(that.get_iterator()), m_fun(that.get_function())
00155 { }
00156
00157 const Iterator& get_iterator() const { return m_it; }
00158 const Function& get_function() const { return m_fun; }
00159
00160 self_type& operator++()
00161 {
00162 ++m_it;
00163 return *this;
00164 }
00165
00166 self_type operator++(int)
00167 {
00168 self_type tmp(*this);
00169 ++m_it;
00170 return tmp;
00171 }
00172
00173 self_type& operator--()
00174 {
00175 --m_it;
00176 return *this;
00177 }
00178
00179 self_type operator--(int)
00180 {
00181 self_type tmp(*this);
00182 --m_it;
00183 return tmp;
00184 }
00185
00186 reference operator*() const { return m_fun(*m_it); }
00187 pointer operator->() const { return &m_fun(*m_it); }
00188
00189 bool operator==( const self_type& that ) const { return m_it == that.m_it; }
00190 bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
00191 bool operator==( const Iterator& it ) const { return m_it == it; }
00192 bool operator!=( const Iterator& it ) const { return m_it != it; }
00193
00194 private:
00196 Iterator m_it;
00197
00199 Function m_fun;
00200
00201 };
00202
00203
00208 template<typename Value, typename Iterator, typename Function>
00209 class wrapped_iterator_by_category
00210 <std::random_access_iterator_tag, Value, Iterator, Function>
00211 {
00212 public:
00213 typedef typename std::iterator_traits<Iterator>::difference_type
00214 difference_type;
00215 typedef Value value_type;
00216 typedef value_type* pointer;
00217 typedef value_type& reference;
00218 typedef typename std::iterator_traits<Iterator>::iterator_category
00219 iterator_category;
00220
00221 typedef
00222 wrapped_iterator_by_category
00223 <std::random_access_iterator_tag, Value, Iterator, Function>
00224 self_type;
00225
00226 public:
00227 wrapped_iterator_by_category() {}
00228 wrapped_iterator_by_category( const Iterator& it )
00229 : m_it(it)
00230 { }
00231 wrapped_iterator_by_category( const Iterator& it, const Function& f )
00232 : m_it(it), m_fun(f)
00233 { }
00234 template<typename V, typename I>
00235 wrapped_iterator_by_category
00236 ( const wrapped_iterator_by_category
00237 <std::random_access_iterator_tag, V, I, Function>& that )
00238 : m_it(that.m_it), m_fun(that.m_fun)
00239 { }
00240 template<typename C, typename V, typename I, typename F>
00241 wrapped_iterator_by_category
00242 ( const wrapped_iterator_by_category<C, V, I, F>& that )
00243 : m_it(that.get_iterator()), m_fun(that.get_function())
00244 { }
00245
00246 const Iterator& get_iterator() const { return m_it; }
00247 const Function& get_function() const { return m_fun; }
00248
00249 self_type& operator++()
00250 {
00251 ++m_it;
00252 return *this;
00253 }
00254
00255 self_type operator++(int)
00256 {
00257 self_type tmp(*this);
00258 ++m_it;
00259 return tmp;
00260 }
00261
00262 self_type& operator--()
00263 {
00264 --m_it;
00265 return *this;
00266 }
00267
00268 self_type operator--(int)
00269 {
00270 self_type tmp(*this);
00271 --m_it;
00272 return tmp;
00273 }
00274
00275 reference operator*() const { return m_fun(*m_it); }
00276 pointer operator->() const { return &m_fun(*m_it); }
00277
00278 bool operator==( const self_type& that ) const { return m_it == that.m_it; }
00279 bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
00280 bool operator==( const Iterator& it ) const { return m_it == it; }
00281 bool operator!=( const Iterator& it ) const { return m_it != it; }
00282 bool operator<( const self_type& that ) const { return m_it < that.m_it; }
00283 bool operator<=( const self_type& that ) const { return m_it <= that.m_it; }
00284 bool operator>( const self_type& that ) const { return m_it > that.m_it; }
00285 bool operator>=( const self_type& that ) const { return m_it >= that.m_it; }
00286
00287 self_type& operator+=(int n)
00288 {
00289 m_it += n;
00290 return *this;
00291 }
00292
00293 self_type operator+(int n) const
00294 {
00295 self_type result(*this);
00296 result += n;
00297 return result;
00298 }
00299
00300 self_type& operator-=(int n) { return *this += -n; }
00301
00302 self_type operator-(int n) const
00303 {
00304 self_type result(*this);
00305 result -= n;
00306 return result;
00307 }
00308
00309 reference operator[](int n) { return m_fun(m_it[n]); }
00310
00311 private:
00313 Iterator m_it;
00314
00316 Function m_fun;
00317
00318 };
00319
00320 template<typename Value, typename Iterator, typename Function>
00321 wrapped_iterator_by_category
00322 <std::random_access_iterator_tag, Value, Iterator, Function>
00323 operator+
00324 ( int n,
00325 const wrapped_iterator_by_category
00326 < std::random_access_iterator_tag, Value, Iterator, Function >& it )
00327 {
00328 return it + n;
00329 }
00330
00331 template<typename Value, typename Iterator, typename Function>
00332 wrapped_iterator_by_category
00333 <std::random_access_iterator_tag, Value, Iterator, Function>
00334 operator-
00335 ( int n,
00336 const wrapped_iterator_by_category
00337 < std::random_access_iterator_tag, Value, Iterator, Function >& it )
00338 {
00339 return it - n;
00340 }
00341
00342
00355 template <typename Value, typename Iterator, typename Function>
00356 class wrapped_iterator
00357 {
00358 public:
00360 typedef wrapped_iterator_by_category
00361 < typename std::iterator_traits<Iterator>::iterator_category,
00362 Value, Iterator, Function >
00363 iterator_type;
00364
00365 };
00366 }
00367
00368 #endif // __CLAW_ITERATOR_HPP__