BALL  1.4.1
forwardFilterIterator.h
Go to the documentation of this file.
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 } // namespace BALL
00410 
00411 #endif // BALL_KERNEL_FORWARDFILTERITERATOR_H
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines