// // Filename : ViewMapAdvancedIterators.h // Author(s) : Stephane Grabli // Purpose : Iterators used to iterate over the various elements of the ViewMap // These iterators can't be exported to python. // Date of creation : 01/07/2003 // /////////////////////////////////////////////////////////////////////////////// // // Copyright (C) : Please refer to the COPYRIGHT file distributed // with this source distribution. // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation; either version 2 // of the License, or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // /////////////////////////////////////////////////////////////////////////////// #ifndef VIEWMAPADVANCEDITERATORS_H # define VIEWMAPADVANCEDITERATORS_H #include "ViewMap.h" /**********************************/ /* */ /* */ /* ViewMap */ /* */ /* */ /**********************************/ /**********************************/ /* */ /* */ /* ViewVertex */ /* */ /* */ /**********************************/ namespace ViewVertexInternal{ class edge_const_traits : public Const_traits< ::ViewVertex::directedViewEdge> { public: typedef vector< ::ViewVertex::directedViewEdge> edges_container; typedef edges_container::const_iterator edges_container_iterator ; typedef vector< ::ViewVertex::directedViewEdge*> edge_pointers_container; typedef edge_pointers_container::const_iterator edge_pointers_container_iterator ; }; class edge_nonconst_traits : public Nonconst_traits< ::ViewVertex::directedViewEdge> { public: typedef vector< ::ViewVertex::directedViewEdge> edges_container; typedef edges_container::iterator edges_container_iterator ; typedef vector< ::ViewVertex::directedViewEdge*> edge_pointers_container; typedef edge_pointers_container::iterator edge_pointers_container_iterator ; }; template class edge_iterator_base : public IteratorBase { public: typedef typename Traits::value_type value_type; typedef typename Traits::difference_type difference_type; typedef typename Traits::pointer pointer; typedef typename Traits::reference reference; typedef edge_iterator_base Self; typedef typename Traits::edges_container_iterator edges_container_iterator; typedef typename Traits::edge_pointers_container_iterator edge_pointers_container_iterator; typedef edge_iterator_base iterator; typedef edge_iterator_base const_iterator; public: friend class ViewVertex; friend class TVertex; friend class NonTVertex; friend class ViewEdge; friend class edge_iterator; protected: Nature::VertexNature _Nature; // the nature of the underlying vertex // T vertex attributes edge_pointers_container_iterator _tbegin; edge_pointers_container_iterator _tend; edge_pointers_container_iterator _tvertex_iter; // mutable value_type _tvertex_iter; // value_type _feA; // value_type _feB; // value_type _beA; // value_type _beB; // Non TVertex attributes edges_container_iterator _begin; edges_container_iterator _end; edges_container_iterator _nontvertex_iter; typedef IteratorBase parent_class; public: inline edge_iterator_base() : parent_class() {} inline edge_iterator_base(Nature::VertexNature iNature) : parent_class() {_Nature = iNature;} edge_iterator_base(const edge_iterator_base& iBrother) : parent_class(iBrother) { _Nature = iBrother._Nature; if(_Nature & Nature::T_VERTEX) { // _feA = iBrother._feA; // _feB = iBrother._feB; // _beA = iBrother._beA; // _beB = iBrother._beB; // _tvertex_iter = iBrother._tvertex_iter; _tbegin = iBrother._tbegin; _tend = iBrother._tend; _tvertex_iter = iBrother._tvertex_iter; } else { _begin = iBrother._begin; _end = iBrother._end; _nontvertex_iter = iBrother._nontvertex_iter; } } edge_iterator_base(const edge_iterator_base& iBrother) : parent_class(iBrother) { _Nature = iBrother._Nature; if(_Nature & Nature::T_VERTEX) { // _feA = iBrother._feA; // _feB = iBrother._feB; // _beA = iBrother._beA; // _beB = iBrother._beB; // _tvertex_iter = iBrother._tvertex_iter; _tbegin = iBrother._tbegin; _tend = iBrother._tend; _tvertex_iter = iBrother._tvertex_iter; } else { _begin = iBrother._begin; _end = iBrother._end; _nontvertex_iter = iBrother._nontvertex_iter; } } virtual ~edge_iterator_base() {} //protected://FIXME public: // inline edge_iterator_base(value_type ifeA, // value_type ifeB, // value_type ibeA, // value_type ibeB, // value_type iter) // : parent_class() // { // _Nature = Nature::T_VERTEX; // _feA = ifeA; // _feB = ifeB; // _beA = ibeA; // _beB = ibeB; // _tvertex_iter = iter; // } inline edge_iterator_base(edge_pointers_container_iterator begin, edge_pointers_container_iterator end, edge_pointers_container_iterator iter) : parent_class() { _Nature = Nature::T_VERTEX; _tbegin = begin; _tend = end; _tvertex_iter = iter; } inline edge_iterator_base(edges_container_iterator begin, edges_container_iterator end, edges_container_iterator iter) : parent_class() { _Nature = Nature::NON_T_VERTEX; _begin = begin; _end = end; _nontvertex_iter = iter; } public: virtual bool begin() const { if(_Nature & Nature::T_VERTEX) return (_tvertex_iter == _tbegin); //return (_tvertex_iter == _feA); else return (_nontvertex_iter == _begin); } virtual bool end() const { if(_Nature & Nature::T_VERTEX) //return (_tvertex_iter.first == 0); return (_tvertex_iter == _tend); else return (_nontvertex_iter == _end); } // operators virtual Self& operator++() // operator corresponding to ++i { increment(); return *this; } virtual Self operator++(int) // opérateur correspondant à i++ { // c.a.d qui renvoie la valeur *puis* incrémente. Self tmp = *this; // C'est pour cela qu'on stocke la valeur increment(); // dans un temporaire. return tmp; } // comparibility virtual bool operator!=(const Self& b) const { if(_Nature & Nature::T_VERTEX) return (_tvertex_iter != b._tvertex_iter); else return (_nontvertex_iter != b._nontvertex_iter); } virtual bool operator==(const Self& b) const {return !(*this != b);} // dereferencing virtual reference operator*() const { if(_Nature & Nature::T_VERTEX) //return _tvertex_iter; return **_tvertex_iter; else return (*_nontvertex_iter); } virtual pointer operator->() const { return &(operator*());} protected: inline void increment() { if(_Nature & Nature::T_VERTEX) { value_type tmp = (**_tvertex_iter); ++_tvertex_iter; value_type tmp2 = (**_tvertex_iter); if(tmp2.first == tmp.first) ++_tvertex_iter; // // Hack to deal with cusp. the result of a cusp // // is a TVertex having two identical viewedges. // // In order to iterate properly, we chose to // // to skip these last ones. // if(_feB.first == _beA.first) // { // if(_feA.first == _beB.first) // { // _tvertex_iter.first = 0; // return; // } // // if(_tvertex_iter.first == _feA.first) // _tvertex_iter.first = _beB.first; // else if(_tvertex_iter.first == _beB.first) // _tvertex_iter.first = 0; // else // _tvertex_iter.first = _feA.first; // return; // } // if(_feA.first == _beB.first) // { // if(_feB.first == _beA.first) // { // _tvertex_iter.first = 0; // return; // } // // if(_tvertex_iter.first == _feB.first) // _tvertex_iter.first = _beA.first; // else if(_tvertex_iter.first == _beA.first) // _tvertex_iter.first = 0; // else // _tvertex_iter.first = _feB.first; // return; // } // // End of hack // // if(_tvertex_iter.first == _feA.first){ // // we return bea or beb // // // // choose one of them // // _tvertex_iter.first = _feB.first; // return; // } // if(_tvertex_iter.first == _feB.first) // { // _tvertex_iter.first = _beA.first; // return; // } // if(_tvertex_iter.first == _beA.first) // { // _tvertex_iter.first = _beB.first; // return; // } // if(_tvertex_iter.first == _beB.first) // { // _tvertex_iter.first = 0; // return; // } } else ++_nontvertex_iter; } }; } /**********************************/ /* */ /* */ /* ViewEdge */ /* */ /* */ /**********************************/ namespace ViewEdgeInternal { /*!----------------------*/ /*! Iterators definition */ /*!----------------------*/ template class edge_iterator_base : public IteratorBase { public: typedef typename Traits::value_type value_type; typedef typename Traits::difference_type difference_type; typedef typename Traits::pointer pointer; typedef typename Traits::reference reference; typedef edge_iterator_base Self; public: mutable value_type _ViewEdge; //friend class edge_iterator_base >; //friend class edge_iterator_base >; value_type _first; bool _orientation; typedef IteratorBase parent_class; public: friend class ViewEdge; inline edge_iterator_base() : parent_class() {_orientation=true;_first=0;} inline edge_iterator_base(const edge_iterator_base >& iBrother) : parent_class() { _ViewEdge = iBrother._ViewEdge; _first = iBrother._first; _orientation = iBrother._orientation; } inline edge_iterator_base(const edge_iterator_base >& iBrother) : parent_class() { _ViewEdge = iBrother._ViewEdge; _first = iBrother._first; _orientation = iBrother._orientation; } //protected://FIXME public: inline edge_iterator_base(value_type iEdge, bool orientation = true) : parent_class() { _ViewEdge = iEdge; _first = iEdge; _orientation = orientation; } public: virtual Self* clone() const { return new edge_iterator_base(*this); } virtual ~edge_iterator_base() {} public: virtual bool orientation() {return _orientation;} virtual void set_edge(value_type iVE) {_ViewEdge=iVE;} virtual void set_orientation(bool iOrientation) {_orientation = iOrientation;} virtual void change_orientation() {_orientation = !_orientation;} // operators inline Self& operator++() // operator corresponding to ++i { //++_ViewEdge->getTimeStamp(); increment(); return *this; } inline Self operator++(int) // opérateur correspondant à i++ { // c.a.d qui renvoie la valeur *puis* incrémente. //++_ViewEdge->getTimeStamp(); Self tmp = *this; // C'est pour cela qu'on stocke la valeur increment(); // dans un temporaire. return tmp; } inline Self& operator--() // operator corresponding to ++i { //++_ViewEdge->getTimeStamp(); decrement(); return *this; } inline Self operator--(int) // opérateur correspondant à i++ { // c.a.d qui renvoie la valeur *puis* incrémente. //++_ViewEdge->getTimeStamp(); Self tmp = *this; // C'est pour cela qu'on stocke la valeur decrement(); // dans un temporaire. return tmp; } // comparibility virtual bool operator!=(const Self& b) const { return (_ViewEdge != b._ViewEdge); } virtual bool operator==(const Self& b) const { return !(*this != b); } // dereferencing virtual reference operator*() const {return (_ViewEdge);} virtual pointer operator->() const { return &(operator*());} public: virtual bool begin() const {return _ViewEdge==_first ? true : false;} virtual bool end() const {return _ViewEdge==0 ? true : false;} protected: virtual void increment() {} virtual void decrement() {} }; template class fedge_iterator_base : public IteratorBase { public: typedef typename Traits::value_type value_type; typedef typename Traits::difference_type difference_type; typedef typename Traits::pointer pointer; typedef typename Traits::reference reference; typedef fedge_iterator_base Self; public: typedef IteratorBase parent_class; mutable value_type _FEdge; value_type _first; value_type _FEdgeB; // last fedge of the view edge public: friend class ::ViewEdge; friend class fedge_iterator; inline fedge_iterator_base() : parent_class() {} inline fedge_iterator_base(const fedge_iterator_base >& iBrother) : parent_class() { _FEdge = iBrother._FEdge; _first = iBrother._first; _FEdgeB = iBrother._FEdgeB; } inline fedge_iterator_base(const fedge_iterator_base >& iBrother) : parent_class() { _FEdge = iBrother._FEdge; _first = iBrother._first; _FEdgeB = iBrother._FEdgeB; } //protected://FIXME public: inline fedge_iterator_base(value_type iEdge, value_type iFEdgeB) : parent_class() { _FEdge = iEdge; _first = iEdge; _FEdgeB = iFEdgeB; } public: virtual ~fedge_iterator_base() {} // operators inline Self& operator++() // operator corresponding to ++i { increment(); return *this; } inline Self operator++(int) // opérateur correspondant à i++ { // c.a.d qui renvoie la valeur *puis* incrémente. Self tmp = *this; // C'est pour cela qu'on stocke la valeur increment(); // dans un temporaire. return tmp; } inline Self& operator--() // operator corresponding to ++i { decrement(); return *this; } inline Self operator--(int) // opérateur correspondant à i++ { // c.a.d qui renvoie la valeur *puis* incrémente. Self tmp = *this; // C'est pour cela qu'on stocke la valeur decrement(); // dans un temporaire. return tmp; } // comparibility virtual bool operator!=(const Self& b) const { return (_FEdge != b._FEdge); } virtual bool operator==(const Self& b) const { return !(*this != b); } // dereferencing virtual reference operator*() const {return (_FEdge);} virtual pointer operator->() const { return &(operator*());} public: virtual bool begin() const {return _FEdge==_first ? true : false;} virtual bool end() const {return _FEdge==0 ? true : false;} protected: virtual void increment() { _FEdge = _FEdge->nextEdge(); // we don't change or } virtual void decrement() { if(0 == _FEdge) { _FEdge = _FEdgeB; return; } _FEdge = _FEdge->previousEdge(); // we don't change or } }; template class vertex_iterator_base : public IteratorBase { public: typedef typename Traits::value_type value_type; typedef typename Traits::difference_type difference_type; typedef typename Traits::pointer pointer; typedef typename Traits::reference reference; typedef vertex_iterator_base Self; protected: typedef IteratorBase parent_class; public: mutable value_type _SVertex; FEdge *_NextFEdge; FEdge *_PreviousFEdge; public: friend class ViewEdge; friend class vertex_iterator; inline vertex_iterator_base() : parent_class() {} inline vertex_iterator_base(const vertex_iterator_base >& iBrother) : parent_class() { _SVertex = iBrother._SVertex; _NextFEdge = iBrother._NextFEdge; _PreviousFEdge = iBrother._PreviousFEdge; } inline vertex_iterator_base(const vertex_iterator_base >& iBrother) : parent_class() { _SVertex = iBrother._SVertex; _NextFEdge = iBrother._NextFEdge; _PreviousFEdge = iBrother._PreviousFEdge; } //protected://FIXME public: inline vertex_iterator_base(value_type iVertex, FEdge *iPreviousFEdge, FEdge *iNextFEdge) : parent_class() { _SVertex = iVertex; _NextFEdge = iNextFEdge; _PreviousFEdge = iPreviousFEdge; } public: virtual ~vertex_iterator_base() {} virtual bool begin() const {return _PreviousFEdge==0? true : false;} virtual bool end() const {return _SVertex==0 ? true : false;} // operators inline Self& operator++() // operator corresponding to ++i { increment(); return *this; } inline Self operator++(int) // opérateur correspondant à i++ { // c.a.d qui renvoie la valeur *puis* incrémente. Self tmp = *this; // C'est pour cela qu'on stocke la valeur increment(); // dans un temporaire. return tmp; } inline Self& operator--() // operator corresponding to ++i { decrement(); return *this; } inline Self operator--(int) // opérateur correspondant à i++ { // c.a.d qui renvoie la valeur *puis* incrémente. Self tmp = *this; // C'est pour cela qu'on stocke la valeur decrement(); // dans un temporaire. return tmp; } // comparibility virtual bool operator!=(const Self& b) const { return (_SVertex != b._SVertex); } virtual bool operator==(const Self& b) const { return !(*this != b); } // dereferencing virtual reference operator*() const {return (_SVertex);} virtual pointer operator->() const { return &(operator*());} protected: virtual void increment() { if(0 == _NextFEdge) { _SVertex = 0; return; } _SVertex = _NextFEdge->vertexB(); _PreviousFEdge = _NextFEdge; _NextFEdge = _NextFEdge->nextEdge(); } virtual void decrement() { // if(0 == _SVertex) // { // _SVertex = _PreviousFEdge->vertexB(); // return; // } if(0 == _PreviousFEdge) { _SVertex = 0; return; } _SVertex = _PreviousFEdge->vertexA(); _NextFEdge = _PreviousFEdge; _PreviousFEdge = _PreviousFEdge->previousEdge(); } }; } // end of namespace ViewEdgeInternal #endif // VIEWMAPADVANCEDITERATORS_H