lemon-main: comparison lemon/bits/graph

equal deleted inserted replaced

-:00ef713fdf0c
+:698dd04ad4e1
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 return Parent::arcFromId(id);
 }
 Node oppositeNode(const Node &node, const Arc &arc) const {
 if (node == Parent::source(arc))
-	return Parent::target(arc);
+return Parent::target(arc);
 else if(node == Parent::target(arc))
-	return Parent::source(arc);
+return Parent::source(arc);
 else
-	return INVALID;
+return INVALID;
 }
 // Alterable extension
 typedef AlterationNotifier<DigraphExtender, Node> NodeNotifier;
 public:
 NodeNotifier& notifier(Node) const {
 return node_notifier;
 }
 ArcNotifier& notifier(Arc) const {
 return arc_notifier;
 }
 class NodeIt : public Node {
 const Digraph* _digraph;
 public:
 NodeIt() {}
 NodeIt(Invalid i) : Node(i) { }
 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)
-	: Node(node), _digraph(&digraph) {}
+: Node(node), _digraph(&digraph) {}
 NodeIt& operator++() {
-	_digraph->next(*this);
+_digraph->next(*this);
-	return *this;
+return *this;
 }
 };
 class ArcIt : public Arc {
 const Digraph* _digraph;
 public:
 ArcIt() { }
 ArcIt(Invalid i) : Arc(i) { }
 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& arc) :
-	Arc(arc), _digraph(&digraph) { }
+Arc(arc), _digraph(&digraph) { }
 ArcIt& operator++() {
-	_digraph->next(*this);
+_digraph->next(*this);
-	return *this;
+return *this;
 }
 };
 class OutArcIt : public Arc {
 const Digraph* _digraph;
 public:
 OutArcIt() { }
 OutArcIt(Invalid i) : Arc(i) { }
 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)
-	: Arc(arc), _digraph(&digraph) {}
+: Arc(arc), _digraph(&digraph) {}
 OutArcIt& operator++() {
-	_digraph->nextOut(*this);
+_digraph->nextOut(*this);
-	return *this;
+return *this;
 }
 };
 class InArcIt : public Arc {
 const Digraph* _digraph;
 public:
 InArcIt() { }
 InArcIt(Invalid i) : Arc(i) { }
 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) :
-	Arc(arc), _digraph(&digraph) {}
+Arc(arc), _digraph(&digraph) {}
 InArcIt& operator++() {
-	_digraph->nextIn(*this);
+_digraph->nextIn(*this);
-	return *this;
+return *this;
 }
 };
 /// \brief Base node of the iterator
 /// iterator
 Node runningNode(const InArcIt &arc) const {
 return Parent::source(arc);
 }
 template <typename _Value>
 class NodeMap
 : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
 public:
 typedef DigraphExtender Digraph;
 typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
 explicit NodeMap(const Digraph& digraph)
-	: Parent(digraph) {}
+: Parent(digraph) {}
 NodeMap(const Digraph& digraph, const _Value& value)
-	: Parent(digraph, value) {}
+: Parent(digraph, value) {}
 NodeMap& operator=(const NodeMap& cmap) {
-	return operator=<NodeMap>(cmap);
+return operator=<NodeMap>(cmap);
 }
 template <typename CMap>
 NodeMap& operator=(const CMap& cmap) {
 Parent::operator=(cmap);
-	return *this;
+return *this;
 }
 };
 template <typename _Value>
 class ArcMap
 : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
 public:
 typedef DigraphExtender Digraph;
 typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 explicit ArcMap(const Digraph& digraph)
-	: Parent(digraph) {}
+: Parent(digraph) {}
 ArcMap(const Digraph& digraph, const _Value& value)
