Mercuriallemon-main / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
lemon/bits/graph_adaptor_extender.h
changeset 422 62c1ed05e83f
parent 414 05357da973ce
child 440 88ed40ad0d4f
child 453 c246659c8b19
equal deleted inserted replaced
0:f845889889f3 1:5a0a229fa7a9 
     1 /* -*- C++ -*-
 
     1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
 
     2  *
 
     2  *
 
     3  * This file is a part of LEMON, a generic C++ optimization library
 
     3  * This file is a part of LEMON, a generic C++ optimization library.
 
     4  *
 
     4  *
 
     5  * Copyright (C) 2003-2008
 
     5  * Copyright (C) 2003-2008
 
     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 
     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 
     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 
     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 
     8  *
 
     8  *
 
    22 #include <lemon/core.h>
 
    22 #include <lemon/core.h>
 
    23 #include <lemon/error.h>
 
    23 #include <lemon/error.h>
 
    24 
    24 
    25 #include <lemon/bits/default_map.h>
 
    25 #include <lemon/bits/default_map.h>
 
    26 
    26 
    27 
       
    28 ///\ingroup digraphbits
 
       
    29 ///\file
 
       
    30 ///\brief Extenders for the digraph adaptor types
 
       
    31 namespace lemon {
 
    27 namespace lemon {
 
    32 
    28 
    33   /// \ingroup digraphbits
 
       
    34   ///
 
       
    35   /// \brief Extender for the DigraphAdaptors
 
       
    36   template <typename _Digraph>
 
    29   template <typename _Digraph>
 
    37   class DigraphAdaptorExtender : public _Digraph {
 
    30   class DigraphAdaptorExtender : public _Digraph {
 
    38   public:
 
    31   public:
 
    39 
    32 
    40     typedef _Digraph Parent;
 
    33     typedef _Digraph Parent;
 
    62       return Parent::arcFromId(id);
 
    55       return Parent::arcFromId(id);
 
    63     }
 
    56     }
 
    64 
    57 
    65     Node oppositeNode(const Node &n, const Arc &e) const {
 
    58     Node oppositeNode(const Node &n, const Arc &e) const {
 
    66       if (n == Parent::source(e))
 
    59       if (n == Parent::source(e))
 
    67 	return Parent::target(e);
 
    60         return Parent::target(e);
 
    68       else if(n==Parent::target(e))
 
    61       else if(n==Parent::target(e))
 
    69 	return Parent::source(e);
 
    62         return Parent::source(e);
 
    70       else
 
    63       else
 
    71 	return INVALID;
 
    64         return INVALID;
 
    72     }
 
    65     }
 
    73 
    66 
    74     class NodeIt : public Node { 
    67     class NodeIt : public Node {
 
    75       const Adaptor* _adaptor;
 
    68       const Adaptor* _adaptor;
 
    76     public:
 
    69     public:
 
    77 
    70 
    78       NodeIt() {}
 
    71       NodeIt() {}
 
    79 
    72 
    80       NodeIt(Invalid i) : Node(i) { }
 
    73       NodeIt(Invalid i) : Node(i) { }
 
    81 
    74 
    82       explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
    75       explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
    83 	_adaptor->first(static_cast<Node&>(*this));
 
    76         _adaptor->first(static_cast<Node&>(*this));
 
    84       }
 
    77       }
 
    85 
    78 
    86       NodeIt(const Adaptor& adaptor, const Node& node) 
    79       NodeIt(const Adaptor& adaptor, const Node& node)
 
    87 	: Node(node), _adaptor(&adaptor) {}
 
    80         : Node(node), _adaptor(&adaptor) {}
 
    88 
    81 
    89       NodeIt& operator++() { 
    82       NodeIt& operator++() {
 
    90 	_adaptor->next(*this);
 
    83         _adaptor->next(*this);
 
    91 	return *this; 
    84         return *this;
 
    92       }
 
    85       }
 
    93 
    86 
    94     };
 
    87     };
 
    95 
    88 
    96 
    89 
    97     class ArcIt : public Arc { 
    90     class ArcIt : public Arc {
 
    98       const Adaptor* _adaptor;
 
    91       const Adaptor* _adaptor;
 
    99     public:
 
    92     public:
 
   100 
    93 
   101       ArcIt() { }
 
    94       ArcIt() { }
 
   102 
    95 
   103       ArcIt(Invalid i) : Arc(i) { }
 
    96       ArcIt(Invalid i) : Arc(i) { }
 
   104 
    97 
   105       explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
    98       explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
   106 	_adaptor->first(static_cast<Arc&>(*this));
 
    99         _adaptor->first(static_cast<Arc&>(*this));
 
   107       }
 
   100       }
 
   108 
   101 
   109       ArcIt(const Adaptor& adaptor, const Arc& e) : 
   102       ArcIt(const Adaptor& adaptor, const Arc& e) :
 
   110 	Arc(e), _adaptor(&adaptor) { }
 
   103         Arc(e), _adaptor(&adaptor) { }
 
   111 
   104 
   112       ArcIt& operator++() { 
   105       ArcIt& operator++() {
 
   113 	_adaptor->next(*this);
 
   106         _adaptor->next(*this);
 
   114 	return *this; 
   107         return *this;
 
   115       }
 
   108       }
 
   116 
   109 
   117     };
 
   110     };
 
   118 
   111 
   119 
   112 
   120     class OutArcIt : public Arc { 
   113     class OutArcIt : public Arc {
 
   121       const Adaptor* _adaptor;
 
   114       const Adaptor* _adaptor;
 
   122     public:
 
   115     public:
 
   123 
   116 
   124       OutArcIt() { }
 
   117       OutArcIt() { }
 
   125 
   118 
   126       OutArcIt(Invalid i) : Arc(i) { }
 
   119       OutArcIt(Invalid i) : Arc(i) { }
 
   127 
   120 
   128       OutArcIt(const Adaptor& adaptor, const Node& node) 
   121       OutArcIt(const Adaptor& adaptor, const Node& node)
 
   129 	: _adaptor(&adaptor) {
 
   122         : _adaptor(&adaptor) {
 
   130 	_adaptor->firstOut(*this, node);
 
   123         _adaptor->firstOut(*this, node);
 
   131       }
 
   124       }
 
   132 
   125 
   133       OutArcIt(const Adaptor& adaptor, const Arc& arc) 
   126       OutArcIt(const Adaptor& adaptor, const Arc& arc)
 
   134 	: Arc(arc), _adaptor(&adaptor) {}
 
   127         : Arc(arc), _adaptor(&adaptor) {}
 
   135 
   128 
   136       OutArcIt& operator++() { 
   129       OutArcIt& operator++() {
 
   137 	_adaptor->nextOut(*this);
 
   130         _adaptor->nextOut(*this);
 
   138 	return *this; 
   131         return *this;
 
   139       }
 
   132       }
 
   140 
   133 
   141     };
 
   134     };
 
   142 
   135 
   143 
   136 
   144     class InArcIt : public Arc { 
   137     class InArcIt : public Arc {
 
   145       const Adaptor* _adaptor;
 
   138       const Adaptor* _adaptor;
 
   146     public:
 
   139     public:
 
   147 
   140 
   148       InArcIt() { }
 
   141       InArcIt() { }
 
   149 
   142 
   150       InArcIt(Invalid i) : Arc(i) { }
 
   143       InArcIt(Invalid i) : Arc(i) { }
 
   151 
   144 
   152       InArcIt(const Adaptor& adaptor, const Node& node) 
   145       InArcIt(const Adaptor& adaptor, const Node& node)
 
   153 	: _adaptor(&adaptor) {
 
   146         : _adaptor(&adaptor) {
 
   154 	_adaptor->firstIn(*this, node);
 
   147         _adaptor->firstIn(*this, node);
 
   155       }
 
   148       }
 
   156 
   149 
   157       InArcIt(const Adaptor& adaptor, const Arc& arc) : 
   150       InArcIt(const Adaptor& adaptor, const Arc& arc) :
 
   158 	Arc(arc), _adaptor(&adaptor) {}
 
   151         Arc(arc), _adaptor(&adaptor) {}
 
   159 
   152 
   160       InArcIt& operator++() { 
   153       InArcIt& operator++() {
 
   161 	_adaptor->nextIn(*this);
 
   154         _adaptor->nextIn(*this);
 
   162 	return *this; 
   155         return *this;
 
   163       }
 
   156       }
 
   164 
   157 
   165     };
 
   158     };
 
   166 
   159 
   167     /// \brief Base node of the iterator
 
       
   168     ///
 
       
   169     /// Returns the base node (ie. the source in this case) of the iterator
 
       
   170     Node baseNode(const OutArcIt &e) const {
 
   160     Node baseNode(const OutArcIt &e) const {
 
   171       return Parent::source(e);
 
   161       return Parent::source(e);
 
   172     }
 
   162     }
 
   173     /// \brief Running node of the iterator
 
       
   174     ///
 
       
   175     /// Returns the running node (ie. the target in this case) of the
 
       
   176     /// iterator
 
       
   177     Node runningNode(const OutArcIt &e) const {
 
   163     Node runningNode(const OutArcIt &e) const {
 
   178       return Parent::target(e);
 
   164       return Parent::target(e);
 
   179     }
 
   165     }
 
   180 
   166 
   181     /// \brief Base node of the iterator
 
       
   182     ///
 
       
   183     /// Returns the base node (ie. the target in this case) of the iterator
 
       
   184     Node baseNode(const InArcIt &e) const {
 
   167     Node baseNode(const InArcIt &e) const {
 
   185       return Parent::target(e);
 
   168       return Parent::target(e);
 
   186     }
 
   169     }
 
   187     /// \brief Running node of the iterator
 
       
   188     ///
 
       
   189     /// Returns the running node (ie. the source in this case) of the
 
       
   190     /// iterator
 
       
   191     Node runningNode(const InArcIt &e) const {
 
   170     Node runningNode(const InArcIt &e) const {
 
   192       return Parent::source(e);
 
   171       return Parent::source(e);
 
   193     }
 
   172     }
 
   194 
   173 
   195   };
 
   174   };
 
   196 
   175 
   197 
   176 
   198   /// \ingroup digraphbits
 
   177   /// \ingroup digraphbits
 
   199   ///
 
   178   ///
 
   200   /// \brief Extender for the GraphAdaptors
 
   179   /// \brief Extender for the GraphAdaptors
 
   201   template <typename _Graph> 
   180   template <typename _Graph>
 
   202   class GraphAdaptorExtender : public _Graph {
 
   181   class GraphAdaptorExtender : public _Graph {
 
   203   public:
 
   182   public:
 
   204     
   183 
   205     typedef _Graph Parent;
 
   184     typedef _Graph Parent;
 
   206     typedef _Graph Graph;
 
   185     typedef _Graph Graph;
 
   207     typedef GraphAdaptorExtender Adaptor;
 
   186     typedef GraphAdaptorExtender Adaptor;
 
   208 
   187 
   209     typedef typename Parent::Node Node;
 
   188     typedef typename Parent::Node Node;
 
   210     typedef typename Parent::Arc Arc;
 
   189     typedef typename Parent::Arc Arc;
 
   211     typedef typename Parent::Edge Edge;
 
   190     typedef typename Parent::Edge Edge;
 
   212 
   191 
   213     // Graph extension    
   192     // Graph extension
 
   214 
   193 
   215     int maxId(Node) const {
 
   194     int maxId(Node) const {
 
   216       return Parent::maxNodeId();
 
   195       return Parent::maxNodeId();
 
   217     }
 
   196     }
 
   218 
   197 
   236       return Parent::edgeFromId(id);
 
   215       return Parent::edgeFromId(id);
 
   237     }
 
   216     }
 
   238 
   217 
   239     Node oppositeNode(const Node &n, const Edge &e) const {
 
   218     Node oppositeNode(const Node &n, const Edge &e) const {
 
   240       if( n == Parent::u(e))
 
   219       if( n == Parent::u(e))
 
   241 	return Parent::v(e);
 
   220         return Parent::v(e);
 
   242       else if( n == Parent::v(e))
 
   221       else if( n == Parent::v(e))
 
   243 	return Parent::u(e);
 
   222         return Parent::u(e);
 
   244       else
 
   223       else
 
   245 	return INVALID;
 
   224         return INVALID;
 
   246     }
 
   225     }
 
   247 
   226 
   248     Arc oppositeArc(const Arc &a) const {
 
   227     Arc oppositeArc(const Arc &a) const {
 
   249       return Parent::direct(a, !Parent::direction(a));
 
   228       return Parent::direct(a, !Parent::direction(a));
 
   250     }
 
   229     }
 
   253     Arc direct(const Edge &e, const Node &s) const {
 
   232     Arc direct(const Edge &e, const Node &s) const {
 
   254       return Parent::direct(e, Parent::u(e) == s);
 
   233       return Parent::direct(e, Parent::u(e) == s);
 
   255     }
 
   234     }
 
   256 
   235 
   257 
   236 
   258     class NodeIt : public Node { 
   237     class NodeIt : public Node {
 
   259       const Adaptor* _adaptor;
 
   238       const Adaptor* _adaptor;
 
   260     public:
 
   239     public:
 
   261 
   240 
   262       NodeIt() {}
 
   241       NodeIt() {}
 
   263 
   242 
   264       NodeIt(Invalid i) : Node(i) { }
 
   243       NodeIt(Invalid i) : Node(i) { }
 
   265 
   244 
   266       explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
   245       explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
   267 	_adaptor->first(static_cast<Node&>(*this));
 
   246         _adaptor->first(static_cast<Node&>(*this));
 
   268       }
 
   247       }
 
   269 
   248 
   270       NodeIt(const Adaptor& adaptor, const Node& node) 
   249       NodeIt(const Adaptor& adaptor, const Node& node)
 
   271 	: Node(node), _adaptor(&adaptor) {}
 
   250         : Node(node), _adaptor(&adaptor) {}
 
   272 
   251 
   273       NodeIt& operator++() { 
   252       NodeIt& operator++() {
 
   274 	_adaptor->next(*this);
 
   253         _adaptor->next(*this);
 
   275 	return *this; 
   254         return *this;
 
   276       }
 
   255       }
 
   277 
   256 
   278     };
 
   257     };
 
   279 
   258 
   280 
   259 
   281     class ArcIt : public Arc { 
   260     class ArcIt : public Arc {
 
   282       const Adaptor* _adaptor;
 
   261       const Adaptor* _adaptor;
 
   283     public:
 
   262     public:
 
   284 
   263 
   285       ArcIt() { }
 
   264       ArcIt() { }
 
   286 
   265 
   287       ArcIt(Invalid i) : Arc(i) { }
 
   266       ArcIt(Invalid i) : Arc(i) { }
 
   288 
   267 
   289       explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
   268       explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
   290 	_adaptor->first(static_cast<Arc&>(*this));
 
   269         _adaptor->first(static_cast<Arc&>(*this));
 
   291       }
 
   270       }
 
   292 
   271 
   293       ArcIt(const Adaptor& adaptor, const Arc& e) : 
   272       ArcIt(const Adaptor& adaptor, const Arc& e) :
 
   294 	Arc(e), _adaptor(&adaptor) { }
 
   273         Arc(e), _adaptor(&adaptor) { }
 
   295 
   274 
   296       ArcIt& operator++() { 
   275       ArcIt& operator++() {
 
   297 	_adaptor->next(*this);
 
   276         _adaptor->next(*this);
 
   298 	return *this; 
   277         return *this;
 
   299       }
 
   278       }
 
   300 
   279 
   301     };
 
   280     };
 
   302 
   281 
   303 
   282 
   304     class OutArcIt : public Arc { 
   283     class OutArcIt : public Arc {
 
   305       const Adaptor* _adaptor;
 
   284       const Adaptor* _adaptor;
 
   306     public:
 
   285     public:
 
   307 
   286 
   308       OutArcIt() { }
 
   287       OutArcIt() { }
 
   309 
   288 
   310       OutArcIt(Invalid i) : Arc(i) { }
 
   289       OutArcIt(Invalid i) : Arc(i) { }
 
   311 
   290 
   312       OutArcIt(const Adaptor& adaptor, const Node& node) 
   291       OutArcIt(const Adaptor& adaptor, const Node& node)
 
   313 	: _adaptor(&adaptor) {
 
   292         : _adaptor(&adaptor) {
 
   314 	_adaptor->firstOut(*this, node);
 
   293         _adaptor->firstOut(*this, node);
 
   315       }
 
   294       }
 
   316 
   295 
   317       OutArcIt(const Adaptor& adaptor, const Arc& arc) 
   296       OutArcIt(const Adaptor& adaptor, const Arc& arc)
 
   318 	: Arc(arc), _adaptor(&adaptor) {}
 
   297         : Arc(arc), _adaptor(&adaptor) {}
 
   319 
   298 
   320       OutArcIt& operator++() { 
   299       OutArcIt& operator++() {
 
   321 	_adaptor->nextOut(*this);
 
   300         _adaptor->nextOut(*this);
 
   322 	return *this; 
   301         return *this;
 
   323       }
 
   302       }
 
   324 
   303 
   325     };
 
   304     };
 
   326 
   305 
   327 
   306 
   328     class InArcIt : public Arc { 
   307     class InArcIt : public Arc {
 
   329       const Adaptor* _adaptor;
 
   308       const Adaptor* _adaptor;
 
   330     public:
 
   309     public:
 
   331 
   310 
   332       InArcIt() { }
 
   311       InArcIt() { }
 
   333 
   312 
   334       InArcIt(Invalid i) : Arc(i) { }
 
   313       InArcIt(Invalid i) : Arc(i) { }
 
   335 
   314 
   336       InArcIt(const Adaptor& adaptor, const Node& node) 
   315       InArcIt(const Adaptor& adaptor, const Node& node)
 
   337 	: _adaptor(&adaptor) {
 
   316         : _adaptor(&adaptor) {
 
   338 	_adaptor->firstIn(*this, node);
 
   317         _adaptor->firstIn(*this, node);
 
   339       }
 
   318       }
 
   340 
   319 
   341       InArcIt(const Adaptor& adaptor, const Arc& arc) : 
   320       InArcIt(const Adaptor& adaptor, const Arc& arc) :
 
   342 	Arc(arc), _adaptor(&adaptor) {}
 
   321         Arc(arc), _adaptor(&adaptor) {}
 
   343 
   322 
   344       InArcIt& operator++() { 
   323       InArcIt& operator++() {
 
   345 	_adaptor->nextIn(*this);
 
   324         _adaptor->nextIn(*this);
 
   346 	return *this; 
   325         return *this;
 
   347       }
 
   326       }
 
   348 
   327 
   349     };
 
   328     };
 
   350 
   329 
   351     class EdgeIt : public Parent::Edge { 
   330     class EdgeIt : public Parent::Edge {
 
   352       const Adaptor* _adaptor;
 
   331       const Adaptor* _adaptor;
 
   353     public:
 
   332     public:
 
   354 
   333 
   355       EdgeIt() { }
 
   334       EdgeIt() { }
 
   356 
   335 
   357       EdgeIt(Invalid i) : Edge(i) { }
 
   336       EdgeIt(Invalid i) : Edge(i) { }
 
   358 
   337 
   359       explicit EdgeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
   338       explicit EdgeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 
   360 	_adaptor->first(static_cast<Edge&>(*this));
 
   339         _adaptor->first(static_cast<Edge&>(*this));
 
   361       }
 
   340       }
 
   362 
   341 
   363       EdgeIt(const Adaptor& adaptor, const Edge& e) : 
   342       EdgeIt(const Adaptor& adaptor, const Edge& e) :
 
   364 	Edge(e), _adaptor(&adaptor) { }
 
   343         Edge(e), _adaptor(&adaptor) { }
 
   365 
   344 
   366       EdgeIt& operator++() { 
   345       EdgeIt& operator++() {
 
   367 	_adaptor->next(*this);
 
   346         _adaptor->next(*this);
 
   368 	return *this; 
   347         return *this;
 
   369       }
 
   348       }
 
   370 
   349 
   371     };
 
   350     };
 
   372 
   351 
   373     class IncEdgeIt : public Edge { 
   352     class IncEdgeIt : public Edge {
 
   374       friend class GraphAdaptorExtender;
 
   353       friend class GraphAdaptorExtender;
 
   375       const Adaptor* _adaptor;
 
   354       const Adaptor* _adaptor;
 
   376       bool direction;
 
   355       bool direction;
 
   377     public:
 
   356     public:
 
   378 
   357 
   379       IncEdgeIt() { }
 
   358       IncEdgeIt() { }
 
   380 
   359 
   381       IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
 
   360       IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
 
   382 
   361 
   383       IncEdgeIt(const Adaptor& adaptor, const Node &n) : _adaptor(&adaptor) {
 
   362       IncEdgeIt(const Adaptor& adaptor, const Node &n) : _adaptor(&adaptor) {
 
   384 	_adaptor->firstInc(static_cast<Edge&>(*this), direction, n);
 
   363         _adaptor->firstInc(static_cast<Edge&>(*this), direction, n);
 
   385       }
 
   364       }
 
   386 
   365 
   387       IncEdgeIt(const Adaptor& adaptor, const Edge &e, const Node &n)
 
   366       IncEdgeIt(const Adaptor& adaptor, const Edge &e, const Node &n)
 
   388 	: _adaptor(&adaptor), Edge(e) {
 
   367         : _adaptor(&adaptor), Edge(e) {
 
   389 	direction = (_adaptor->u(e) == n);
 
   368         direction = (_adaptor->u(e) == n);
 
   390       }
 
   369       }
 
   391 
   370 
   392       IncEdgeIt& operator++() {
 
   371       IncEdgeIt& operator++() {
 
   393 	_adaptor->nextInc(*this, direction);
 
   372         _adaptor->nextInc(*this, direction);
 
   394 	return *this; 
   373         return *this;
 
   395       }
 
   374       }
 
   396     };
 
   375     };
 
   397 
   376 
   398     /// \brief Base node of the iterator
 
       
   399     ///
 
       
   400     /// Returns the base node (ie. the source in this case) of the iterator
 
       
   401     Node baseNode(const OutArcIt &a) const {
 
   377     Node baseNode(const OutArcIt &a) const {
 
   402       return Parent::source(a);
 
   378       return Parent::source(a);
 
   403     }
 
   379     }
 
   404     /// \brief Running node of the iterator
 
       
   405     ///
 
       
   406     /// Returns the running node (ie. the target in this case) of the
 
       
   407     /// iterator
 
       
   408     Node runningNode(const OutArcIt &a) const {
 
   380     Node runningNode(const OutArcIt &a) const {
 
   409       return Parent::target(a);
 
   381       return Parent::target(a);
 
   410     }
 
   382     }
 
   411 
   383 
   412     /// \brief Base node of the iterator
 
       
   413     ///
 
       
   414     /// Returns the base node (ie. the target in this case) of the iterator
 
       
   415     Node baseNode(const InArcIt &a) const {
 
   384     Node baseNode(const InArcIt &a) const {
 
   416       return Parent::target(a);
 
   385       return Parent::target(a);
 
   417     }
 
   386     }
 
   418     /// \brief Running node of the iterator
 
       
   419     ///
 
       
   420     /// Returns the running node (ie. the source in this case) of the
 
       
   421     /// iterator
 
       
   422     Node runningNode(const InArcIt &a) const {
 
   387     Node runningNode(const InArcIt &a) const {
 
   423       return Parent::source(a);
 
   388       return Parent::source(a);
 
   424     }
 
   389     }
 
   425 
   390 
   426     /// Base node of the iterator
 
       
   427     ///
 
       
   428     /// Returns the base node of the iterator
 
       
   429     Node baseNode(const IncEdgeIt &e) const {
 
   391     Node baseNode(const IncEdgeIt &e) const {
 
   430       return e.direction ? Parent::u(e) : Parent::v(e);
 
   392       return e.direction ? Parent::u(e) : Parent::v(e);
 
   431     }
 
   393     }
 
   432     /// Running node of the iterator
 
       
   433     ///
 
       
   434     /// Returns the running node of the iterator
 
       
   435     Node runningNode(const IncEdgeIt &e) const {
 
   394     Node runningNode(const IncEdgeIt &e) const {
 
   436       return e.direction ? Parent::v(e) : Parent::u(e);
 
   395       return e.direction ? Parent::v(e) : Parent::u(e);
 
   437     }
 
   396     }
 
   438 
   397 
   439   };
 
   398   };
lemon-main