SkelGIS
3.0
|
00001 /*! \file iterator_phb.hpp 00002 * \brief This file contains the definitions of the four specific physical border iterators of skelgis. Two template specializations for each iterator. Users do not have to construct an iterator object directly (these objects are constructed in the DMatrix) however operators and methods of the iterator are used by the user. 00003 */ 00004 #ifndef ITERATOR_PHB_H 00005 #define ITERATOR_PHB_H 00006 00007 namespace skelgis{ 00008 00009 //=============================================================================== 00010 //! Iterator class 00011 /*! 00012 template of the left physical border iterator of SkelGIS. 00013 This is the first specialization of iterator_phb_left class. 00014 \tparam T is the type of data stored in the DMatrix to manipulate with the iterator 00015 \tparam R is the overlap distance needed by the calculation, and the same overlap than in the DMatrix to manipulate with this iterator. 00016 */ 00017 //------------------------------------------------------------------------------- 00018 template<class T,int R> struct iterator_phb_left 00019 //------------------------------------------------------------------------------- 00020 { 00021 public: 00022 unsigned int _rank; /*!< current rank of the iterator */ 00023 unsigned int _width; /*!< width of the DMatrix associated to this iterator */ 00024 00025 //! default constructor of the iterator 00026 //------------------------------------------------------------------------------- 00027 iterator_phb_left():_rank(0),_width(0){} 00028 //------------------------------------------------------------------------------- 00029 //! constructor of the iterator 00030 /*! 00031 \param r is the initial rank to assign to the iterator 00032 \param w is the DMatrix width to assign to the iterator 00033 */ 00034 //------------------------------------------------------------------------------- 00035 iterator_phb_left(const unsigned int r,const unsigned int w):_rank(r),_width(w){} 00036 //------------------------------------------------------------------------------- 00037 //! constructor of the iterator from another iterator 00038 /*! 00039 \param it is the other iterator instance from which to construct the new one 00040 */ 00041 //------------------------------------------------------------------------------- 00042 iterator_phb_left(const iterator_phb_left<T,R>& it):_rank(it._rank),_width(it._width){} 00043 //------------------------------------------------------------------------------- 00044 //! Destructor of the iterator 00045 //------------------------------------------------------------------------------- 00046 ~iterator_phb_left(){} 00047 //------------------------------------------------------------------------------- 00048 //! operator ++ pre-incrementation of the iterator 00049 /*! 00050 This operation increments the position of the iterator in the DMatrix. 00051 \return a reference to the resulting iterator itself 00052 */ 00053 //------------------------------------------------------------------------------- 00054 iterator_phb_left<T,R>& operator++() 00055 //------------------------------------------------------------------------------- 00056 { 00057 if((_rank+1)%_width%R==0) 00058 _rank = _rank+_width-(R-1); 00059 else 00060 ++_rank; 00061 return *this; 00062 } 00063 //------------------------------------------------------------------------------- 00064 //! operator ++ post-incrementation of the iterator 00065 /*! 00066 This operation increments the position of the iterator in the DMatrix. 00067 \return a reference to the resulting iterator itself 00068 */ 00069 //------------------------------------------------------------------------------- 00070 iterator_phb_left<T,R>& operator++(int) 00071 //------------------------------------------------------------------------------- 00072 { 00073 iterator_phb_left<T,R> _tmp = *this; 00074 if((_rank+1)%_width%R==0) 00075 _rank = _rank+_width-(R-1); 00076 else 00077 ++_rank; 00078 return _tmp; 00079 } 00080 //------------------------------------------------------------------------------- 00081 //! operator = of the iterator 00082 /*! 00083 This operation assigns another iterator informations to the current one. 00084 \return a reference to the resulting iterator itself 00085 */ 00086 //------------------------------------------------------------------------------- 00087 inline iterator_phb_left<T,R>& operator=(iterator_phb_left<T,R> right) 00088 //------------------------------------------------------------------------------- 00089 { 00090 this->_rank = right._rank; 00091 this->_width = right._width; 00092 return *this; 00093 } 00094 //------------------------------------------------------------------------------- 00095 //! operator == of the iterator 00096 /*! 00097 This operation checks the equality of two iterators with their rank values. 00098 \return true if the two iterator have the same rank. False otherwize. 00099 */ 00100 //------------------------------------------------------------------------------- 00101 inline bool operator==(const iterator_phb_left<T,R> & toTest) {return this->_rank==toTest._rank;} 00102 //------------------------------------------------------------------------------- 00103 //! operator != of the iterator 00104 /*! 00105 This operation checks the inequality of two iterators with their rank values. 00106 \return true if the two iterator do not have the same rank. False otherwize. 00107 */ 00108 //------------------------------------------------------------------------------- 00109 inline bool operator!=(const iterator_phb_left<T,R>& toTest) {return this->_rank!=toTest._rank;} 00110 //------------------------------------------------------------------------------- 00111 //! operator <= of the iterator 00112 /*! 00113 This operation checks if the current iterator rank is smaller or equal to the other one. 00114 \return true is the current iterator rank is smaller or equal. False otherwize. 00115 */ 00116 //------------------------------------------------------------------------------- 00117 inline bool operator <=(const iterator_phb_left<T,R>& toComp) {return this->_rank<=toComp._rank;} 00118 //------------------------------------------------------------------------------- 00119 //! operator < of the iterator 00120 /*! 00121 This operation checks if the current iterator rank is smaller than the other one. 00122 \return true is the current iterator rank is smaller. False otherwize. 00123 */ 00124 //------------------------------------------------------------------------------- 00125 inline bool operator <(const iterator_phb_left<T,R>& toComp) {return this->_rank<toComp._rank;} 00126 //------------------------------------------------------------------------------- 00127 //! operator >= of the iterator 00128 /*! 00129 This operation checks if the current iterator rank is biger or equal to the other one. 00130 \return true is the current iterator rank is biger or equal. False otherwize. 00131 */ 00132 //------------------------------------------------------------------------------- 00133 inline bool operator >=(const iterator_phb_left<T,R>& toComp) {return this->_rank>=toComp._rank;} 00134 //------------------------------------------------------------------------------- 00135 //! operator > of the iterator 00136 /*! 00137 This operation checks if the current iterator rank is biger than the other one. 00138 \return true is the current iterator rank is biger. False otherwize. 00139 */ 00140 //------------------------------------------------------------------------------- 00141 inline bool operator >(const iterator_phb_left<T,R>& toComp) {return this->_rank>toComp._rank;} 00142 //------------------------------------------------------------------------------- 00143 }; 00144 00145 //=============================================================================== 00146 //! Iterator class 00147 /*! 00148 template of the left physical border iterator of SkelGIS. Second specialization. In this case the overlap R is null, then their are no physical borders. 00149 */ 00150 //------------------------------------------------------------------------------- 00151 template<class T> struct iterator_phb_left<T,0>{}; 00152 //------------------------------------------------------------------------------- 00153 00154 //=============================================================================== 00155 //! Iterator class 00156 /*! 00157 template of the up physical border iterator of SkelGIS. 00158 This is the first specialization of iterator_phb_up class. 00159 \tparam T is the type of data stored in the DMatrix to manipulate with the iterator 00160 \tparam R is the overlap distance needed by the calculation, and the same overlap than in the DMatrix to manipulate with this iterator. 00161 */ 00162 //------------------------------------------------------------------------------- 00163 template<class T,int R> struct iterator_phb_up 00164 //------------------------------------------------------------------------------- 00165 { 00166 public: 00167 unsigned int _rank; /*!< current rank of the iterator */ 00168 unsigned int _width; /*!< width of the DMatrix associated to this iterator */ 00169 00170 //! default constructor of the iterator 00171 //------------------------------------------------------------------------------- 00172 iterator_phb_up():_rank(0),_width(0){} 00173 //------------------------------------------------------------------------------- 00174 //! constructor of the iterator 00175 /*! 00176 \param r is the initial rank to assign to the iterator 00177 \param w is the DMatrix width to assign to the iterator 00178 */ 00179 //------------------------------------------------------------------------------- 00180 iterator_phb_up(const unsigned int r,const unsigned int w):_rank(r),_width(w){} 00181 //------------------------------------------------------------------------------- 00182 //! constructor of the iterator from another iterator 00183 /*! 00184 \param it is the other iterator instance from which to construct the new one 00185 */ 00186 //------------------------------------------------------------------------------- 00187 iterator_phb_up(const iterator_phb_up<T,R>& it):_rank(it._rank),_width(it._width){} 00188 //------------------------------------------------------------------------------- 00189 //! Destructor of the iterator 00190 //------------------------------------------------------------------------------- 00191 ~iterator_phb_up(){} 00192 //------------------------------------------------------------------------------- 00193 //! operator ++ pre-incrementation of the iterator 00194 /*! 00195 This operation increments the position of the iterator in the DMatrix. 00196 \return a reference to the resulting iterator itself 00197 */ 00198 //------------------------------------------------------------------------------- 00199 iterator_phb_up<T,R>& operator++() 00200 //------------------------------------------------------------------------------- 00201 { 00202 if((_rank+1)%_width<(_width-R)) 00203 ++_rank; 00204 else 00205 _rank = _rank+2*R+1; 00206 return *this; 00207 } 00208 //------------------------------------------------------------------------------- 00209 //! operator ++ post-incrementation of the iterator 00210 /*! 00211 This operation increments the position of the iterator in the DMatrix. 00212 \return a reference to the resulting iterator itself 00213 */ 00214 //------------------------------------------------------------------------------- 00215 iterator_phb_up<T,R>& operator++(int) 00216 //------------------------------------------------------------------------------- 00217 { 00218 iterator_cont<T,R> _tmp = *this; 00219 if((_rank+1)%_width<(_width-R)) 00220 ++_rank; 00221 else 00222 _rank = _rank+2*R+1; 00223 return _tmp; 00224 } 00225 //------------------------------------------------------------------------------- 00226 //! operator = of the iterator 00227 /*! 00228 This operation assigns another iterator informations to the current one. 00229 \return a reference to the resulting iterator itself 00230 */ 00231 //------------------------------------------------------------------------------- 00232 inline iterator_phb_up<T,R>& operator=(iterator_phb_up<T,R> right) 00233 //------------------------------------------------------------------------------- 00234 { 00235 this->_rank = right._rank; 00236 this->_width = right._width; 00237 return *this; 00238 } 00239 //------------------------------------------------------------------------------- 00240 //! operator == of the iterator 00241 /*! 00242 This operation checks the equality of two iterators with their rank values. 00243 \return true if the two iterator have the same rank. False otherwize. 00244 */ 00245 //------------------------------------------------------------------------------- 00246 inline bool operator==(const iterator_phb_up<T,R> & toTest) {return this->_rank==toTest._rank;} 00247 //------------------------------------------------------------------------------- 00248 //! operator != of the iterator 00249 /*! 00250 This operation checks the inequality of two iterators with their rank values. 00251 \return true if the two iterator do not have the same rank. False otherwize. 00252 */ 00253 //------------------------------------------------------------------------------- 00254 inline bool operator!=(const iterator_phb_up<T,R>& toTest) {return this->_rank!=toTest._rank;} 00255 //------------------------------------------------------------------------------- 00256 //! operator <= of the iterator 00257 /*! 00258 This operation checks if the current iterator rank is smaller or equal to the other one. 00259 \return true is the current iterator rank is smaller or equal. False otherwize. 00260 */ 00261 //------------------------------------------------------------------------------- 00262 inline bool operator <=(const iterator_phb_up<T,R>& toComp) {return this->_rank<=toComp._rank;} 00263 //------------------------------------------------------------------------------- 00264 //! operator < of the iterator 00265 /*! 00266 This operation checks if the current iterator rank is smaller than the other one. 00267 \return true is the current iterator rank is smaller. False otherwize. 00268 */ 00269 //------------------------------------------------------------------------------- 00270 inline bool operator <(const iterator_phb_up<T,R>& toComp) {return this->_rank<toComp._rank;} 00271 //------------------------------------------------------------------------------- 00272 //! operator >= of the iterator 00273 /*! 00274 This operation checks if the current iterator rank is biger or equal to the other one. 00275 \return true is the current iterator rank is biger or equal. False otherwize. 00276 */ 00277 //------------------------------------------------------------------------------- 00278 inline bool operator >=(const iterator_phb_up<T,R>& toComp) {return this->_rank>=toComp._rank;} 00279 //------------------------------------------------------------------------------- 00280 //! operator > of the iterator 00281 /*! 00282 This operation checks if the current iterator rank is biger than the other one. 00283 \return true is the current iterator rank is biger. False otherwize. 00284 */ 00285 //------------------------------------------------------------------------------- 00286 inline bool operator >(const iterator_phb_up<T,R>& toComp) {return this->_rank>toComp._rank;} 00287 //------------------------------------------------------------------------------- 00288 }; 00289 00290 //=============================================================================== 00291 //! Iterator class 00292 /*! 00293 template of the up physical border iterator of SkelGIS. Second specialization. In this case the overlap R is null, then their are no physical borders. 00294 */ 00295 //------------------------------------------------------------------------------- 00296 template<class T> struct iterator_phb_up<T,0>{}; 00297 //------------------------------------------------------------------------------- 00298 00299 //=============================================================================== 00300 //! Iterator class 00301 /*! 00302 template of the right physical border iterator of SkelGIS. 00303 This is the first specialization of iterator_phb_right class. 00304 \tparam T is the type of data stored in the DMatrix to manipulate with the iterator 00305 \tparam R is the overlap distance needed by the calculation, and the same overlap than in the DMatrix to manipulate with this iterator. 00306 */ 00307 //------------------------------------------------------------------------------- 00308 template<class T,int R> struct iterator_phb_right 00309 //------------------------------------------------------------------------------- 00310 { 00311 public: 00312 unsigned int _rank; /*!< current rank of the iterator */ 00313 unsigned int _width; /*!< width of the DMatrix associated to this iterator */ 00314 00315 //! default constructor of the iterator 00316 //------------------------------------------------------------------------------- 00317 iterator_phb_right():_rank(0),_width(0){} 00318 //------------------------------------------------------------------------------- 00319 //! constructor of the iterator 00320 /*! 00321 \param r is the initial rank to assign to the iterator 00322 \param w is the DMatrix width to assign to the iterator 00323 */ 00324 //------------------------------------------------------------------------------- 00325 iterator_phb_right(const unsigned int r,const unsigned int w):_rank(r),_width(w){} 00326 //------------------------------------------------------------------------------- 00327 //! constructor of the iterator from another iterator 00328 /*! 00329 \param it is the other iterator instance from which to construct the new one 00330 */ 00331 //------------------------------------------------------------------------------- 00332 iterator_phb_right(const iterator_phb_right<T,R>& it):_rank(it._rank),_width(it._width){} 00333 //------------------------------------------------------------------------------- 00334 //! Destructor of the iterator 00335 //------------------------------------------------------------------------------- 00336 ~iterator_phb_right(){} 00337 //------------------------------------------------------------------------------- 00338 //! operator ++ pre-incrementation of the iterator 00339 /*! 00340 This operation increments the position of the iterator in the DMatrix. 00341 \return a reference to the resulting iterator itself 00342 */ 00343 //------------------------------------------------------------------------------- 00344 iterator_phb_right<T,R>& operator++() 00345 //------------------------------------------------------------------------------- 00346 { 00347 if((_rank+1-_width+R)%_width%R==0) 00348 _rank = _rank+_width-(R-1); 00349 else 00350 ++_rank; 00351 return *this; 00352 } 00353 //------------------------------------------------------------------------------- 00354 //! operator ++ post-incrementation of the iterator 00355 /*! 00356 This operation increments the position of the iterator in the DMatrix. 00357 \return a reference to the resulting iterator itself 00358 */ 00359 //------------------------------------------------------------------------------- 00360 iterator_phb_right<T,R>& operator++(int) 00361 //------------------------------------------------------------------------------- 00362 { 00363 iterator_cont<T,R> _tmp = *this; 00364 if((_rank+1-_width+R)%_width%R<=(R-1)) 00365 ++_rank; 00366 else 00367 _rank = _rank+_width-(R-1); 00368 return _tmp; 00369 } 00370 //------------------------------------------------------------------------------- 00371 //! operator = of the iterator 00372 /*! 00373 This operation assigns another iterator informations to the current one. 00374 \return a reference to the resulting iterator itself 00375 */ 00376 //------------------------------------------------------------------------------- 00377 inline iterator_phb_right<T,R>& operator=(iterator_phb_right<T,R> & right) 00378 //------------------------------------------------------------------------------- 00379 { 00380 this->_rank = right._rank; 00381 this->_width = right._width; 00382 return *this; 00383 } 00384 //------------------------------------------------------------------------------- 00385 //! operator == of the iterator 00386 /*! 00387 This operation checks the equality of two iterators with their rank values. 00388 \return true if the two iterator have the same rank. False otherwize. 00389 */ 00390 //------------------------------------------------------------------------------- 00391 inline bool operator==(const iterator_phb_right<T,R> & toTest) {return this->_rank==toTest._rank;} 00392 //------------------------------------------------------------------------------- 00393 //! operator != of the iterator 00394 /*! 00395 This operation checks the inequality of two iterators with their rank values. 00396 \return true if the two iterator do not have the same rank. False otherwize. 00397 */ 00398 //------------------------------------------------------------------------------- 00399 inline bool operator!=(const iterator_phb_right<T,R>& toTest) {return this->_rank!=toTest._rank;} 00400 //------------------------------------------------------------------------------- 00401 //! operator <= of the iterator 00402 /*! 00403 This operation checks if the current iterator rank is smaller or equal to the other one. 00404 \return true is the current iterator rank is smaller or equal. False otherwize. 00405 */ 00406 //------------------------------------------------------------------------------- 00407 inline bool operator <=(const iterator_phb_right<T,R>& toComp) {return this->_rank<=toComp._rank;} 00408 //------------------------------------------------------------------------------- 00409 //! operator < of the iterator 00410 /*! 00411 This operation checks if the current iterator rank is smaller than the other one. 00412 \return true is the current iterator rank is smaller. False otherwize. 00413 */ 00414 //------------------------------------------------------------------------------- 00415 inline bool operator <(const iterator_phb_right<T,R>& toComp) {return this->_rank<toComp._rank;} 00416 //------------------------------------------------------------------------------- 00417 //! operator >= of the iterator 00418 /*! 00419 This operation checks if the current iterator rank is biger or equal to the other one. 00420 \return true is the current iterator rank is biger or equal. False otherwize. 00421 */ 00422 //------------------------------------------------------------------------------- 00423 inline bool operator >=(const iterator_phb_right<T,R>& toComp) {return this->_rank>=toComp._rank;} 00424 //------------------------------------------------------------------------------- 00425 //! operator > of the iterator 00426 /*! 00427 This operation checks if the current iterator rank is biger than the other one. 00428 \return true is the current iterator rank is biger. False otherwize. 00429 */ 00430 //------------------------------------------------------------------------------- 00431 inline bool operator >(const iterator_phb_right<T,R>& toComp) {return this->_rank>toComp._rank;} 00432 //------------------------------------------------------------------------------- 00433 }; 00434 00435 //=============================================================================== 00436 //! Iterator class 00437 /*! 00438 template of the right physical border iterator of SkelGIS. Second specialization. In this case the overlap R is null, then their are no physical borders. 00439 */ 00440 //------------------------------------------------------------------------------- 00441 template<class T> struct iterator_phb_right<T,0>{}; 00442 //------------------------------------------------------------------------------- 00443 00444 00445 //=============================================================================== 00446 //! Iterator class 00447 /*! 00448 template of the down physical border iterator of SkelGIS. 00449 This is the first specialization of iterator_phb_down class. 00450 \tparam T is the type of data stored in the DMatrix to manipulate with the iterator 00451 \tparam R is the overlap distance needed by the calculation, and the same overlap than in the DMatrix to manipulate with this iterator. 00452 */ 00453 //------------------------------------------------------------------------------- 00454 template<class T,int R> struct iterator_phb_down 00455 //------------------------------------------------------------------------------- 00456 { 00457 public: 00458 unsigned int _rank; /*!< current rank of the iterator */ 00459 unsigned int _width; /*!< width of the DMatrix associated to this iterator */ 00460 00461 //! default constructor of the iterator 00462 //------------------------------------------------------------------------------- 00463 iterator_phb_down():_rank(0),_width(0){} 00464 //------------------------------------------------------------------------------- 00465 //! constructor of the iterator 00466 /*! 00467 \param r is the initial rank to assign to the iterator 00468 \param w is the DMatrix width to assign to the iterator 00469 */ 00470 //------------------------------------------------------------------------------- 00471 iterator_phb_down(const unsigned int r,const unsigned int w):_rank(r),_width(w){} 00472 //------------------------------------------------------------------------------- 00473 //! constructor of the iterator from another iterator 00474 /*! 00475 \param it is the other iterator instance from which to construct the new one 00476 */ 00477 //------------------------------------------------------------------------------- 00478 iterator_phb_down(const iterator_phb_down<T,R>& it):_rank(it._rank),_width(it._width){} 00479 //------------------------------------------------------------------------------- 00480 //! Destructor of the iterator 00481 //------------------------------------------------------------------------------- 00482 ~iterator_phb_down(){} 00483 //------------------------------------------------------------------------------- 00484 //! operator ++ pre-incrementation of the iterator 00485 /*! 00486 This operation increments the position of the iterator in the DMatrix. 00487 \return a reference to the resulting iterator itself 00488 */ 00489 //------------------------------------------------------------------------------- 00490 iterator_phb_down<T,R>& operator++() 00491 //------------------------------------------------------------------------------- 00492 { 00493 if((_rank+1)%_width<(_width-R)) 00494 ++_rank; 00495 else 00496 _rank = _rank+2*R+1; 00497 return *this; 00498 } 00499 //------------------------------------------------------------------------------- 00500 //! operator ++ post-incrementation of the iterator 00501 /*! 00502 This operation increments the position of the iterator in the DMatrix. 00503 \return a reference to the resulting iterator itself 00504 */ 00505 //------------------------------------------------------------------------------- 00506 iterator_phb_down<T,R>& operator++(int) 00507 //------------------------------------------------------------------------------- 00508 { 00509 iterator_cont<T,R> _tmp = *this; 00510 if((_rank+1)%_width<(_width-R)) 00511 ++_rank; 00512 else 00513 _rank = _rank+2*R+1; 00514 return _tmp; 00515 } 00516 //------------------------------------------------------------------------------- 00517 //! operator = of the iterator 00518 /*! 00519 This operation assigns another iterator informations to the current one. 00520 \return a reference to the resulting iterator itself 00521 */ 00522 //------------------------------------------------------------------------------- 00523 inline iterator_phb_down<T,R>& operator=(iterator_phb_down<T,R> & right) 00524 //------------------------------------------------------------------------------- 00525 { 00526 this->_rank = right._rank; 00527 this->_width = right._width; 00528 return *this; 00529 } 00530 //------------------------------------------------------------------------------- 00531 //! operator == of the iterator 00532 /*! 00533 This operation checks the equality of two iterators with their rank values. 00534 \return true if the two iterator have the same rank. False otherwize. 00535 */ 00536 //------------------------------------------------------------------------------- 00537 inline bool operator==(const iterator_phb_down<T,R> & toTest) {return this->_rank==toTest._rank;} 00538 //------------------------------------------------------------------------------- 00539 //! operator != of the iterator 00540 /*! 00541 This operation checks the inequality of two iterators with their rank values. 00542 \return true if the two iterator do not have the same rank. False otherwize. 00543 */ 00544 //------------------------------------------------------------------------------- 00545 inline bool operator!=(const iterator_phb_down<T,R>& toTest) {return this->_rank!=toTest._rank;} 00546 //------------------------------------------------------------------------------- 00547 //! operator <= of the iterator 00548 /*! 00549 This operation checks if the current iterator rank is smaller or equal to the other one. 00550 \return true is the current iterator rank is smaller or equal. False otherwize. 00551 */ 00552 //------------------------------------------------------------------------------- 00553 inline bool operator <=(const iterator_phb_down<T,R>& toComp) {return this->_rank<=toComp._rank;} 00554 //------------------------------------------------------------------------------- 00555 //! operator < of the iterator 00556 /*! 00557 This operation checks if the current iterator rank is smaller than the other one. 00558 \return true is the current iterator rank is smaller. False otherwize. 00559 */ 00560 //------------------------------------------------------------------------------- 00561 inline bool operator <(const iterator_phb_down<T,R>& toComp) {return this->_rank<toComp._rank;} 00562 //------------------------------------------------------------------------------- 00563 //! operator >= of the iterator 00564 /*! 00565 This operation checks if the current iterator rank is biger or equal to the other one. 00566 \return true is the current iterator rank is biger or equal. False otherwize. 00567 */ 00568 //------------------------------------------------------------------------------- 00569 inline bool operator >=(const iterator_phb_down<T,R>& toComp) {return this->_rank>=toComp._rank;} 00570 //------------------------------------------------------------------------------- 00571 //! operator > of the iterator 00572 /*! 00573 This operation checks if the current iterator rank is biger than the other one. 00574 \return true is the current iterator rank is biger. False otherwize. 00575 */ 00576 //------------------------------------------------------------------------------- 00577 inline bool operator >(const iterator_phb_down<T,R>& toComp) {return this->_rank>toComp._rank;} 00578 //------------------------------------------------------------------------------- 00579 }; 00580 00581 //=============================================================================== 00582 //! Iterator class 00583 /*! 00584 template of the down physical border iterator of SkelGIS. Second specialization. In this case the overlap R is null, then their are no physical borders. 00585 */ 00586 //------------------------------------------------------------------------------- 00587 template<class T> struct iterator_phb_down<T,0>{}; 00588 //------------------------------------------------------------------------------- 00589 00590 00591 } 00592 00593 #endif