692 lines
22 KiB
C++
692 lines
22 KiB
C++
//
|
|
// 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"
|
|
#include "../system/Iterator.h" //soc
|
|
|
|
/**********************************/
|
|
/* */
|
|
/* */
|
|
/* 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 Traits>
|
|
class edge_iterator_base : public IteratorBase<Traits,InputIteratorTag_Traits>
|
|
{
|
|
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<Traits> 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<edge_nonconst_traits> iterator;
|
|
typedef edge_iterator_base<edge_const_traits> 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<Traits,InputIteratorTag_Traits> 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<edge_nonconst_traits>& 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<edge_const_traits>& 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 Traits>
|
|
class edge_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
|
|
{
|
|
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<Traits> Self;
|
|
public:
|
|
mutable value_type _ViewEdge;
|
|
//friend class edge_iterator_base<Nonconst_traits<ViewEdge*> >;
|
|
//friend class edge_iterator_base<Const_traits<ViewEdge*> >;
|
|
value_type _first;
|
|
bool _orientation;
|
|
typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
|
|
|
|
public:
|
|
friend class ViewEdge;
|
|
inline edge_iterator_base()
|
|
: parent_class()
|
|
{_orientation=true;_first=0;}
|
|
|
|
inline edge_iterator_base(const edge_iterator_base<Nonconst_traits< ::ViewEdge*> >& iBrother)
|
|
: parent_class()
|
|
{
|
|
_ViewEdge = iBrother._ViewEdge;
|
|
_first = iBrother._first;
|
|
_orientation = iBrother._orientation;
|
|
}
|
|
|
|
inline edge_iterator_base(const edge_iterator_base<Const_traits< ::ViewEdge*> >& 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 Traits>
|
|
class fedge_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
|
|
{
|
|
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<Traits> Self;
|
|
public:
|
|
typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> 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<Nonconst_traits<FEdge*> >& iBrother)
|
|
: parent_class()
|
|
{
|
|
_FEdge = iBrother._FEdge;
|
|
_first = iBrother._first;
|
|
_FEdgeB = iBrother._FEdgeB;
|
|
}
|
|
inline fedge_iterator_base(const fedge_iterator_base<Const_traits<FEdge*> >& 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 Traits>
|
|
class vertex_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
|
|
{
|
|
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<Traits> Self;
|
|
protected:
|
|
typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> 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<Const_traits<SVertex*> >& iBrother)
|
|
: parent_class()
|
|
{
|
|
_SVertex = iBrother._SVertex;
|
|
_NextFEdge = iBrother._NextFEdge;
|
|
_PreviousFEdge = iBrother._PreviousFEdge;
|
|
}
|
|
inline vertex_iterator_base(const vertex_iterator_base<Nonconst_traits<SVertex*> >& 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
|