00001 #ifndef BALL_LINALG_FORWARDFILTERITERATOR_H
00002 #define BALL_LINALG_FORWARDFILTERITERATOR_H
00003
00004 #ifndef BALL_LINALG_BASEFILTERITERATOR_H
00005 # include <BALL/MATHS/LINALG/baseFilterIterator.h>
00006 #endif
00007
00008 namespace BALL
00009 {
00010
00014
00017 template <class Predicate, class IteratorForward>
00018 class ConstForwardFilterIterator
00019 : public BaseFilterIterator<Predicate, IteratorForward>
00020 {
00021 public:
00022
00026
00027
00029 typedef typename IteratorForward::container_type Container;
00031 typedef typename IteratorForward::value_type DataType;
00033 typedef typename IteratorForward::difference_type Position;
00035 typedef typename IteratorForward::traits_type Traits;
00037 typedef typename IteratorForward::value_type value_type;
00039 typedef typename IteratorForward::difference_type difference_type;
00041 typedef typename IteratorForward::pointer pointer;
00043 typedef typename IteratorForward::reference reference;
00045 typedef std::forward_iterator_tag iterator_category;
00047 typedef BaseFilterIterator<Predicate, IteratorForward> Base;
00049
00053
00055 ConstForwardFilterIterator() {}
00056
00058 ConstForwardFilterIterator(Predicate p, IteratorForward it)
00059 : BaseFilterIterator<Predicate, IteratorForward>(p,it)
00060 {
00061 while (!isEnd() && !Base::predicate_(Base::getTraits().getData()))
00062 Base::getTraits().forward();
00063 }
00064
00066 ConstForwardFilterIterator(const ConstForwardFilterIterator& iterator)
00067 : BaseFilterIterator<Predicate, IteratorForward>(iterator)
00068 {
00069 }
00070
00072 ~ConstForwardFilterIterator() {}
00073
00075
00079
00080 ConstForwardFilterIterator& operator = (const ConstForwardFilterIterator& iterator)
00081 {
00082 Base::operator = (iterator);
00083 return *this;
00084 }
00085
00087 void swap(ConstForwardFilterIterator& iterator)
00088 {
00089 std::swap(Base::predicate_, iterator.predicate_);
00090 std::swap(Base::iterator_, iterator.iterator_);
00091 }
00093
00095 void setIterator(const IteratorForward& iterator)
00096 {
00097 Base::iterator_ = iterator;
00098
00099 while (!isEnd() && !Base::predicate_(Base::getTraits().getData()))
00100 Base::getTraits().forward();
00101 }
00102
00104 const IteratorForward& getIterator() const { return Base::iterator_; }
00105
00107 IteratorForward& getIterator() { return Base::iterator_; }
00108
00112
00116 void toBegin();
00117
00119 bool isBegin() const;
00120
00124 void toEnd();
00125
00127 bool isEnd() const;
00128
00132 static ConstForwardFilterIterator begin(const Container& container);
00133
00137 static ConstForwardFilterIterator end(const Container& container);
00138
00142 ConstForwardFilterIterator& operator ++ ()
00143 {
00144 if (!Base::isValid())
00145 {
00146 Exception::InvalidIterator e;
00147 throw(e);
00148 }
00149 Base::getTraits().forward();
00150
00151 while (!isEnd() && !Base::predicate_(Base::getTraits().getData()))
00152 Base::getTraits().forward();
00153 return *this;
00154 }
00155
00159 ConstForwardFilterIterator operator ++ (int)
00160 {
00161 if (!IteratorForward::isValid())
00162 {
00163 Exception::InvalidIterator e;
00164 throw(e);
00165 }
00166 ConstForwardFilterIterator tmp(*this);
00167 ++(*this);
00168 return tmp;
00169 }
00170
00172
00173 protected:
00174
00176 template <typename Container>
00177 ConstForwardFilterIterator(const Container& container)
00178 : BaseFilterIterator<Predicate, IteratorForward>(container)
00179 {
00180 }
00181
00182 };
00184
00185 template <class Predicate, class IteratorForward>
00186 void ConstForwardFilterIterator<Predicate, IteratorForward>::toBegin()
00187 {
00188 if (IteratorForward::isSingular())
00189 {
00190 Exception::SingularIterator e;
00191 throw(e);
00192 }
00193 Base::getTraits().toBegin();
00194 }
00195
00196 template <class Predicate, class IteratorForward>
00197 ConstForwardFilterIterator<Predicate, IteratorForward>
00198 ConstForwardFilterIterator<Predicate, IteratorForward>::begin(const Container& container)
00199 {
00200 ConstForwardFilterIterator<Predicate, IteratorForward> iterator(container);
00201 iterator.toBegin();
00202 return iterator;
00203 }
00204
00205 template <class Predicate, class IteratorForward>
00206 bool ConstForwardFilterIterator<Predicate, IteratorForward>::isBegin() const
00207 {
00208 if (Base::getTraits().isSingular())
00209 {
00210 return false;
00211 }
00212 return Base::getTraits().isBegin();
00213 }
00214
00215 template <class Predicate, class IteratorForward>
00216 void ConstForwardFilterIterator<Predicate, IteratorForward>::toEnd()
00217 {
00218 if (Base::isSingular())
00219 {
00220 Exception::SingularIterator e;
00221 throw(e);
00222 }
00223 Base::getTraits().toEnd();
00224 }
00225
00226 template <class Predicate, class IteratorForward>
00227 ConstForwardFilterIterator<Predicate, IteratorForward>
00228 ConstForwardFilterIterator<Predicate, IteratorForward>::end(const Container& container)
00229 {
00230 ConstForwardFilterIterator<Predicate, IteratorForward> iterator(container);
00231 iterator.toEnd();
00232 return iterator;
00233 }
00234
00235 template <class Predicate, class IteratorForward>
00236 bool ConstForwardFilterIterator<Predicate, IteratorForward>::isEnd() const
00237 {
00238 if (Base::isSingular())
00239 {
00240 return false;
00241 }
00242 return Base::getTraits().isEnd();
00243 }
00244
00247 template <class Predicate, class IteratorForward>
00248 class ForwardFilterIterator
00249 : public ConstForwardFilterIterator<Predicate, IteratorForward>
00250 {
00251 public:
00252
00256
00258 typedef typename IteratorForward::container_type Container;
00260 typedef typename IteratorForward::value_type DataType;
00262 typedef typename IteratorForward::difference_type Position;
00264 typedef typename IteratorForward::traits_type Traits;
00266 typedef typename IteratorForward::value_type value_type;
00268 typedef typename IteratorForward::difference_type difference_type;
00270 typedef typename IteratorForward::pointer pointer;
00272 typedef typename IteratorForward::reference reference;
00274 typedef ConstForwardFilterIterator<Predicate, IteratorForward> Base;
00275
00277
00281
00283 ForwardFilterIterator() {}
00284
00286 ForwardFilterIterator(Predicate p, IteratorForward it)
00287 : ConstForwardFilterIterator<Predicate, IteratorForward>(p,it)
00288 {
00289 }
00290
00292 ForwardFilterIterator(const ForwardFilterIterator& iterator)
00293 : ConstForwardFilterIterator<Predicate, IteratorForward>(iterator)
00294 {
00295 }
00296
00298 ~ForwardFilterIterator() {}
00300
00304
00305 ForwardFilterIterator& operator = (const ForwardFilterIterator& iterator)
00306 {
00307 Base::operator = (iterator);
00308 return *this;
00309 }
00310
00312
00314 void swap(ForwardFilterIterator& iterator)
00315 {
00316 std::swap(Base::predicate_, iterator.predicate_);
00317 std::swap(Base::iterator_, iterator.iterator_);
00318 }
00320
00324
00328 static ForwardFilterIterator begin(const Container& container);
00329
00333 static ForwardFilterIterator end(const Container& container);
00334
00336 reference operator * () const
00337 {
00338 return Base::getTraits().getData();
00339 }
00340
00342 pointer operator -> () const
00343 {
00344 return &Base::getTraits().getData();
00345 }
00346
00350 ForwardFilterIterator& operator ++ ()
00351 {
00352 if (!Base::isValid())
00353 {
00354 Exception::InvalidIterator e;
00355 throw(e);
00356 }
00357
00358 while (!Base::isEnd() && !Base::predicate_(Base::getTraits().getData()))
00359 Base::getTraits().forward();
00360 return *this;
00361 }
00362
00366 ForwardFilterIterator operator ++ (int)
00367 {
00368 if (!Base::isValid())
00369 {
00370 Exception::InvalidIterator e;
00371 throw(e);
00372 }
00373 ForwardFilterIterator tmp(*this);
00374 ++(*this);
00375 return tmp;
00376 }
00377
00379
00380 protected:
00381
00383 ForwardFilterIterator(const Container& container)
00384 : ConstForwardFilterIterator<Predicate, IteratorForward>(container)
00385 {
00386 }
00387 };
00388
00389
00390 template <class Predicate, class IteratorForward>
00391 ForwardFilterIterator<Predicate, IteratorForward>
00392 ForwardFilterIterator<Predicate, IteratorForward>::begin(const Container& container)
00393 {
00394 ForwardFilterIterator iterator(container);
00395 iterator.toBegin();
00396 return iterator;
00397 }
00398
00399 template <class Predicate, class IteratorForward>
00400 ForwardFilterIterator<Predicate, IteratorForward>
00401 ForwardFilterIterator<Predicate, IteratorForward>::end(const Container& container)
00402 {
00403 ForwardFilterIterator iterator(container);
00404 iterator.toEnd();
00405 return iterator;
00406 }
00407
00408
00409 }
00410
00411 #endif // BALL_KERNEL_FORWARDFILTERITERATOR_H