lemon: comparison lemon/bits/edge_set

equal deleted inserted replaced

-:003580a06207
+:dbd790b96225
 // \ingroup digraphbits
 //
 // \brief Extender for the ArcSets
 template <typename Base>
 class ArcSetExtender : public Base {
+typedef Base Parent;
 public:
-typedef Base Parent;
 typedef ArcSetExtender Digraph;
 // Base extensions
 typedef typename Parent::Node Node;
 // Mappable extension
 template <typename _Value>
 class ArcMap
 : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
-public:
-typedef ArcSetExtender Digraph;
 typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
+public:
 explicit ArcMap(const Digraph& _g)
 	: Parent(_g) {}
 ArcMap(const Digraph& _g, const _Value& _v)
 	: Parent(_g, _v) {}
 // \ingroup digraphbits
 //
 // \brief Extender for the EdgeSets
 template <typename Base>
 class EdgeSetExtender : public Base {
+typedef Base Parent;
 public:
-typedef Base Parent;
+typedef EdgeSetExtender Graph;
-typedef EdgeSetExtender Digraph;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 typedef typename Parent::Edge Edge;
 int maxId(Node) const {
 return Parent::maxNodeId();
 }
 return edge_notifier;
 }
 class NodeIt : public Node {
-const Digraph* digraph;
+const Graph* graph;
 public:
 NodeIt() {}
 NodeIt(Invalid i) : Node(i) { }
-explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
+explicit NodeIt(const Graph& _graph) : graph(&_graph) {
 	_graph.first(static_cast<Node&>(*this));
 }
-NodeIt(const Digraph& _graph, const Node& node)
+NodeIt(const Graph& _graph, const Node& node)
-	: Node(node), digraph(&_graph) {}
+	: Node(node), graph(&_graph) {}
 NodeIt& operator++() {
-	digraph->next(*this);
+	graph->next(*this);
 	return *this;
 }
 };
 class ArcIt : public Arc {
-const Digraph* digraph;
+const Graph* graph;
 public:
 ArcIt() { }
 ArcIt(Invalid i) : Arc(i) { }
-explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
+explicit ArcIt(const Graph& _graph) : graph(&_graph) {
 	_graph.first(static_cast<Arc&>(*this));
 }
-ArcIt(const Digraph& _graph, const Arc& e) :
+ArcIt(const Graph& _graph, const Arc& e) :
-	Arc(e), digraph(&_graph) { }
+	Arc(e), graph(&_graph) { }
 ArcIt& operator++() {
-	digraph->next(*this);
+	graph->next(*this);
 	return *this;
 }
 };
 class OutArcIt : public Arc {
-const Digraph* digraph;
+const Graph* graph;
 public:
 OutArcIt() { }
 OutArcIt(Invalid i) : Arc(i) { }
-OutArcIt(const Digraph& _graph, const Node& node)
+OutArcIt(const Graph& _graph, const Node& node)
-	: digraph(&_graph) {
+	: graph(&_graph) {
 	_graph.firstOut(*this, node);
 }
-OutArcIt(const Digraph& _graph, const Arc& arc)
+OutArcIt(const Graph& _graph, const Arc& arc)
-	: Arc(arc), digraph(&_graph) {}
+	: Arc(arc), graph(&_graph) {}
 OutArcIt& operator++() {
-	digraph->nextOut(*this);
+	graph->nextOut(*this);
 	return *this;
 }
 };
 class InArcIt : public Arc {
-const Digraph* digraph;
+const Graph* graph;
 public:
 InArcIt() { }
 InArcIt(Invalid i) : Arc(i) { }
-InArcIt(const Digraph& _graph, const Node& node)
+InArcIt(const Graph& _graph, const Node& node)
-	: digraph(&_graph) {
+	: graph(&_graph) {
 	_graph.firstIn(*this, node);
 }
-InArcIt(const Digraph& _graph, const Arc& arc) :
+InArcIt(const Graph& _graph, const Arc& arc) :
-	Arc(arc), digraph(&_graph) {}
+	Arc(arc), graph(&_graph) {}
 InArcIt& operator++() {
-	digraph->nextIn(*this);
+	graph->nextIn(*this);
 	return *this;
 }
 };
 class EdgeIt : public Parent::Edge {
-const Digraph* digraph;
+const Graph* graph;
 public:
 EdgeIt() { }
 EdgeIt(Invalid i) : Edge(i) { }
-explicit EdgeIt(const Digraph& _graph) : digraph(&_graph) {
+explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
 	_graph.first(static_cast<Edge&>(*this));
 }
-EdgeIt(const Digraph& _graph, const Edge& e) :
+EdgeIt(const Graph& _graph, const Edge& e) :
-	Edge(e), digraph(&_graph) { }
+	Edge(e), graph(&_graph) { }
 EdgeIt& operator++() {
-	digraph->next(*this);
+	graph->next(*this);
 	return *this;
 }
 };
 class IncEdgeIt : public Parent::Edge {
 friend class EdgeSetExtender;
-const Digraph* digraph;
+const Graph* graph;
 bool direction;
 public:
 IncEdgeIt() { }
 IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
-IncEdgeIt(const Digraph& _graph, const Node &n) : digraph(&_graph) {
+IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
 	_graph.firstInc(*this, direction, n);
 }
-IncEdgeIt(const Digraph& _graph, const Edge &ue, const Node &n)
+IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
-	: digraph(&_graph), Edge(ue) {
+	: graph(&_graph), Edge(ue) {
 	direction = (_graph.source(ue) == n);
 }
 IncEdgeIt& operator++() {
-	digraph->nextInc(*this, direction);
+	graph->nextInc(*this, direction);
 	return *this;
 }
 };
 // \brief Base node of the iterator
 }
 template <typename _Value>
 class ArcMap
-: public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
+: public MapExtender<DefaultMap<Graph, Arc, _Value> > {
-public:
+typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
-typedef EdgeSetExtender Digraph;
-typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
+public:
+ArcMap(const Graph& _g)
-ArcMap(const Digraph& _g)
 	: Parent(_g) {}
-ArcMap(const Digraph& _g, const _Value& _v)
+ArcMap(const Graph& _g, const _Value& _v)
 	: Parent(_g, _v) {}
 ArcMap& operator=(const ArcMap& cmap) {
 	return operator=<ArcMap>(cmap);
 }
 };
 template <typename _Value>
 class EdgeMap
-: public MapExtender<DefaultMap<Digraph, Edge, _Value> > {
+: public MapExtender<DefaultMap<Graph, Edge, _Value> > {
-public:
+typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
-typedef EdgeSetExtender Digraph;
-typedef MapExtender<DefaultMap<Digraph, Edge, _Value> > Parent;
+public:
+EdgeMap(const Graph& _g)
-EdgeMap(const Digraph& _g)
 	: Parent(_g) {}
-EdgeMap(const Digraph& _g, const _Value& _v)
+EdgeMap(const Graph& _g, const _Value& _v)
 	: Parent(_g, _v) {}
 EdgeMap& operator=(const EdgeMap& cmap) {
 	return operator=<EdgeMap>(cmap);
 }

changeset 664	4137ef9aacc6
parent 606	c5fd2d996909
child 732	a27356ceb5bd
child 965	ece1f8a3052d