lemon-1.0: comparison lemon/bits/graph

equal deleted inserted replaced

-:4327a15d97f5
+:1b9fc79dc990
 Arc fromId(int id, Arc) const {
 return Parent::arcFromId(id);
 }
-Node oppositeNode(const Node &n, const Arc &e) const {
+Node oppositeNode(const Node &node, const Arc &arc) const {
-if (n == Parent::source(e))
+if (node == Parent::source(arc))
-	return Parent::target(e);
+	return Parent::target(arc);
-else if(n==Parent::target(e))
+else if(node == Parent::target(arc))
-	return Parent::source(e);
+	return Parent::source(arc);
 else
 	return INVALID;
 }
 // Alterable extension
 ArcNotifier& notifier(Arc) const {
 return arc_notifier;
 }
 class NodeIt : public Node {
-const Digraph* digraph;
+const Digraph* _digraph;
 public:
 NodeIt() {}
 NodeIt(Invalid i) : Node(i) { }
-explicit NodeIt(const Digraph& _digraph) : digraph(&_digraph) {
+explicit NodeIt(const Digraph& digraph) : _digraph(&digraph) {
-	_digraph.first(static_cast<Node&>(*this));
+	_digraph->first(static_cast<Node&>(*this));
 }
-NodeIt(const Digraph& _digraph, const Node& node)
+NodeIt(const Digraph& digraph, const Node& node)
-	: Node(node), digraph(&_digraph) {}
+	: Node(node), _digraph(&digraph) {}
 NodeIt& operator++() {
-	digraph->next(*this);
+	_digraph->next(*this);
 	return *this;
 }
 };
 class ArcIt : public Arc {
-const Digraph* digraph;
+const Digraph* _digraph;
 public:
 ArcIt() { }
 ArcIt(Invalid i) : Arc(i) { }
-explicit ArcIt(const Digraph& _digraph) : digraph(&_digraph) {
+explicit ArcIt(const Digraph& digraph) : _digraph(&digraph) {
-	_digraph.first(static_cast<Arc&>(*this));
+	_digraph->first(static_cast<Arc&>(*this));
 }
-ArcIt(const Digraph& _digraph, const Arc& e) :
+ArcIt(const Digraph& digraph, const Arc& arc) :
-	Arc(e), digraph(&_digraph) { }
+	Arc(arc), _digraph(&digraph) { }
 ArcIt& operator++() {
-	digraph->next(*this);
+	_digraph->next(*this);
 	return *this;
 }
 };
 class OutArcIt : public Arc {
-const Digraph* digraph;
+const Digraph* _digraph;
 public:
 OutArcIt() { }
 OutArcIt(Invalid i) : Arc(i) { }
-OutArcIt(const Digraph& _digraph, const Node& node)
+OutArcIt(const Digraph& digraph, const Node& node)
-	: digraph(&_digraph) {
+	: _digraph(&digraph) {
-	_digraph.firstOut(*this, node);
+	_digraph->firstOut(*this, node);
 }
-OutArcIt(const Digraph& _digraph, const Arc& arc)
+OutArcIt(const Digraph& digraph, const Arc& arc)
-	: Arc(arc), digraph(&_digraph) {}
+	: Arc(arc), _digraph(&digraph) {}
 OutArcIt& operator++() {
-	digraph->nextOut(*this);
+	_digraph->nextOut(*this);
 	return *this;
 }
 };
 class InArcIt : public Arc {
-const Digraph* digraph;
+const Digraph* _digraph;
 public:
 InArcIt() { }
 InArcIt(Invalid i) : Arc(i) { }
-InArcIt(const Digraph& _digraph, const Node& node)
+InArcIt(const Digraph& digraph, const Node& node)
-	: digraph(&_digraph) {
+	: _digraph(&digraph) {
-	_digraph.firstIn(*this, node);
+	_digraph->firstIn(*this, node);
 }
-InArcIt(const Digraph& _digraph, const Arc& arc) :
+InArcIt(const Digraph& digraph, const Arc& arc) :
-	Arc(arc), digraph(&_digraph) {}
+	Arc(arc), _digraph(&digraph) {}
 InArcIt& operator++() {
-	digraph->nextIn(*this);
+	_digraph->nextIn(*this);
 	return *this;
 }
 };
 /// \brief Base node of the iterator
 ///
 /// Returns the base node (i.e. the source in this case) of the iterator
-Node baseNode(const OutArcIt &e) const {
+Node baseNode(const OutArcIt &arc) const {
-return Parent::source(e);
+return Parent::source(arc);
 }
 /// \brief Running node of the iterator
 ///
 /// Returns the running node (i.e. the target in this case) of the
 /// iterator
-Node runningNode(const OutArcIt &e) const {
+Node runningNode(const OutArcIt &arc) const {
-return Parent::target(e);
+return Parent::target(arc);
 }
 /// \brief Base node of the iterator
 ///
 /// Returns the base node (i.e. the target in this case) of the iterator
-Node baseNode(const InArcIt &e) const {
+Node baseNode(const InArcIt &arc) const {
-return Parent::target(e);
+return Parent::target(arc);
 }
 /// \brief Running node of the iterator
 ///
 /// Returns the running node (i.e. the source in this case) of the
 /// iterator
-Node runningNode(const InArcIt &e) const {
+Node runningNode(const InArcIt &arc) const {
-return Parent::source(e);
+return Parent::source(arc);
 }
 template <typename _Value>
 class NodeMap
 arc_notifier.clear();
 node_notifier.clear();
 }
 };
-/// \ingroup graphbits
+/// \ingroup _graphbits
 ///
 /// \brief Extender for the Graphs
 template <typename Base>
 class GraphExtender : public Base {
 public:
 typedef Base Parent;
-typedef GraphExtender Digraph;
+typedef GraphExtender Graph;
 typedef True UndirectedTag;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 	return Parent::source(e);
 else
 	return INVALID;
 }
-Arc oppositeArc(const Arc &e) const {
+Arc oppositeArc(const Arc &arc) const {
-return Parent::direct(e, !Parent::direction(e));
+return Parent::direct(arc, !Parent::direction(arc));
 }
 using Parent::direct;
-Arc direct(const Edge &ue, const Node &s) const {
+Arc direct(const Edge &edge, const Node &node) const {
-return Parent::direct(ue, Parent::source(ue) == s);
+return Parent::direct(edge, Parent::source(edge) == node);
 }
 // Alterable extension
 typedef AlterationNotifier<GraphExtender, Node> NodeNotifier;
 }
 class NodeIt : public Node {
-const Digraph* digraph;
+const Graph* _graph;
 public:
 NodeIt() {}
 NodeIt(Invalid i) : Node(i) { }
-explicit NodeIt(const Digraph& _digraph) : digraph(&_digraph) {
+explicit NodeIt(const Graph& graph) : _graph(&graph) {
-	_digraph.first(static_cast<Node&>(*this));
+	_graph->first(static_cast<Node&>(*this));
 }
-NodeIt(const Digraph& _digraph, const Node& node)
+NodeIt(const Graph& graph, const Node& node)
-	: Node(node), digraph(&_digraph) {}
+	: 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& _digraph) : digraph(&_digraph) {
+explicit ArcIt(const Graph& graph) : _graph(&graph) {
-	_digraph.first(static_cast<Arc&>(*this));
+	_graph->first(static_cast<Arc&>(*this));
 }
-ArcIt(const Digraph& _digraph, const Arc& e) :
+ArcIt(const Graph& graph, const Arc& arc) :
-	Arc(e), digraph(&_digraph) { }
+	Arc(arc), _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& _digraph, const Node& node)
+OutArcIt(const Graph& graph, const Node& node)
-	: digraph(&_digraph) {
+	: _graph(&graph) {
-	_digraph.firstOut(*this, node);
+	_graph->firstOut(*this, node);
 }
-OutArcIt(const Digraph& _digraph, const Arc& arc)
+OutArcIt(const Graph& graph, const Arc& arc)
-	: Arc(arc), digraph(&_digraph) {}
+	: 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& _digraph, const Node& node)
+InArcIt(const Graph& graph, const Node& node)
-	: digraph(&_digraph) {
+	: _graph(&graph) {
-	_digraph.firstIn(*this, node);
+	_graph->firstIn(*this, node);
 }
-InArcIt(const Digraph& _digraph, const Arc& arc) :
+InArcIt(const Graph& graph, const Arc& arc) :
-	Arc(arc), digraph(&_digraph) {}
+	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& _digraph) : digraph(&_digraph) {
+explicit EdgeIt(const Graph& graph) : _graph(&graph) {
-	_digraph.first(static_cast<Edge&>(*this));
+	_graph->first(static_cast<Edge&>(*this));
 }
-EdgeIt(const Digraph& _digraph, const Edge& e) :
+EdgeIt(const Graph& graph, const Edge& edge) :
-	Edge(e), digraph(&_digraph) { }
+	Edge(edge), _graph(&graph) { }
 EdgeIt& operator++() {
-	digraph->next(*this);
+	_graph->next(*this);
 	return *this;
 }
 };
-class IncArcIt : public Parent::Edge {
+class IncEdgeIt : public Parent::Edge {
 friend class GraphExtender;
-const Digraph* digraph;
+const Graph* _graph;
-bool direction;
+bool _direction;
 public:
-IncArcIt() { }
+IncEdgeIt() { }
-IncArcIt(Invalid i) : Edge(i), direction(false) { }
+IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
-IncArcIt(const Digraph& _digraph, const Node &n) : digraph(&_digraph) {
+IncEdgeIt(const Graph& graph, const Node &node) : _graph(&graph) {
-	_digraph.firstInc(*this, direction, n);
+	_graph->firstInc(*this, _direction, node);
 }
-IncArcIt(const Digraph& _digraph, const Edge &ue, const Node &n)
+IncEdgeIt(const Graph& graph, const Edge &edge, const Node &node)
-	: digraph(&_digraph), Edge(ue) {
+	: _graph(&graph), Edge(edge) {
-	direction = (_digraph.source(ue) == n);
+	_direction = (_graph->source(edge) == node);
 }
-IncArcIt& operator++() {
+IncEdgeIt& operator++() {
-	digraph->nextInc(*this, direction);
+	_graph->nextInc(*this, _direction);
 	return *this;
 }
 };
 /// \brief Base node of the iterator
 ///
 /// Returns the base node (ie. the source in this case) of the iterator
-Node baseNode(const OutArcIt &e) const {
+Node baseNode(const OutArcIt &arc) const {
-return Parent::source(static_cast<const Arc&>(e));
+return Parent::source(static_cast<const Arc&>(arc));
 }
 /// \brief Running node of the iterator
 ///
 /// Returns the running node (ie. the target in this case) of the
 /// iterator
-Node runningNode(const OutArcIt &e) const {
+Node runningNode(const OutArcIt &arc) const {
-return Parent::target(static_cast<const Arc&>(e));
+return Parent::target(static_cast<const Arc&>(arc));
 }
 /// \brief Base node of the iterator
 ///
 /// Returns the base node (ie. the target in this case) of the iterator
-Node baseNode(const InArcIt &e) const {
+Node baseNode(const InArcIt &arc) const {
-return Parent::target(static_cast<const Arc&>(e));
+return Parent::target(static_cast<const Arc&>(arc));
 }
 /// \brief Running node of the iterator
 ///
 /// Returns the running node (ie. the source in this case) of the
 /// iterator
-Node runningNode(const InArcIt &e) const {
+Node runningNode(const InArcIt &arc) const {
-return Parent::source(static_cast<const Arc&>(e));
+return Parent::source(static_cast<const Arc&>(arc));
 }
 /// Base node of the iterator
 ///
 /// Returns the base node of the iterator
-Node baseNode(const IncArcIt &e) const {
+Node baseNode(const IncEdgeIt &edge) const {
-return e.direction ? source(e) : target(e);
+return edge._direction ? source(edge) : target(edge);
 }
 /// Running node of the iterator
 ///
 /// Returns the running node of the iterator
-Node runningNode(const IncArcIt &e) const {
+Node runningNode(const IncEdgeIt &edge) const {
-return e.direction ? target(e) : source(e);
+return edge._direction ? target(edge) : source(edge);
 }
 // Mappable extension
 template <typename _Value>
 class NodeMap
-: public MapExtender<DefaultMap<Digraph, Node, _Value> > {
+: public MapExtender<DefaultMap<Graph, Node, _Value> > {
 public:
-typedef GraphExtender Digraph;
+typedef GraphExtender Graph;
-typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
+typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
-NodeMap(const Digraph& digraph)
+NodeMap(const Graph& graph)
-	: Parent(digraph) {}
+	: Parent(graph) {}
-NodeMap(const Digraph& digraph, const _Value& value)
+NodeMap(const Graph& graph, const _Value& value)
-	: Parent(digraph, value) {}
+	: Parent(graph, value) {}
 NodeMap& operator=(const NodeMap& cmap) {
 	return operator=<NodeMap>(cmap);
 }
 };
 template <typename _Value>
 class ArcMap
-: public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
+: public MapExtender<DefaultMap<Graph, Arc, _Value> > {
 public:
-typedef GraphExtender Digraph;
+typedef GraphExtender Graph;
-typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
+typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
-ArcMap(const Digraph& digraph)
+ArcMap(const Graph& graph)
-	: Parent(digraph) {}
+	: Parent(graph) {}
-ArcMap(const Digraph& digraph, const _Value& value)
+ArcMap(const Graph& graph, const _Value& value)
-	: Parent(digraph, value) {}
+	: Parent(graph, value) {}
 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 GraphExtender Digraph;
+typedef GraphExtender Graph;
-typedef MapExtender<DefaultMap<Digraph, Edge, _Value> > Parent;
+typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
-EdgeMap(const Digraph& digraph)
+EdgeMap(const Graph& graph)
-	: Parent(digraph) {}
+	: Parent(graph) {}
-EdgeMap(const Digraph& digraph, const _Value& value)
+EdgeMap(const Graph& graph, const _Value& value)
-	: Parent(digraph, value) {}
+	: Parent(graph, value) {}
 EdgeMap& operator=(const EdgeMap& cmap) {
 	return operator=<EdgeMap>(cmap);
 }
 notifier(Edge()).clear();
 notifier(Node()).clear();
 Parent::clear();
 }
-template <typename Digraph, typename NodeRefMap, typename EdgeRefMap>
+template <typename Graph, typename NodeRefMap, typename EdgeRefMap>
-void build(const Digraph& digraph, NodeRefMap& nodeRef,
+void build(const Graph& graph, NodeRefMap& nodeRef,
 EdgeRefMap& edgeRef) {
-Parent::build(digraph, nodeRef, edgeRef);
+Parent::build(graph, nodeRef, edgeRef);
 notifier(Node()).build();
 notifier(Edge()).build();
 notifier(Arc()).build();
 }
 notifier(Node()).erase(node);
 Parent::erase(node);
 }
 void erase(const Edge& edge) {
-std::vector<Arc> ev;
+std::vector<Arc> av;
-ev.push_back(Parent::direct(edge, true));
+av.push_back(Parent::direct(edge, true));
-ev.push_back(Parent::direct(edge, false));
+av.push_back(Parent::direct(edge, false));
-notifier(Arc()).erase(ev);
+notifier(Arc()).erase(av);
 notifier(Edge()).erase(edge);
 Parent::erase(edge);
 }
 GraphExtender() {

changeset 93	f857981306ea
parent 77	2de55e4f57a7
child 107	31a2e6d28f61