SkelGIS  3.0
/home/helene/Documents/These/SkelGIS/SkelGIS_Library/SkelGIS_V3/skelgis/iterators/DMatrix/iterator_phb.hpp
Go to the documentation of this file.
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
 All Classes Files Functions Variables Defines