-	: Parent(digraph, value) {}
+: Parent(digraph, value) {}
 ArcMap& operator=(const ArcMap& cmap) {
-	return operator=<ArcMap>(cmap);
+return operator=<ArcMap>(cmap);
 }
 template <typename CMap>
 ArcMap& operator=(const CMap& cmap) {
 Parent::operator=(cmap);
-	return *this;
+return *this;
 }
 };
 Node addNode() {
 Node node = Parent::addNode();
 notifier(Node()).add(node);
 return node;
 }
 Arc addArc(const Node& from, const Node& to) {
 Arc arc = Parent::addArc(from, to);
 notifier(Arc()).add(arc);
 return arc;
 }
 void erase(const Node& node) {
 Arc arc;
 Parent::firstOut(arc, node);
 while (arc != INVALID ) {
-	erase(arc);
+erase(arc);
-	Parent::firstOut(arc, node);
+Parent::firstOut(arc, node);
 }
 Parent::firstIn(arc, node);
 while (arc != INVALID ) {
-	erase(arc);
+erase(arc);
-	Parent::firstIn(arc, node);
+Parent::firstIn(arc, node);
 }
 notifier(Node()).erase(node);
 Parent::erase(node);
 }
 void erase(const Arc& arc) {
 notifier(Arc()).erase(arc);
 Parent::erase(arc);
 }
 DigraphExtender() {
 node_notifier.setContainer(*this);
 arc_notifier.setContainer(*this);
 }
 ~DigraphExtender() {
 arc_notifier.clear();
 node_notifier.clear();
 }
 };
 /// \ingroup _graphbits
 ///
 /// \brief Extender for the Graphs
 template <typename Base>
 class GraphExtender : public Base {
 public:
 typedef Base Parent;
 typedef GraphExtender Graph;
 typedef True UndirectedTag;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 typedef typename Parent::Edge Edge;
 // Graph extension
 int maxId(Node) const {
 return Parent::maxNodeId();
 }
 return Parent::edgeFromId(id);
 }
 Node oppositeNode(const Node &n, const Edge &e) const {
 if( n == Parent::u(e))
-	return Parent::v(e);
+return Parent::v(e);
 else if( n == Parent::v(e))
-	return Parent::u(e);
+return Parent::u(e);
 else
-	return INVALID;
+return INVALID;
 }
 Arc oppositeArc(const Arc &arc) const {
 return Parent::direct(arc, !Parent::direction(arc));
 }
 public:
 NodeNotifier& notifier(Node) const {
 return node_notifier;
 }
 ArcNotifier& notifier(Arc) const {
 return arc_notifier;
 }
 EdgeNotifier& notifier(Edge) const {
 return edge_notifier;
 }
 class NodeIt : public Node {
 const Graph* _graph;
 public:
 NodeIt() {}
 NodeIt(Invalid i) : Node(i) { }
 explicit NodeIt(const Graph& graph) : _graph(&graph) {
-	_graph->first(static_cast<Node&>(*this));
+_graph->first(static_cast<Node&>(*this));
 }
 NodeIt(const Graph& graph, const Node& node)
-	: Node(node), _graph(&graph) {}
+: Node(node), _graph(&graph) {}
 NodeIt& operator++() {
-	_graph->next(*this);
+_graph->next(*this);
-	return *this;
+return *this;
 }
 };
 class ArcIt : public Arc {
 const Graph* _graph;
 public:
 ArcIt() { }
 ArcIt(Invalid i) : Arc(i) { }
 explicit ArcIt(const Graph& graph) : _graph(&graph) {
-	_graph->first(static_cast<Arc&>(*this));
+_graph->first(static_cast<Arc&>(*this));
 }
 ArcIt(const Graph& graph, const Arc& arc) :
-	Arc(arc), _graph(&graph) { }
+Arc(arc), _graph(&graph) { }
 ArcIt& operator++() {
-	_graph->next(*this);
+_graph->next(*this);
-	return *this;
+return *this;
 }
 };
 class OutArcIt : public Arc {
 const Graph* _graph;
 public:
 OutArcIt() { }
 OutArcIt(Invalid i) : Arc(i) { }
 OutArcIt(const Graph& graph, const Node& node)
-	: _graph(&graph) {
+: _graph(&graph) {
-	_graph->firstOut(*this, node);
+_graph->firstOut(*this, node);
 }
 OutArcIt(const Graph& graph, const Arc& arc)
-	: Arc(arc), _graph(&graph) {}
+: Arc(arc), _graph(&graph) {}
 OutArcIt& operator++() {
-	_graph->nextOut(*this);
+_graph->nextOut(*this);
-	return *this;
+return *this;
 }
 };
 class InArcIt : public Arc {
 const Graph* _graph;
 public:
 InArcIt() { }
 InArcIt(Invalid i) : Arc(i) { }
 InArcIt(const Graph& graph, const Node& node)
-	: _graph(&graph) {
+: _graph(&graph) {
-	_graph->firstIn(*this, node);
+_graph->firstIn(*this, node);
 }
 InArcIt(const Graph& graph, const Arc& arc) :
-	Arc(arc), _graph(&graph) {}
+Arc(arc), _graph(&graph) {}
 InArcIt& operator++() {
-	_graph->nextIn(*this);
+_graph->nextIn(*this);
-	return *this;
+return *this;
 }
 };
 class EdgeIt : public Parent::Edge {
 const Graph* _graph;
 public:
 EdgeIt() { }
 EdgeIt(Invalid i) : Edge(i) { }
 explicit EdgeIt(const Graph& graph) : _graph(&graph) {
-	_graph->first(static_cast<Edge&>(*this));
+_graph->first(static_cast<Edge&>(*this));
 }
 EdgeIt(const Graph& graph, const Edge& edge) :
-	Edge(edge), _graph(&graph) { }
+Edge(edge), _graph(&graph) { }
 EdgeIt& operator++() {
-	_graph->next(*this);
+_graph->next(*this);
-	return *this;
+return *this;
 }
 };
 class IncEdgeIt : public Parent::Edge {
 IncEdgeIt() { }
 IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
 IncEdgeIt(const Graph& graph, const Node &node) : _graph(&graph) {
-	_graph->firstInc(*this, _direction, node);
+_graph->firstInc(*this, _direction, node);
 }
 IncEdgeIt(const Graph& graph, const Edge &edge, const Node &node)
-	: _graph(&graph), Edge(edge) {
+: _graph(&graph), Edge(edge) {
-	_direction = (_graph->source(edge) == node);
+_direction = (_graph->source(edge) == node);
 }
 IncEdgeIt& operator++() {
-	_graph->nextInc(*this, _direction);
+_graph->nextInc(*this, _direction);
-	return *this;
+return *this;
 }
 };
 /// \brief Base node of the iterator
 ///
 }
 // Mappable extension
 template <typename _Value>
 class NodeMap
 : public MapExtender<DefaultMap<Graph, Node, _Value> > {
 public:
 typedef GraphExtender Graph;
 typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
 NodeMap(const Graph& graph)
-	: Parent(graph) {}
+: Parent(graph) {}
 NodeMap(const Graph& graph, const _Value& value)
-	: Parent(graph, value) {}
+: Parent(graph, value) {}
 NodeMap& operator=(const NodeMap& cmap) {
-	return operator=<NodeMap>(cmap);
+return operator=<NodeMap>(cmap);
 }
 template <typename CMap>
 NodeMap& operator=(const CMap& cmap) {
 Parent::operator=(cmap);
-	return *this;
+return *this;
 }
 };
 template <typename _Value>
 class ArcMap
 : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
 public:
 typedef GraphExtender Graph;
 typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 ArcMap(const Graph& graph)
-	: Parent(graph) {}
+: Parent(graph) {}
 ArcMap(const Graph& graph, const _Value& value)
-	: Parent(graph, value) {}
+: Parent(graph, value) {}
 ArcMap& operator=(const ArcMap& cmap) {
-	return operator=<ArcMap>(cmap);
+return operator=<ArcMap>(cmap);
 }
 template <typename CMap>
 ArcMap& operator=(const CMap& cmap) {
 Parent::operator=(cmap);
-	return *this;
+return *this;
 }
 };
 template <typename _Value>
 class EdgeMap
 : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
 public:
 typedef GraphExtender Graph;
 typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 EdgeMap(const Graph& graph)
-	: Parent(graph) {}
+: Parent(graph) {}
 EdgeMap(const Graph& graph, const _Value& value)
-	: Parent(graph, value) {}
+: Parent(graph, value) {}
 EdgeMap& operator=(const EdgeMap& cmap) {
-	return operator=<EdgeMap>(cmap);
+return operator=<EdgeMap>(cmap);
 }
 template <typename CMap>
 EdgeMap& operator=(const CMap& cmap) {
 Parent::operator=(cmap);
-	return *this;
+return *this;
 }
 };
 // Alteration extension
 Edge addEdge(const Node& from, const Node& to) {
 Edge edge = Parent::addEdge(from, to);
 notifier(Edge()).add(edge);
 std::vector<Arc> ev;
 ev.push_back(Parent::direct(edge, true));
 ev.push_back(Parent::direct(edge, false));
 notifier(Arc()).add(ev);
 return edge;
 }
 void clear() {
 notifier(Arc()).clear();
 notifier(Edge()).clear();
 notifier(Node()).clear();
 Parent::clear();
 }
 template <typename Graph, typename NodeRefMap, typename EdgeRefMap>
 void build(const Graph& graph, NodeRefMap& nodeRef,
 EdgeRefMap& edgeRef) {
 Parent::build(graph, nodeRef, edgeRef);
 notifier(Node()).build();
 notifier(Edge()).build();
 notifier(Arc()).build();
 void erase(const Node& node) {
 Arc arc;
 Parent::firstOut(arc, node);
 while (arc != INVALID ) {
-	erase(arc);
+erase(arc);
-	Parent::firstOut(arc, node);
+Parent::firstOut(arc, node);
 }
 Parent::firstIn(arc, node);
 while (arc != INVALID ) {
-	erase(arc);
+erase(arc);
-	Parent::firstIn(arc, node);
+Parent::firstIn(arc, node);
 }
 notifier(Node()).erase(node);
 Parent::erase(node);
 }
 void erase(const Edge& edge) {
 std::vector<Arc> av;
 av.push_back(Parent::direct(edge, true));
 av.push_back(Parent::direct(edge, false));
 notifier(Arc()).erase(av);
 notifier(Edge()).erase(edge);
 Parent::erase(edge);
 }
 GraphExtender() {
 node_notifier.setContainer(*this);
 arc_notifier.setContainer(*this);
 edge_notifier.setContainer(*this);
 }
 ~GraphExtender() {
 edge_notifier.clear();
 arc_notifier.clear();
 node_notifier.clear();
 }
 };
 }

changeset 218	0d6511647639
parent 125	19e82bda606a
child 220	a5d8c039f218