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() throw() {}
00056
00058 ConstForwardFilterIterator(Predicate p, IteratorForward it) throw()
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) throw()
00067 : BaseFilterIterator<Predicate, IteratorForward>(iterator)
00068 {
00069 }
00070
00072 ~ConstForwardFilterIterator() throw() {}
00073
00075
00079
00080 ConstForwardFilterIterator& operator = (const ConstForwardFilterIterator& iterator) throw()
00081 {
00082 Base::operator = (iterator);
00083 return *this;
00084 }
00085
00087 void swap(ConstForwardFilterIterator& iterator) throw()
00088 {
00089 std::swap(Base::predicate_, iterator.predicate_);
00090 std::swap(Base::iterator_, iterator.iterator_);
00091 }
00093
00095 void setIterator(const IteratorForward& iterator) throw()
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 throw() { return Base::iterator_; }
00105
00107 IteratorForward& getIterator() throw() { return Base::iterator_; }
00108
00112
00114 void toBegin() throw(Exception::SingularIterator);
00115
00117 bool isBegin() const throw();
00118
00120 void toEnd() throw(Exception::SingularIterator);
00121
00123 bool isEnd() const throw();
00124
00126 static ConstForwardFilterIterator begin(const Container& container)
00127 throw(Exception::Precondition);
00128
00130 static ConstForwardFilterIterator end(const Container& container)
00131 throw(Exception::Precondition);
00132
00134 ConstForwardFilterIterator& operator ++ () throw(Exception::InvalidIterator)
00135 {
00136 if (!Base::isValid())
00137 {
00138 Exception::InvalidIterator e;
00139 throw(e);
00140 }
00141 Base::getTraits().forward();
00142
00143 while (!isEnd() && !Base::predicate_(Base::getTraits().getData()))
00144 Base::getTraits().forward();
00145 return *this;
00146 }
00147
00149 ConstForwardFilterIterator operator ++ (int) throw(Exception::InvalidIterator)
00150 {
00151 if (!IteratorForward::isValid())
00152 {
00153 Exception::InvalidIterator e;
00154 throw(e);
00155 }
00156 ConstForwardFilterIterator tmp(*this);
00157 ++(*this);
00158 return tmp;
00159 }
00160
00162
00163 protected:
00164
00166 template <typename Container>
00167 ConstForwardFilterIterator(const Container& container) throw()
00168 : BaseFilterIterator<Predicate, IteratorForward>(container)
00169 {
00170 }
00171
00172 };
00174
00175 template <class Predicate, class IteratorForward>
00176 void ConstForwardFilterIterator<Predicate, IteratorForward>::toBegin()
00177 throw(Exception::SingularIterator)
00178 {
00179 if (IteratorForward::isSingular())
00180 {
00181 Exception::SingularIterator e;
00182 throw(e);
00183 }
00184 Base::getTraits().toBegin();
00185 }
00186
00187 template <class Predicate, class IteratorForward>
00188 ConstForwardFilterIterator<Predicate, IteratorForward>
00189 ConstForwardFilterIterator<Predicate, IteratorForward>::begin(const Container& container)
00190 throw(Exception::Precondition)
00191 {
00192 ConstForwardFilterIterator<Predicate, IteratorForward> iterator(container);
00193 iterator.toBegin();
00194 return iterator;
00195 }
00196
00197 template <class Predicate, class IteratorForward>
00198 bool ConstForwardFilterIterator<Predicate, IteratorForward>::isBegin() const
00199 throw()
00200 {
00201 if (Base::getTraits().isSingular())
00202 {
00203 return false;
00204 }
00205 return Base::getTraits().isBegin();
00206 }
00207
00208 template <class Predicate, class IteratorForward>
00209 void ConstForwardFilterIterator<Predicate, IteratorForward>::toEnd()
00210 throw(Exception::SingularIterator)
00211 {
00212 if (Base::isSingular())
00213 {
00214 Exception::SingularIterator e;
00215 throw(e);
00216 }
00217 Base::getTraits().toEnd();
00218 }
00219
00220 template <class Predicate, class IteratorForward>
00221 ConstForwardFilterIterator<Predicate, IteratorForward>
00222 ConstForwardFilterIterator<Predicate, IteratorForward>::end(const Container& container)
00223 throw(Exception::Precondition)
00224 {
00225 ConstForwardFilterIterator<Predicate, IteratorForward> iterator(container);
00226 iterator.toEnd();
00227 return iterator;
00228 }
00229
00230 template <class Predicate, class IteratorForward>
00231 bool ConstForwardFilterIterator<Predicate, IteratorForward>::isEnd() const
00232 throw()
00233 {
00234 if (Base::isSingular())
00235 {
00236 return false;
00237 }
00238 return Base::getTraits().isEnd();
00239 }
00240
00243 template <class Predicate, class IteratorForward>
00244 class ForwardFilterIterator
00245 : public ConstForwardFilterIterator<Predicate, IteratorForward>
00246 {
00247 public:
00248
00252
00254 typedef typename IteratorForward::container_type Container;
00256 typedef typename IteratorForward::value_type DataType;
00258 typedef typename IteratorForward::difference_type Position;
00260 typedef typename IteratorForward::traits_type Traits;
00262 typedef typename IteratorForward::value_type value_type;
00264 typedef typename IteratorForward::difference_type difference_type;
00266 typedef typename IteratorForward::pointer pointer;
00268 typedef typename IteratorForward::reference reference;
00270 typedef ConstForwardFilterIterator<Predicate, IteratorForward> Base;
00271
00273
00277
00279 ForwardFilterIterator() throw() {}
00280
00282 ForwardFilterIterator(Predicate p, IteratorForward it) throw()
00283 : ConstForwardFilterIterator<Predicate, IteratorForward>(p,it)
00284 {
00285 }
00286
00288 ForwardFilterIterator(const ForwardFilterIterator& iterator) throw()
00289 : ConstForwardFilterIterator<Predicate, IteratorForward>(iterator)
00290 {
00291 }
00292
00294 ~ForwardFilterIterator() throw() {}
00296
00300
00301 ForwardFilterIterator& operator = (const ForwardFilterIterator& iterator) throw()
00302 {
00303 Base::operator = (iterator);
00304 return *this;
00305 }
00306
00308
00310 void swap(ForwardFilterIterator& iterator) throw()
00311 {
00312 std::swap(Base::predicate_, iterator.predicate_);
00313 std::swap(Base::iterator_, iterator.iterator_);
00314 }
00316
00320
00322 static ForwardFilterIterator begin(const Container& container) throw(Exception::Precondition);
00323
00325 static ForwardFilterIterator end(const Container& container) throw(Exception::Precondition);
00326
00328 reference operator * () const throw()
00329 {
00330 return Base::getTraits().getData();
00331 }
00332
00334 pointer operator -> () const throw()
00335 {
00336 return &Base::getTraits().getData();
00337 }
00338
00340 ForwardFilterIterator& operator ++ () throw(Exception::InvalidIterator)
00341 {
00342 if (!Base::isValid())
00343 {
00344 Exception::InvalidIterator e;
00345 throw(e);
00346 }
00347
00348 while (!Base::isEnd() && !Base::predicate_(Base::getTraits().getData()))
00349 Base::getTraits().forward();
00350 return *this;
00351 }
00352
00354 ForwardFilterIterator operator ++ (int) throw(Exception::InvalidIterator)
00355 {
00356 if (!Base::isValid())
00357 {
00358 Exception::InvalidIterator e;
00359 throw(e);
00360 }
00361 ForwardFilterIterator tmp(*this);
00362 ++(*this);
00363 return tmp;
00364 }
00365
00367
00368 protected:
00369
00371 ForwardFilterIterator(const Container& container) throw()
00372 : ConstForwardFilterIterator<Predicate, IteratorForward>(container)
00373 {
00374 }
00375 };
00376
00377
00378 template <class Predicate, class IteratorForward>
00379 ForwardFilterIterator<Predicate, IteratorForward>
00380 ForwardFilterIterator<Predicate, IteratorForward>::begin(const Container& container)
00381 throw(Exception::Precondition)
00382 {
00383 ForwardFilterIterator iterator(container);
00384 iterator.toBegin();
00385 return iterator;
00386 }
00387
00388 template <class Predicate, class IteratorForward>
00389 ForwardFilterIterator<Predicate, IteratorForward>
00390 ForwardFilterIterator<Predicate, IteratorForward>::end(const Container& container)
00391 throw(Exception::Precondition)
00392 {
00393 ForwardFilterIterator iterator(container);
00394 iterator.toEnd();
00395 return iterator;
00396 }
00397
00398
00399 }
00400
00401 #endif // BALL_KERNEL_FORWARDFILTERITERATOR_H