Removed references to the gui.
3 * This file is a part of LEMON, a generic C++ optimization library
5 * Copyright (C) 2003-2006
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
19 /// \ingroup graph_concepts
21 /// \brief Undirected bipartite graphs and components of.
24 #ifndef LEMON_CONCEPT_BPUGRAPH_H
25 #define LEMON_CONCEPT_BPUGRAPH_H
27 #include <lemon/concept/graph_component.h>
29 #include <lemon/concept/graph.h>
30 #include <lemon/concept/ugraph.h>
32 #include <lemon/bits/utility.h>
37 /// \addtogroup graph_concepts
41 /// \brief Class describing the concept of Bipartite Undirected Graphs.
43 /// This class describes the common interface of all
44 /// Undirected Bipartite Graphs.
46 /// As all concept describing classes it provides only interface
47 /// without any sensible implementation. So any algorithm for
48 /// bipartite undirected graph should compile with this class, but it
49 /// will not run properly, of course.
51 /// In LEMON bipartite undirected graphs also fulfill the concept of
52 /// the undirected graphs (\ref lemon::concept::UGraph "UGraph Concept").
54 /// You can assume that all undirected bipartite graph can be handled
55 /// as an undirected graph and consequently as a static graph.
57 /// The bipartite graph stores two types of nodes which are named
58 /// ANode and BNode. The graph type contains two types ANode and BNode
59 /// which are inherited from Node type. Moreover they have
60 /// constructor which converts Node to either ANode or BNode when it is
61 /// possible. Therefor everywhere the Node type can be used instead of
62 /// ANode and BNode. So the usage of the ANode and BNode is suggested.
64 /// The iteration on the partition can be done with the ANodeIt and
65 /// BNodeIt classes. The node map can be used to map values to the nodes
66 /// and similarly we can use to map values for just the ANodes and
67 /// BNodes the ANodeMap and BNodeMap template classes.
71 /// \todo undocumented
73 typedef True UndirectedTag;
75 /// \brief The base type of node iterators,
76 /// or in other words, the trivial node iterator.
78 /// This is the base type of each node iterator,
79 /// thus each kind of node iterator converts to this.
80 /// More precisely each kind of node iterator should be inherited
81 /// from the trivial node iterator. The Node class represents
82 /// both of two types of nodes.
85 /// Default constructor
87 /// @warning The default constructor sets the iterator
88 /// to an undefined value.
96 /// Invalid constructor \& conversion.
98 /// This constructor initializes the iterator to be invalid.
99 /// \sa Invalid for more details.
101 /// Equality operator
103 /// Two iterators are equal if and only if they point to the
104 /// same object or both are invalid.
105 bool operator==(Node) const { return true; }
107 /// Inequality operator
109 /// \sa operator==(Node n)
111 bool operator!=(Node) const { return true; }
113 /// Artificial ordering operator.
115 /// To allow the use of graph descriptors as key type in std::map or
116 /// similar associative container we require this.
118 /// \note This operator only have to define some strict ordering of
119 /// the items; this order has nothing to do with the iteration
120 /// ordering of the items.
121 bool operator<(Node) const { return false; }
125 /// \brief The base type of anode iterators,
126 /// or in other words, the trivial anode iterator.
128 /// This is the base type of each anode iterator,
129 /// thus each kind of anode iterator converts to this.
130 /// More precisely each kind of node iterator should be inherited
131 /// from the trivial anode iterator. The ANode class should be used
132 /// only in special cases. Usually the Node type should be used insted
136 /// Default constructor
138 /// @warning The default constructor sets the iterator
139 /// to an undefined value.
141 /// Copy constructor.
143 /// Copy constructor.
145 ANode(const ANode&) { }
147 /// Construct the same node as ANode.
149 /// Construct the same node as ANode. It may throws assertion
150 /// when the given node is from the BNode set.
151 ANode(const Node&) { }
153 /// Invalid constructor \& conversion.
155 /// This constructor initializes the iterator to be invalid.
156 /// \sa Invalid for more details.
158 /// Equality operator
160 /// Two iterators are equal if and only if they point to the
161 /// same object or both are invalid.
162 bool operator==(ANode) const { return true; }
164 /// Inequality operator
166 /// \sa operator==(ANode n)
168 bool operator!=(ANode) const { return true; }
170 /// Artificial ordering operator.
172 /// To allow the use of graph descriptors as key type in std::map or
173 /// similar associative container we require this.
175 /// \note This operator only have to define some strict ordering of
176 /// the items; this order has nothing to do with the iteration
177 /// ordering of the items.
178 bool operator<(ANode) const { return false; }
182 /// \brief The base type of bnode iterators,
183 /// or in other words, the trivial bnode iterator.
185 /// This is the base type of each anode iterator,
186 /// thus each kind of anode iterator converts to this.
187 /// More precisely each kind of node iterator should be inherited
188 /// from the trivial anode iterator. The BNode class should be used
189 /// only in special cases. Usually the Node type should be used insted
193 /// Default constructor
195 /// @warning The default constructor sets the iterator
196 /// to an undefined value.
198 /// Copy constructor.
200 /// Copy constructor.
202 BNode(const BNode&) { }
204 /// Construct the same node as BNode.
206 /// Construct the same node as BNode. It may throws assertion
207 /// when the given node is from the ANode set.
208 BNode(const Node&) { }
210 /// Invalid constructor \& conversion.
212 /// This constructor initializes the iterator to be invalid.
213 /// \sa Invalid for more details.
215 /// Equality operator
217 /// Two iterators are equal if and only if they point to the
218 /// same object or both are invalid.
219 bool operator==(BNode) const { return true; }
221 /// Inequality operator
223 /// \sa operator==(BNode n)
225 bool operator!=(BNode) const { return true; }
227 /// Artificial ordering operator.
229 /// To allow the use of graph descriptors as key type in std::map or
230 /// similar associative container we require this.
232 /// \note This operator only have to define some strict ordering of
233 /// the items; this order has nothing to do with the iteration
234 /// ordering of the items.
235 bool operator<(BNode) const { return false; }
239 /// This iterator goes through each node.
241 /// This iterator goes through each node.
242 /// Its usage is quite simple, for example you can count the number
243 /// of nodes in graph \c g of type \c Graph like this:
246 /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
248 class NodeIt : public Node {
250 /// Default constructor
252 /// @warning The default constructor sets the iterator
253 /// to an undefined value.
255 /// Copy constructor.
257 /// Copy constructor.
259 NodeIt(const NodeIt& n) : Node(n) { }
260 /// Invalid constructor \& conversion.
262 /// Initialize the iterator to be invalid.
263 /// \sa Invalid for more details.
265 /// Sets the iterator to the first node.
267 /// Sets the iterator to the first node of \c g.
269 NodeIt(const BpUGraph&) { }
270 /// Node -> NodeIt conversion.
272 /// Sets the iterator to the node of \c the graph pointed by
273 /// the trivial iterator.
274 /// This feature necessitates that each time we
275 /// iterate the edge-set, the iteration order is the same.
276 NodeIt(const BpUGraph&, const Node&) { }
279 /// Assign the iterator to the next node.
281 NodeIt& operator++() { return *this; }
284 /// This iterator goes through each ANode.
286 /// This iterator goes through each ANode.
287 /// Its usage is quite simple, for example you can count the number
288 /// of nodes in graph \c g of type \c Graph like this:
291 /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count;
293 class ANodeIt : public ANode {
295 /// Default constructor
297 /// @warning The default constructor sets the iterator
298 /// to an undefined value.
300 /// Copy constructor.
302 /// Copy constructor.
304 ANodeIt(const ANodeIt& n) : Node(n) { }
305 /// Invalid constructor \& conversion.
307 /// Initialize the iterator to be invalid.
308 /// \sa Invalid for more details.
310 /// Sets the iterator to the first node.
312 /// Sets the iterator to the first node of \c g.
314 ANodeIt(const BpUGraph&) { }
315 /// Node -> ANodeIt conversion.
317 /// Sets the iterator to the node of \c the graph pointed by
318 /// the trivial iterator.
319 /// This feature necessitates that each time we
320 /// iterate the edge-set, the iteration order is the same.
321 ANodeIt(const BpUGraph&, const Node&) { }
324 /// Assign the iterator to the next node.
326 ANodeIt& operator++() { return *this; }
329 /// This iterator goes through each BNode.
331 /// This iterator goes through each BNode.
332 /// Its usage is quite simple, for example you can count the number
333 /// of nodes in graph \c g of type \c Graph like this:
336 /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count;
338 class BNodeIt : public BNode {
340 /// Default constructor
342 /// @warning The default constructor sets the iterator
343 /// to an undefined value.
345 /// Copy constructor.
347 /// Copy constructor.
349 BNodeIt(const BNodeIt& n) : Node(n) { }
350 /// Invalid constructor \& conversion.
352 /// Initialize the iterator to be invalid.
353 /// \sa Invalid for more details.
355 /// Sets the iterator to the first node.
357 /// Sets the iterator to the first node of \c g.
359 BNodeIt(const BpUGraph&) { }
360 /// Node -> BNodeIt conversion.
362 /// Sets the iterator to the node of \c the graph pointed by
363 /// the trivial iterator.
364 /// This feature necessitates that each time we
365 /// iterate the edge-set, the iteration order is the same.
366 BNodeIt(const BpUGraph&, const Node&) { }
369 /// Assign the iterator to the next node.
371 BNodeIt& operator++() { return *this; }
375 /// The base type of the undirected edge iterators.
377 /// The base type of the undirected edge iterators.
381 /// Default constructor
383 /// @warning The default constructor sets the iterator
384 /// to an undefined value.
386 /// Copy constructor.
388 /// Copy constructor.
390 UEdge(const UEdge&) { }
391 /// Initialize the iterator to be invalid.
393 /// Initialize the iterator to be invalid.
396 /// Equality operator
398 /// Two iterators are equal if and only if they point to the
399 /// same object or both are invalid.
400 bool operator==(UEdge) const { return true; }
401 /// Inequality operator
403 /// \sa operator==(UEdge n)
405 bool operator!=(UEdge) const { return true; }
407 /// Artificial ordering operator.
409 /// To allow the use of graph descriptors as key type in std::map or
410 /// similar associative container we require this.
412 /// \note This operator only have to define some strict ordering of
413 /// the items; this order has nothing to do with the iteration
414 /// ordering of the items.
415 bool operator<(UEdge) const { return false; }
418 /// This iterator goes through each undirected edge.
420 /// This iterator goes through each undirected edge of a graph.
421 /// Its usage is quite simple, for example you can count the number
422 /// of undirected edges in a graph \c g of type \c Graph as follows:
425 /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
427 class UEdgeIt : public UEdge {
429 /// Default constructor
431 /// @warning The default constructor sets the iterator
432 /// to an undefined value.
434 /// Copy constructor.
436 /// Copy constructor.
438 UEdgeIt(const UEdgeIt& e) : UEdge(e) { }
439 /// Initialize the iterator to be invalid.
441 /// Initialize the iterator to be invalid.
444 /// This constructor sets the iterator to the first undirected edge.
446 /// This constructor sets the iterator to the first undirected edge.
447 UEdgeIt(const BpUGraph&) { }
448 /// UEdge -> UEdgeIt conversion
450 /// Sets the iterator to the value of the trivial iterator.
451 /// This feature necessitates that each time we
452 /// iterate the undirected edge-set, the iteration order is the
454 UEdgeIt(const BpUGraph&, const UEdge&) { }
455 /// Next undirected edge
457 /// Assign the iterator to the next undirected edge.
458 UEdgeIt& operator++() { return *this; }
461 /// \brief This iterator goes trough the incident undirected
464 /// This iterator goes trough the incident undirected edges
465 /// of a certain node
467 /// Its usage is quite simple, for example you can compute the
468 /// degree (i.e. count the number
469 /// of incident edges of a node \c n
470 /// in graph \c g of type \c Graph as follows.
473 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
475 class IncEdgeIt : public UEdge {
477 /// Default constructor
479 /// @warning The default constructor sets the iterator
480 /// to an undefined value.
482 /// Copy constructor.
484 /// Copy constructor.
486 IncEdgeIt(const IncEdgeIt& e) : UEdge(e) { }
487 /// Initialize the iterator to be invalid.
489 /// Initialize the iterator to be invalid.
491 IncEdgeIt(Invalid) { }
492 /// This constructor sets the iterator to first incident edge.
494 /// This constructor set the iterator to the first incident edge of
496 IncEdgeIt(const BpUGraph&, const Node&) { }
497 /// UEdge -> IncEdgeIt conversion
499 /// Sets the iterator to the value of the trivial iterator \c e.
500 /// This feature necessitates that each time we
501 /// iterate the edge-set, the iteration order is the same.
502 IncEdgeIt(const BpUGraph&, const UEdge&) { }
503 /// Next incident edge
505 /// Assign the iterator to the next incident edge
506 /// of the corresponding node.
507 IncEdgeIt& operator++() { return *this; }
510 /// The directed edge type.
512 /// The directed edge type. It can be converted to the
514 class Edge : public UEdge {
516 /// Default constructor
518 /// @warning The default constructor sets the iterator
519 /// to an undefined value.
521 /// Copy constructor.
523 /// Copy constructor.
525 Edge(const Edge& e) : UEdge(e) { }
526 /// Initialize the iterator to be invalid.
528 /// Initialize the iterator to be invalid.
531 /// Equality operator
533 /// Two iterators are equal if and only if they point to the
534 /// same object or both are invalid.
535 bool operator==(Edge) const { return true; }
536 /// Inequality operator
538 /// \sa operator==(Edge n)
540 bool operator!=(Edge) const { return true; }
542 /// Artificial ordering operator.
544 /// To allow the use of graph descriptors as key type in std::map or
545 /// similar associative container we require this.
547 /// \note This operator only have to define some strict ordering of
548 /// the items; this order has nothing to do with the iteration
549 /// ordering of the items.
550 bool operator<(Edge) const { return false; }
553 /// This iterator goes through each directed edge.
555 /// This iterator goes through each edge of a graph.
556 /// Its usage is quite simple, for example you can count the number
557 /// of edges in a graph \c g of type \c Graph as follows:
560 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
562 class EdgeIt : public Edge {
564 /// Default constructor
566 /// @warning The default constructor sets the iterator
567 /// to an undefined value.
569 /// Copy constructor.
571 /// Copy constructor.
573 EdgeIt(const EdgeIt& e) : Edge(e) { }
574 /// Initialize the iterator to be invalid.
576 /// Initialize the iterator to be invalid.
579 /// This constructor sets the iterator to the first edge.
581 /// This constructor sets the iterator to the first edge of \c g.
582 ///@param g the graph
583 EdgeIt(const BpUGraph &g) { ignore_unused_variable_warning(g); }
584 /// Edge -> EdgeIt conversion
586 /// Sets the iterator to the value of the trivial iterator \c e.
587 /// This feature necessitates that each time we
588 /// iterate the edge-set, the iteration order is the same.
589 EdgeIt(const BpUGraph&, const Edge&) { }
592 /// Assign the iterator to the next edge.
593 EdgeIt& operator++() { return *this; }
596 /// This iterator goes trough the outgoing directed edges of a node.
598 /// This iterator goes trough the \e outgoing edges of a certain node
600 /// Its usage is quite simple, for example you can count the number
601 /// of outgoing edges of a node \c n
602 /// in graph \c g of type \c Graph as follows.
605 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
608 class OutEdgeIt : public Edge {
610 /// Default constructor
612 /// @warning The default constructor sets the iterator
613 /// to an undefined value.
615 /// Copy constructor.
617 /// Copy constructor.
619 OutEdgeIt(const OutEdgeIt& e) : Edge(e) { }
620 /// Initialize the iterator to be invalid.
622 /// Initialize the iterator to be invalid.
624 OutEdgeIt(Invalid) { }
625 /// This constructor sets the iterator to the first outgoing edge.
627 /// This constructor sets the iterator to the first outgoing edge of
630 ///@param g the graph
631 OutEdgeIt(const BpUGraph& n, const Node& g) {
632 ignore_unused_variable_warning(n);
633 ignore_unused_variable_warning(g);
635 /// Edge -> OutEdgeIt conversion
637 /// Sets the iterator to the value of the trivial iterator.
638 /// This feature necessitates that each time we
639 /// iterate the edge-set, the iteration order is the same.
640 OutEdgeIt(const BpUGraph&, const Edge&) { }
641 ///Next outgoing edge
643 /// Assign the iterator to the next
644 /// outgoing edge of the corresponding node.
645 OutEdgeIt& operator++() { return *this; }
648 /// This iterator goes trough the incoming directed edges of a node.
650 /// This iterator goes trough the \e incoming edges of a certain node
652 /// Its usage is quite simple, for example you can count the number
653 /// of outgoing edges of a node \c n
654 /// in graph \c g of type \c Graph as follows.
657 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
660 class InEdgeIt : public Edge {
662 /// Default constructor
664 /// @warning The default constructor sets the iterator
665 /// to an undefined value.
667 /// Copy constructor.
669 /// Copy constructor.
671 InEdgeIt(const InEdgeIt& e) : Edge(e) { }
672 /// Initialize the iterator to be invalid.
674 /// Initialize the iterator to be invalid.
676 InEdgeIt(Invalid) { }
677 /// This constructor sets the iterator to first incoming edge.
679 /// This constructor set the iterator to the first incoming edge of
682 ///@param g the graph
683 InEdgeIt(const BpUGraph& g, const Node& n) {
684 ignore_unused_variable_warning(n);
685 ignore_unused_variable_warning(g);
687 /// Edge -> InEdgeIt conversion
689 /// Sets the iterator to the value of the trivial iterator \c e.
690 /// This feature necessitates that each time we
691 /// iterate the edge-set, the iteration order is the same.
692 InEdgeIt(const BpUGraph&, const Edge&) { }
693 /// Next incoming edge
695 /// Assign the iterator to the next inedge of the corresponding node.
697 InEdgeIt& operator++() { return *this; }
700 /// \brief Read write map of the nodes to type \c T.
702 /// ReadWrite map of the nodes to type \c T.
704 /// \warning Making maps that can handle bool type (NodeMap<bool>)
705 /// needs some extra attention!
706 /// \todo Wrong documentation
708 class NodeMap : public ReadWriteMap< Node, T >
713 NodeMap(const BpUGraph&) { }
715 NodeMap(const BpUGraph&, T) { }
718 NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
719 ///Assignment operator
720 NodeMap& operator=(const NodeMap&) { return *this; }
721 // \todo fix this concept
724 /// \brief Read write map of the ANodes to type \c T.
726 /// ReadWrite map of the ANodes to type \c T.
728 /// \warning Making maps that can handle bool type (NodeMap<bool>)
729 /// needs some extra attention!
730 /// \todo Wrong documentation
732 class ANodeMap : public ReadWriteMap< Node, T >
737 ANodeMap(const BpUGraph&) { }
739 ANodeMap(const BpUGraph&, T) { }
742 ANodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
743 ///Assignment operator
744 ANodeMap& operator=(const NodeMap&) { return *this; }
745 // \todo fix this concept
748 /// \brief Read write map of the BNodes to type \c T.
750 /// ReadWrite map of the BNodes to type \c T.
752 /// \warning Making maps that can handle bool type (NodeMap<bool>)
753 /// needs some extra attention!
754 /// \todo Wrong documentation
756 class BNodeMap : public ReadWriteMap< Node, T >
761 BNodeMap(const BpUGraph&) { }
763 BNodeMap(const BpUGraph&, T) { }
766 BNodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
767 ///Assignment operator
768 BNodeMap& operator=(const NodeMap&) { return *this; }
769 // \todo fix this concept
772 /// \brief Read write map of the directed edges to type \c T.
774 /// Reference map of the directed edges to type \c T.
776 /// \warning Making maps that can handle bool type (EdgeMap<bool>)
777 /// needs some extra attention!
778 /// \todo Wrong documentation
780 class EdgeMap : public ReadWriteMap<Edge,T>
785 EdgeMap(const BpUGraph&) { }
787 EdgeMap(const BpUGraph&, T) { }
789 EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
790 ///Assignment operator
791 EdgeMap& operator=(const EdgeMap&) { return *this; }
792 // \todo fix this concept
795 /// Read write map of the undirected edges to type \c T.
797 /// Reference map of the edges to type \c T.
799 /// \warning Making maps that can handle bool type (UEdgeMap<bool>)
800 /// needs some extra attention!
801 /// \todo Wrong documentation
803 class UEdgeMap : public ReadWriteMap<UEdge,T>
808 UEdgeMap(const BpUGraph&) { }
810 UEdgeMap(const BpUGraph&, T) { }
812 UEdgeMap(const UEdgeMap& em) : ReadWriteMap<UEdge,T>(em) {}
813 ///Assignment operator
814 UEdgeMap &operator=(const UEdgeMap&) { return *this; }
815 // \todo fix this concept
818 /// \brief Direct the given undirected edge.
820 /// Direct the given undirected edge. The returned edge source
821 /// will be the given edge.
822 Edge direct(const UEdge&, const Node&) const {
826 /// \brief Direct the given undirected edge.
828 /// Direct the given undirected edge. The returned edge source
829 /// will be the source of the undirected edge if the given bool
831 Edge direct(const UEdge&, bool) const {
835 /// \brief Returns true when the given node is an ANode.
837 /// Returns true when the given node is an ANode.
838 bool aNode(Node) const { return true;}
840 /// \brief Returns true when the given node is an BNode.
842 /// Returns true when the given node is an BNode.
843 bool bNode(Node) const { return true;}
845 /// \brief Returns the edge's end node which is in the ANode set.
847 /// Returns the edge's end node which is in the ANode set.
848 Node aNode(UEdge) const { return INVALID;}
850 /// \brief Returns the edge's end node which is in the BNode set.
852 /// Returns the edge's end node which is in the BNode set.
853 Node bNode(UEdge) const { return INVALID;}
855 /// \brief Returns true if the edge has default orientation.
857 /// Returns whether the given directed edge is same orientation as
858 /// the corresponding undirected edge.
859 bool direction(Edge) const { return true; }
861 /// \brief Returns the opposite directed edge.
863 /// Returns the opposite directed edge.
864 Edge oppositeEdge(Edge) const { return INVALID; }
866 /// \brief Opposite node on an edge
868 /// \return the opposite of the given Node on the given Edge
869 Node oppositeNode(Node, UEdge) const { return INVALID; }
871 /// \brief First node of the undirected edge.
873 /// \return the first node of the given UEdge.
875 /// Naturally uectected edges don't have direction and thus
876 /// don't have source and target node. But we use these two methods
877 /// to query the two endnodes of the edge. The direction of the edge
878 /// which arises this way is called the inherent direction of the
879 /// undirected edge, and is used to define the "default" direction
880 /// of the directed versions of the edges.
882 Node source(UEdge) const { return INVALID; }
884 /// \brief Second node of the undirected edge.
885 Node target(UEdge) const { return INVALID; }
887 /// \brief Source node of the directed edge.
888 Node source(Edge) const { return INVALID; }
890 /// \brief Target node of the directed edge.
891 Node target(Edge) const { return INVALID; }
893 /// \brief Base node of the iterator
895 /// Returns the base node (the source in this case) of the iterator
896 Node baseNode(OutEdgeIt e) const {
900 /// \brief Running node of the iterator
902 /// Returns the running node (the target in this case) of the
904 Node runningNode(OutEdgeIt e) const {
908 /// \brief Base node of the iterator
910 /// Returns the base node (the target in this case) of the iterator
911 Node baseNode(InEdgeIt e) const {
914 /// \brief Running node of the iterator
916 /// Returns the running node (the source in this case) of the
918 Node runningNode(InEdgeIt e) const {
922 /// \brief Base node of the iterator
924 /// Returns the base node of the iterator
925 Node baseNode(IncEdgeIt) const {
929 /// \brief Running node of the iterator
931 /// Returns the running node of the iterator
932 Node runningNode(IncEdgeIt) const {
936 template <typename Graph>