BALL
1.4.1
|
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