BALL  1.4.1
reverseIterator.h
Go to the documentation of this file.
00001 #ifndef BALL_LINALG_REVERSEITERATOR_H
00002 #define BALL_LINALG_REVERSEITERATOR_H
00003 
00004 #ifndef BALL_CONCEPT_RANDOMACCESSITERATOR_H
00005 #include <BALL/CONCEPT/randomAccessIterator.h>
00006 #endif
00007 
00008 #include <BALL/MATHS/LINALG/linalgException.h>
00009 
00010 namespace BALL 
00011 {
00013     typedef int Distance;
00015     typedef int Index;
00016 
00021   template <typename Container, typename DataType, typename Position, typename Traits>
00022   class ConstReverseIterator
00023     : public ConstRandomAccessIterator<Container, DataType, Position, Traits>
00024   {
00025     public:
00026 
00030 
00032     typedef std::random_access_iterator_tag iterator_category;
00033     // convenience typedef
00034     typedef ConstRandomAccessIterator<Container, DataType, Position, Traits> Base;
00036 
00040 
00042     ConstReverseIterator() {}
00043   
00045     ConstReverseIterator(const ConstReverseIterator& iterator)
00046       : Base(iterator)
00047     {
00048     }
00049 
00051     ~ConstReverseIterator() {}
00053 
00054 
00055 
00059     
00063     ConstReverseIterator& operator += (Distance distance);
00064 
00068     ConstReverseIterator& operator -= (Distance distance);
00069 
00074     ConstReverseIterator operator + (Distance distance) const;
00075 
00081     ConstReverseIterator operator - (Distance distance) const;
00082 
00089     Distance operator - (const ConstReverseIterator& iterator) const;
00090 
00095     static ConstReverseIterator begin(const Container& container);
00096 
00101     static ConstReverseIterator end(const Container& container);
00102 
00107     static ConstReverseIterator rbegin(const Container& container);
00108 
00113     static ConstReverseIterator rend(const Container& container);
00114 
00118     ConstReverseIterator& operator ++ ();
00119 
00123     ConstReverseIterator operator ++ (int);
00124 
00128     ConstReverseIterator& operator -- ();
00129 
00133     ConstReverseIterator operator -- (int);
00134 
00135 
00137 
00141 
00143     bool operator + () const { return Base::getTraits().isValid(); }
00144 
00146     bool operator - () const { return !Base::getTraits().isValid(); }
00147 
00154     bool operator < (const ConstReverseIterator& iterator) const;
00155 
00163     bool operator <= (const ConstReverseIterator& iterator) const;
00164 
00172     bool operator >= (const ConstReverseIterator& iterator) const;
00173 
00180     bool operator > (const ConstReverseIterator& iterator) const;
00181 
00183 
00184       
00185 
00192     const DataType& operator [] (Index index) const;
00194 
00195     protected:
00196 
00197     ConstReverseIterator(const Container& container)
00198       : Base(container)
00199     {
00200     }
00201   };
00203 
00204   template <typename Container, typename DataType, typename Position, typename Traits>
00205   ConstReverseIterator<Container, DataType, Position, Traits>& 
00206     ConstReverseIterator<Container, DataType, Position, Traits>::operator ++ ()
00207   {
00208       if (!Base::getTraits().isValid())
00209       {
00210         Exception::InvalidIterator e;
00211         throw(e);
00212       }
00213     Base::getTraits().backward();
00214     return *this;
00215   }
00216 
00217   template <typename Container, typename DataType, typename Position, typename Traits>
00218   ConstReverseIterator<Container, DataType, Position, Traits> 
00219     ConstReverseIterator<Container, DataType, Position, Traits>::operator ++ (int)
00220   {
00221       if (!Base::getTraits().isValid())
00222       {
00223         Exception::InvalidIterator e;
00224         throw(e);
00225       }
00226     ConstReverseIterator iterator(*this);
00227     ++(*this);
00228     return iterator;
00229   }
00230 
00231   template <typename Container, typename DataType, typename Position, typename Traits>
00232   ConstReverseIterator<Container, DataType, Position, Traits>& 
00233     ConstReverseIterator<Container, DataType, Position, Traits>::operator -- ()
00234   { 
00235       if (Base::getTraits().isSingular())
00236       {
00237         Exception::SingularIterator e;
00238         throw(e);
00239       }
00240     Base::getTraits().forward();
00241     return *this;
00242   }
00243 
00244   template <typename Container, typename DataType, typename Position, typename Traits>
00245   ConstReverseIterator<Container, DataType, Position, Traits> 
00246     ConstReverseIterator<Container, DataType, Position, Traits>::operator -- (int)
00247   { 
00248       if (Base::getTraits().isSingular())
00249       {
00250         Exception::SingularIterator e;
00251         throw(e);
00252       }
00253     ConstReverseIterator iterator(*this);
00254     --(*this);
00255     return iterator;
00256   }
00257   
00263   template <typename Container, typename DataType, typename Position, typename Traits>
00264   ConstReverseIterator<Container, DataType, Position, Traits> operator + 
00265     (Distance distance, const ConstReverseIterator<Container, DataType, Position, Traits>& iterator) 
00266   {
00267     ConstReverseIterator<Container, DataType, Position, Traits> tmp_iterator(iterator);
00268     return (tmp_iterator += distance);
00269   }
00270 
00277   template <typename Container, typename DataType, typename Position, typename Traits>
00278   Distance ConstReverseIterator<Container, DataType, Position, Traits>::operator -
00279     (const ConstReverseIterator<Container, DataType, Position, Traits>& b) const
00280   {
00281     if (!Base::getTraits().isValid())
00282     {
00283       Exception::InvalidIterator e;
00284       throw e;
00285     }
00286     if (!b.getTraits().isValid())
00287     {
00288       Exception::InvalidIterator e;
00289       throw e;
00290     }
00291     if (Base::getTraits().getContainer() != b.getTraits().getContainer())
00292     {
00293       Exception::IncompatibleIterators e;
00294       throw e;
00295     }
00296     return Base::getTraits().getDistance(b.getTraits());
00297   }
00298 
00299   template <typename Container, typename DataType, typename Position, typename Traits>
00300   ConstReverseIterator<Container, DataType, Position, Traits>&
00301     ConstReverseIterator<Container, DataType, Position, Traits>::operator += (Distance distance)
00302   {
00303     if (!Base::getTraits().isValid())
00304     {
00305       Exception::InvalidIterator e;
00306       throw e;
00307     }
00308     if (distance < (Distance)0)
00309     {
00310       return (*this -= -distance);
00311     }
00312     Base::getTraits().backward(distance);
00313     return *this;
00314   }
00315 
00316   template <typename Container, typename DataType, typename Position, typename Traits>
00317   ConstReverseIterator<Container, DataType, Position, Traits>&
00318     ConstReverseIterator<Container, DataType, Position, Traits>::operator -= (Distance distance)
00319   {
00320     if (Base::getTraits().isSingular())
00321     {
00322       Exception::InvalidIterator e;
00323       throw e;
00324     }
00325     if (distance < (Distance)0)
00326     {
00327       return (*this += -distance);
00328     }
00329     if (Base::getTraits().isREnd() == true)
00330     {
00331       Base::getTraits().toBegin();
00332       Base::getTraits().forward(distance - 1);
00333     }
00334     else 
00335     {
00336       Base::getTraits().forward(distance);
00337     }
00338     return *this;
00339   }
00340 
00341   template <typename Container, typename DataType, typename Position, typename Traits>
00342   ConstReverseIterator<Container, DataType, Position, Traits>
00343     ConstReverseIterator<Container, DataType, Position, Traits>::operator + (Distance distance) const
00344   {
00345     ConstReverseIterator iterator(*this);
00346     return (iterator += distance);
00347   }
00348 
00349   template <typename Container, typename DataType, typename Position, typename Traits>
00350   ConstReverseIterator<Container, DataType, Position, Traits> 
00351     ConstReverseIterator<Container, DataType, Position, Traits>::operator - (Distance distance) const
00352   {
00353     ConstReverseIterator iterator(*this);
00354     return (iterator -= distance);
00355   }
00356 
00357   template <typename Container, typename DataType, typename Position, typename Traits>
00358   bool ConstReverseIterator<Container, DataType, Position, Traits>::operator < 
00359     (const ConstReverseIterator& iterator) const
00360   {
00361     if (!Base::getTraits().isValid())
00362     {
00363       Exception::InvalidIterator e;
00364       throw e;
00365     }
00366     if (!iterator.isValid())
00367     {
00368       Exception::InvalidIterator e;
00369       throw e;        
00370     }
00371     if (Base::getTraits().getContainer() != iterator.getContainer())
00372     {
00373       Exception::IncompatibleIterators e;
00374       throw e;
00375     }
00376 
00377     return !(Base::getTraits().operator < (iterator.getTraits()));
00378   }
00379 
00380   template <typename Container, typename DataType, typename Position, typename Traits>
00381   bool ConstReverseIterator<Container, DataType, Position, Traits>::operator <= 
00382     (const ConstReverseIterator& iterator) const
00383   {
00384     if (!Base::getTraits().isValid())
00385     {
00386       Exception::InvalidIterator e;
00387       throw e;  
00388     }
00389     if (!iterator.isValid())
00390     {
00391       Exception::InvalidIterator e;
00392       throw e;  
00393     }
00394     if (Base::getTraits().getContainer() != iterator.getContainer())
00395     {
00396       Exception::IncompatibleIterators e;
00397       throw e;
00398     }
00399     return (Base::getTraits().operator > (iterator.getTraits()));
00400   }
00401 
00402   template <typename Container, typename DataType, typename Position, typename Traits>
00403   bool ConstReverseIterator<Container, DataType, Position, Traits>::operator >= 
00404     (const ConstReverseIterator& iterator) const
00405   {
00406     if (!Base::getTraits().isValid())
00407     {
00408       Exception::InvalidIterator e;
00409       throw e;
00410     }
00411     if (!iterator.isValid())
00412     {
00413       Exception::InvalidIterator e;
00414       throw e;
00415     }
00416     if (Base::getTraits().getContainer() != iterator.getContainer())
00417     {
00418       Exception::IncompatibleIterators e;
00419       throw e;
00420     }
00421 
00422     return (Base::getTraits().operator < (iterator.getTraits()));
00423   }
00424 
00425   template <typename Container, typename DataType, typename Position, typename Traits>
00426   bool ConstReverseIterator<Container, DataType, Position, Traits>::operator > 
00427     (const ConstReverseIterator& iterator) const
00428   {
00429     if (!Base::getTraits().isValid())
00430     {
00431       Exception::InvalidIterator e;
00432       throw e;
00433     }
00434     if (!iterator.isValid())
00435     {
00436       Exception::InvalidIterator e;
00437       throw e;
00438     }
00439     if (Base::getTraits().getContainer() != iterator.getContainer())
00440     {
00441       Exception::IncompatibleIterators e;
00442       throw e;
00443     }
00444 
00445     return !(Base::getTraits().operator > (iterator.getTraits()));
00446   }
00447 
00448   
00449   template <typename Container, typename DataType, typename Position, typename Traits>
00450   const DataType& ConstReverseIterator<Container, DataType, Position, Traits>::operator [] (Index index) const
00451   {
00452     if (!Base::getTraits().isValid())
00453     {
00454       Exception::InvalidIterator e;
00455       throw e;
00456     }
00457 
00458     return Base::getTraits().getData(index);
00459   }
00460 
00461   template <typename Container, typename DataType, typename Position, typename Traits>
00462   ConstReverseIterator<Container, DataType, Position, Traits> 
00463     ConstReverseIterator<Container, DataType, Position, Traits>::begin(const Container& container)
00464   {
00465     ConstReverseIterator iterator(container);
00466     iterator.toRBegin();
00467     return iterator;
00468   }
00469 
00470   template <typename Container, typename DataType, typename Position, typename Traits>
00471   ConstReverseIterator<Container, DataType, Position, Traits> 
00472     ConstReverseIterator<Container, DataType, Position, Traits>::end(const Container& container)
00473   {
00474     ConstReverseIterator iterator(container);
00475     iterator.toREnd();
00476     return iterator;
00477   }
00478 
00479   template <typename Container, typename DataType, typename Position, typename Traits>
00480   ConstReverseIterator<Container, DataType, Position, Traits> 
00481     ConstReverseIterator<Container, DataType, Position, Traits>::rbegin(const Container& container)
00482   {
00483     ConstReverseIterator iterator(container);
00484     iterator.toBegin();
00485     return iterator;
00486   }
00487 
00488   template <typename Container, typename DataType, typename Position, typename Traits>
00489   ConstReverseIterator<Container, DataType, Position, Traits> 
00490     ConstReverseIterator<Container, DataType, Position, Traits>::rend(const Container& container)
00491   {
00492     ConstReverseIterator iterator(container);
00493     iterator.toEnd();
00494     return iterator;
00495   }
00496 
00501 
00504   template <typename Container, typename DataType, typename Position, typename Traits>
00505   class ReverseIterator
00506     : public ConstReverseIterator<Container, DataType, Position, Traits>
00507   {
00508     public:
00509 
00513 
00514           typedef DataType& reference;
00516     typedef DataType* pointer;
00518     typedef ConstReverseIterator<Container, DataType, Position, Traits> Base;
00520 
00524 
00526     ReverseIterator() {}
00527   
00529     ReverseIterator(const ReverseIterator& iterator)
00530       : Base(iterator)
00531     {
00532     }
00533 
00535     ~ReverseIterator() {}
00537 
00544     reference operator [] (Index index) const { return const_cast<reference>(Base::getTraits().getData(index)); }
00546     reference operator * () const { return const_cast<reference>(Base::getTraits().getData()); }
00548     pointer operator -> () const { return const_cast<pointer>(&Base::getTraits().getData()); }
00550 
00558     static ReverseIterator begin(const Container& container);
00559 
00564     static ReverseIterator end(const Container& container);
00565 
00570     static ReverseIterator rbegin(const Container& container);
00571 
00576     static ReverseIterator rend(const Container& container);
00578 
00579     protected:
00580 
00581     ReverseIterator(const Container& container)
00582       : Base(container)
00583     {
00584     }
00585 
00586   };
00588   
00589   template <typename Container, typename DataType, typename Position, typename Traits>
00590   ReverseIterator<Container, DataType, Position, Traits> 
00591     ReverseIterator<Container, DataType, Position, Traits>::begin(const Container& container)
00592   {
00593     ReverseIterator iterator(container);
00594     iterator.toRBegin();
00595     return iterator;
00596   }
00597 
00598   template <typename Container, typename DataType, typename Position, typename Traits>
00599   ReverseIterator<Container, DataType, Position, Traits> 
00600     ReverseIterator<Container, DataType, Position, Traits>::end(const Container& container)
00601   {
00602     ReverseIterator iterator(container);
00603     iterator.toREnd();
00604     return iterator;
00605   }
00606 
00607   template <typename Container, typename DataType, typename Position, typename Traits>
00608   ReverseIterator<Container, DataType, Position, Traits> 
00609     ReverseIterator<Container, DataType, Position, Traits>::rbegin(const Container& container)
00610   {
00611     ReverseIterator iterator(container);
00612     iterator.toBegin();
00613     return iterator;
00614   }
00615 
00616   template <typename Container, typename DataType, typename Position, typename Traits>
00617   ReverseIterator<Container, DataType, Position, Traits> 
00618     ReverseIterator<Container, DataType, Position, Traits>::rend(const Container& container)
00619   {
00620     ReverseIterator iterator(container);
00621     iterator.toEnd();
00622     return iterator;
00623   }
00624 
00625 } // namespace BALL 
00626 
00627 #endif // BALL_KERNEL_REVERSEITERATOR_H
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines