lemon-1.1: comparison lemon/edge

equal deleted inserted replaced

-:156cf2b3e5a3
+:539ef86d6577
 /// \brief ArcSet and EdgeSet classes.
 ///
 /// Graphs which use another graph's node-set as own.
 namespace lemon {
-template <typename _Graph>
+template <typename GR>
 class ListArcSetBase {
 public:
-typedef _Graph Graph;
+typedef GR Graph;
-typedef typename Graph::Node Node;
+typedef typename GR::Node Node;
-typedef typename Graph::NodeIt NodeIt;
+typedef typename GR::NodeIt NodeIt;
 protected:
 struct NodeT {
 int first_out, first_in;
 NodeT() : first_out(-1), first_in(-1) {}
 };
-typedef typename ItemSetTraits<Graph, Node>::
+typedef typename ItemSetTraits<GR, Node>::
 template Map<NodeT>::Type NodesImplBase;
-NodesImplBase* nodes;
+NodesImplBase* _nodes;
 struct ArcT {
 Node source, target;
 int next_out, next_in;
 int prev_out, prev_in;
 std::vector<ArcT> arcs;
 int first_arc;
 int first_free_arc;
-const Graph* graph;
+const GR* _graph;
-void initalize(const Graph& _graph, NodesImplBase& _nodes) {
+void initalize(const GR& graph, NodesImplBase& nodes) {
-graph = &_graph;
+_graph = &graph;
-nodes = &_nodes;
+_nodes = &nodes;
 }
 public:
 class Arc {
-friend class ListArcSetBase<Graph>;
+friend class ListArcSetBase<GR>;
 protected:
 Arc(int _id) : id(_id) {}
 int id;
 public:
 Arc() {}
 arcs.push_back(ArcT());
 } else {
 n = first_free_arc;
 first_free_arc = arcs[first_free_arc].next_in;
 }
-arcs[n].next_in = (*nodes)[v].first_in;
+arcs[n].next_in = (*_nodes)[v].first_in;
-if ((*nodes)[v].first_in != -1) {
+if ((*_nodes)[v].first_in != -1) {
-arcs[(*nodes)[v].first_in].prev_in = n;
+arcs[(*_nodes)[v].first_in].prev_in = n;
 }
-(*nodes)[v].first_in = n;
+(*_nodes)[v].first_in = n;
-arcs[n].next_out = (*nodes)[u].first_out;
+arcs[n].next_out = (*_nodes)[u].first_out;
-if ((*nodes)[u].first_out != -1) {
+if ((*_nodes)[u].first_out != -1) {
-arcs[(*nodes)[u].first_out].prev_out = n;
+arcs[(*_nodes)[u].first_out].prev_out = n;
 }
-(*nodes)[u].first_out = n;
+(*_nodes)[u].first_out = n;
 arcs[n].source = u;
 arcs[n].target = v;
 return Arc(n);
 }
 void erase(const Arc& arc) {
 int n = arc.id;
 if (arcs[n].prev_in != -1) {
 arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
 } else {
-(*nodes)[arcs[n].target].first_in = arcs[n].next_in;
+(*_nodes)[arcs[n].target].first_in = arcs[n].next_in;
 }
 if (arcs[n].next_in != -1) {
 arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
 }
 if (arcs[n].prev_out != -1) {
 arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 } else {
-(*nodes)[arcs[n].source].first_out = arcs[n].next_out;
+(*_nodes)[arcs[n].source].first_out = arcs[n].next_out;
 }
 if (arcs[n].next_out != -1) {
 arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
 }
 }
 void clear() {
 Node node;
 for (first(node); node != INVALID; next(node)) {
-(*nodes)[node].first_in = -1;
+(*_nodes)[node].first_in = -1;
-(*nodes)[node].first_out = -1;
+(*_nodes)[node].first_out = -1;
 }
 arcs.clear();
 first_arc = -1;
 first_free_arc = -1;
 }
 void first(Node& node) const {
-graph->first(node);
+_graph->first(node);
 }
 void next(Node& node) const {
-graph->next(node);
+_graph->next(node);
 }
 void first(Arc& arc) const {
 Node node;
 first(node);
-while (node != INVALID && (*nodes)[node].first_in == -1) {
+while (node != INVALID && (*_nodes)[node].first_in == -1) {
 next(node);
 }
-arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_in;
+arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
 }
 void next(Arc& arc) const {
 if (arcs[arc.id].next_in != -1) {
 arc.id = arcs[arc.id].next_in;
 } else {
 Node node = arcs[arc.id].target;
 next(node);
-while (node != INVALID && (*nodes)[node].first_in == -1) {
+while (node != INVALID && (*_nodes)[node].first_in == -1) {
 next(node);
 }
-arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_in;
+arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
 }
 }
 void firstOut(Arc& arc, const Node& node) const {
-arc.id = (*nodes)[node].first_out;
+arc.id = (*_nodes)[node].first_out;
 }
 void nextOut(Arc& arc) const {
 arc.id = arcs[arc.id].next_out;
 }
 void firstIn(Arc& arc, const Node& node) const {
-arc.id = (*nodes)[node].first_in;
+arc.id = (*_nodes)[node].first_in;
 }
 void nextIn(Arc& arc) const {
 arc.id = arcs[arc.id].next_in;
 }
-int id(const Node& node) const { return graph->id(node); }
+int id(const Node& node) const { return _graph->id(node); }
 int id(const Arc& arc) const { return arc.id; }
-Node nodeFromId(int ix) const { return graph->nodeFromId(ix); }
+Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
 Arc arcFromId(int ix) const { return Arc(ix); }
-int maxNodeId() const { return graph->maxNodeId(); };
+int maxNodeId() const { return _graph->maxNodeId(); };
 int maxArcId() const { return arcs.size() - 1; }
 Node source(const Arc& arc) const { return arcs[arc.id].source;}
 Node target(const Arc& arc) const { return arcs[arc.id].target;}
-typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const {
-return graph->notifier(Node());
+return _graph->notifier(Node());
 }
-template <typename _Value>
+template <typename V>
-class NodeMap : public Graph::template NodeMap<_Value> {
+class NodeMap : public GR::template NodeMap<V> {
 public:
-typedef typename _Graph::template NodeMap<_Value> Parent;
+typedef typename GR::template NodeMap<V> Parent;
-explicit NodeMap(const ListArcSetBase<Graph>& arcset)
+explicit NodeMap(const ListArcSetBase<GR>& arcset)
-: Parent(*arcset.graph) {}
+: Parent(*arcset._graph) {}
-NodeMap(const ListArcSetBase<Graph>& arcset, const _Value& value)
+NodeMap(const ListArcSetBase<GR>& arcset, const V& value)
-: Parent(*arcset.graph, value) {}
+: Parent(*arcset._graph, value) {}
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 /// node the outgoing and the incoming arcs make up lists, therefore
 /// one arc can be erased in constant time. It also makes possible,
 /// that node can be removed from the underlying graph, in this case
 /// all arcs incident to the given node is erased from the arc set.
 ///
-/// \param _Graph The type of the graph which shares its node set with
+/// \param GR The type of the graph which shares its node set with
 /// this class. Its interface must conform to the
 /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 /// concept.
 ///
 /// This class is fully conform to the \ref concepts::Digraph
 /// "Digraph" concept.
-template <typename _Graph>
+template <typename GR>
-class ListArcSet : public ArcSetExtender<ListArcSetBase<_Graph> > {
+class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
 public:
-typedef ArcSetExtender<ListArcSetBase<_Graph> > Parent;
+typedef ArcSetExtender<ListArcSetBase<GR> > Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
-typedef _Graph Graph;
+typedef GR Graph;
 typedef typename Parent::NodesImplBase NodesImplBase;
 void eraseNode(const Node& node) {
 class NodesImpl : public NodesImplBase {
 public:
 typedef NodesImplBase Parent;
-NodesImpl(const Graph& graph, ListArcSet& arcset)
+NodesImpl(const GR& graph, ListArcSet& arcset)
 : Parent(graph), _arcset(arcset) {}
 virtual ~NodesImpl() {}
 protected:
 private:
 ListArcSet& _arcset;
 };
-NodesImpl nodes;
+NodesImpl _nodes;
 public:
 /// \brief Constructor of the ArcSet.
 ///
 /// Constructor of the ArcSet.
-ListArcSet(const Graph& graph) : nodes(graph, *this) {
+ListArcSet(const GR& graph) : _nodes(graph, *this) {
-Parent::initalize(graph, nodes);
+Parent::initalize(graph, _nodes);
 }
 /// \brief Add a new arc to the digraph.
 ///
 /// Add a new arc to the digraph with source node \c s
 return Parent::erase(a);
 }
 };
-template <typename _Graph>
+template <typename GR>
 class ListEdgeSetBase {
 public:
-typedef _Graph Graph;
+typedef GR Graph;
-typedef typename Graph::Node Node;
+typedef typename GR::Node Node;
-typedef typename Graph::NodeIt NodeIt;
+typedef typename GR::NodeIt NodeIt;
 protected:
 struct NodeT {
 int first_out;
 NodeT() : first_out(-1) {}
 };
-typedef typename ItemSetTraits<Graph, Node>::
+typedef typename ItemSetTraits<GR, Node>::
 template Map<NodeT>::Type NodesImplBase;
-NodesImplBase* nodes;
+NodesImplBase* _nodes;
 struct ArcT {
 Node target;
 int prev_out, next_out;
 ArcT() : prev_out(-1), next_out(-1) {}
 std::vector<ArcT> arcs;
 int first_arc;
 int first_free_arc;
-const Graph* graph;
+const GR* _graph;
-void initalize(const Graph& _graph, NodesImplBase& _nodes) {
+void initalize(const GR& graph, NodesImplBase& nodes) {
-graph = &_graph;
+_graph = &graph;
-nodes = &_nodes;
+_nodes = &nodes;
 }
 public:
 class Edge {
 }
 arcs[n].target = u;
 arcs[n | 1].target = v;
-arcs[n].next_out = (*nodes)[v].first_out;
+arcs[n].next_out = (*_nodes)[v].first_out;
-if ((*nodes)[v].first_out != -1) {
+if ((*_nodes)[v].first_out != -1) {
-arcs[(*nodes)[v].first_out].prev_out = n;
+arcs[(*_nodes)[v].first_out].prev_out = n;
 }
-(*nodes)[v].first_out = n;
+(*_nodes)[v].first_out = n;
 arcs[n].prev_out = -1;
-if ((*nodes)[u].first_out != -1) {
+if ((*_nodes)[u].first_out != -1) {
-arcs[(*nodes)[u].first_out].prev_out = (n | 1);
+arcs[(*_nodes)[u].first_out].prev_out = (n | 1);
 }
-arcs[n | 1].next_out = (*nodes)[u].first_out;
+arcs[n | 1].next_out = (*_nodes)[u].first_out;
-(*nodes)[u].first_out = (n | 1);
+(*_nodes)[u].first_out = (n | 1);
 arcs[n | 1].prev_out = -1;
 return Edge(n / 2);
 }
 }
 if (arcs[n].prev_out != -1) {
 arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 } else {
-(*nodes)[arcs[n | 1].target].first_out = arcs[n].next_out;
+(*_nodes)[arcs[n | 1].target].first_out = arcs[n].next_out;
 }
 if (arcs[n | 1].next_out != -1) {
 arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
 }
 if (arcs[n | 1].prev_out != -1) {
 arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
 } else {
-(*nodes)[arcs[n].target].first_out = arcs[n | 1].next_out;
+(*_nodes)[arcs[n].target].first_out = arcs[n | 1].next_out;
 }
 arcs[n].next_out = first_free_arc;
 first_free_arc = n;
 }
 void clear() {
 Node node;
 for (first(node); node != INVALID; next(node)) {
-(*nodes)[node].first_out = -1;
+(*_nodes)[node].first_out = -1;
 }
 arcs.clear();
 first_arc = -1;
 first_free_arc = -1;
 }
 void first(Node& node) const {
-graph->first(node);
+_graph->first(node);
 }
 void next(Node& node) const {
-graph->next(node);
+_graph->next(node);
 }
 void first(Arc& arc) const {
 Node node;
 first(node);
-while (node != INVALID && (*nodes)[node].first_out == -1) {
+while (node != INVALID && (*_nodes)[node].first_out == -1) {
 next(node);
 }
-arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_out;
+arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
 }
 void next(Arc& arc) const {
 if (arcs[arc.id].next_out != -1) {
 arc.id = arcs[arc.id].next_out;
 } else {
 Node node = arcs[arc.id ^ 1].target;
 next(node);
-while(node != INVALID && (*nodes)[node].first_out == -1) {
+while(node != INVALID && (*_nodes)[node].first_out == -1) {
 next(node);
 }
-arc.id = (node == INVALID) ? -1 : (*nodes)[node].first_out;
+arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
 }
 }
 void first(Edge& edge) const {
 Node node;
 first(node);
 while (node != INVALID) {
-edge.id = (*nodes)[node].first_out;
+edge.id = (*_nodes)[node].first_out;
 while ((edge.id & 1) != 1) {
 edge.id = arcs[edge.id].next_out;
 }
 if (edge.id != -1) {
 edge.id /= 2;
 edge.id /= 2;
 return;
 }
 next(node);
 while (node != INVALID) {
-edge.id = (*nodes)[node].first_out;
+edge.id = (*_nodes)[node].first_out;
 while ((edge.id & 1) != 1) {
 edge.id = arcs[edge.id].next_out;
 }
 if (edge.id != -1) {
 edge.id /= 2;
 }
 edge.id = -1;
 }
 void firstOut(Arc& arc, const Node& node) const {
-arc.id = (*nodes)[node].first_out;
+arc.id = (*_nodes)[node].first_out;
 }
 void nextOut(Arc& arc) const {
 arc.id = arcs[arc.id].next_out;
 }
 void firstIn(Arc& arc, const Node& node) const {
-arc.id = (((*nodes)[node].first_out) ^ 1);
+arc.id = (((*_nodes)[node].first_out) ^ 1);
 if (arc.id == -2) arc.id = -1;
 }
 void nextIn(Arc& arc) const {
 arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
 if (arc.id == -2) arc.id = -1;
 }
 void firstInc(Edge &arc, bool& dir, const Node& node) const {
-int de = (*nodes)[node].first_out;
+int de = (*_nodes)[node].first_out;
 if (de != -1 ) {
 arc.id = de / 2;
 dir = ((de & 1) == 1);
 } else {
 arc.id = -1;
 static Arc direct(Edge edge, bool dir) {
 return Arc(edge.id * 2 + (dir ? 1 : 0));
 }
-int id(const Node& node) const { return graph->id(node); }
+int id(const Node& node) const { return _graph->id(node); }
 static int id(Arc e) { return e.id; }
 static int id(Edge e) { return e.id; }
-Node nodeFromId(int id) const { return graph->nodeFromId(id); }
+Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
 static Arc arcFromId(int id) { return Arc(id);}
 static Edge edgeFromId(int id) { return Edge(id);}
-int maxNodeId() const { return graph->maxNodeId(); };
+int maxNodeId() const { return _graph->maxNodeId(); };
 int maxEdgeId() const { return arcs.size() / 2 - 1; }
 int maxArcId() const { return arcs.size()-1; }
 Node source(Arc e) const { return arcs[e.id ^ 1].target; }
 Node target(Arc e) const { return arcs[e.id].target; }
 Node u(Edge e) const { return arcs[2 * e.id].target; }
 Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
-typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const {
-return graph->notifier(Node());
+return _graph->notifier(Node());
 }
-template <typename _Value>
+template <typename V>
-class NodeMap : public Graph::template NodeMap<_Value> {
+class NodeMap : public GR::template NodeMap<V> {
 public:
-typedef typename _Graph::template NodeMap<_Value> Parent;
+typedef typename GR::template NodeMap<V> Parent;
-explicit NodeMap(const ListEdgeSetBase<Graph>& arcset)
+explicit NodeMap(const ListEdgeSetBase<GR>& arcset)
-: Parent(*arcset.graph) {}
+: Parent(*arcset._graph) {}
-NodeMap(const ListEdgeSetBase<Graph>& arcset, const _Value& value)
+NodeMap(const ListEdgeSetBase<GR>& arcset, const V& value)
-: Parent(*arcset.graph, value) {}
+: Parent(*arcset._graph, value) {}
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 /// node the incident edges make up lists, therefore one edge can be
 /// erased in constant time. It also makes possible, that node can
 /// be removed from the underlying graph, in this case all edges
 /// incident to the given node is erased from the arc set.
 ///
-/// \param _Graph The type of the graph which shares its node set
+/// \param GR The type of the graph which shares its node set
 /// with this class. Its interface must conform to the
 /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 /// concept.
 ///
 /// This class is fully conform to the \ref concepts::Graph "Graph"
 /// concept.
-template <typename _Graph>
+template <typename GR>
-class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<_Graph> > {
+class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<GR> > {
 public:
-typedef EdgeSetExtender<ListEdgeSetBase<_Graph> > Parent;
+typedef EdgeSetExtender<ListEdgeSetBase<GR> > Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 typedef typename Parent::Edge Edge;
-typedef _Graph Graph;
+typedef GR Graph;
 typedef typename Parent::NodesImplBase NodesImplBase;
 void eraseNode(const Node& node) {
 class NodesImpl : public NodesImplBase {
 public:
 typedef NodesImplBase Parent;
-NodesImpl(const Graph& graph, ListEdgeSet& arcset)
+NodesImpl(const GR& graph, ListEdgeSet& arcset)
 : Parent(graph), _arcset(arcset) {}
 virtual ~NodesImpl() {}
 protected:
 private:
 ListEdgeSet& _arcset;
 };
-NodesImpl nodes;
+NodesImpl _nodes;
 public:
 /// \brief Constructor of the EdgeSet.
 ///
 /// Constructor of the EdgeSet.
-ListEdgeSet(const Graph& graph) : nodes(graph, *this) {
+ListEdgeSet(const GR& graph) : _nodes(graph, *this) {
-Parent::initalize(graph, nodes);
+Parent::initalize(graph, _nodes);
 }
 /// \brief Add a new edge to the graph.
 ///
 /// Add a new edge to the graph with node \c u
 return Parent::erase(e);
 }
 };
-template <typename _Graph>
+template <typename GR>
 class SmartArcSetBase {
 public:
-typedef _Graph Graph;
+typedef GR Graph;
 typedef typename Graph::Node Node;
 typedef typename Graph::NodeIt NodeIt;
 protected:
 struct NodeT {
 int first_out, first_in;
 NodeT() : first_out(-1), first_in(-1) {}
 };
-typedef typename ItemSetTraits<Graph, Node>::
+typedef typename ItemSetTraits<GR, Node>::
 template Map<NodeT>::Type NodesImplBase;
-NodesImplBase* nodes;
+NodesImplBase* _nodes;
 struct ArcT {
 Node source, target;
 int next_out, next_in;
 ArcT() {}
 };
 std::vector<ArcT> arcs;
-const Graph* graph;
+const GR* _graph;
-void initalize(const Graph& _graph, NodesImplBase& _nodes) {
+void initalize(const GR& graph, NodesImplBase& nodes) {
-graph = &_graph;
+_graph = &graph;
-nodes = &_nodes;
+_nodes = &nodes;
 }
 public:
 class Arc {
-friend class SmartArcSetBase<Graph>;
+friend class SmartArcSetBase<GR>;
 protected:
 Arc(int _id) : id(_id) {}
 int id;
 public:
 Arc() {}
 SmartArcSetBase() {}
 Arc addArc(const Node& u, const Node& v) {
 int n = arcs.size();
 arcs.push_back(ArcT());
-arcs[n].next_in = (*nodes)[v].first_in;
+arcs[n].next_in = (*_nodes)[v].first_in;
-(*nodes)[v].first_in = n;
+(*_nodes)[v].first_in = n;
-arcs[n].next_out = (*nodes)[u].first_out;
+arcs[n].next_out = (*_nodes)[u].first_out;
-(*nodes)[u].first_out = n;
+(*_nodes)[u].first_out = n;
 arcs[n].source = u;
 arcs[n].target = v;
 return Arc(n);
 }
 void clear() {
 Node node;
 for (first(node); node != INVALID; next(node)) {
-(*nodes)[node].first_in = -1;
+(*_nodes)[node].first_in = -1;
-(*nodes)[node].first_out = -1;
+(*_nodes)[node].first_out = -1;
 }
 arcs.clear();
 }
 void first(Node& node) const {
-graph->first(node);
+_graph->first(node);
 }
 void next(Node& node) const {
-graph->next(node);
+_graph->next(node);
 }
 void first(Arc& arc) const {
 arc.id = arcs.size() - 1;
 }
 void next(Arc& arc) const {
 --arc.id;
 }
 void firstOut(Arc& arc, const Node& node) const {
-arc.id = (*nodes)[node].first_out;
+arc.id = (*_nodes)[node].first_out;
 }
 void nextOut(Arc& arc) const {
 arc.id = arcs[arc.id].next_out;
 }
 void firstIn(Arc& arc, const Node& node) const {
-arc.id = (*nodes)[node].first_in;
+arc.id = (*_nodes)[node].first_in;
 }
 void nextIn(Arc& arc) const {
 arc.id = arcs[arc.id].next_in;
 }
-int id(const Node& node) const { return graph->id(node); }
+int id(const Node& node) const { return _graph->id(node); }
 int id(const Arc& arc) const { return arc.id; }
-Node nodeFromId(int ix) const { return graph->nodeFromId(ix); }
+Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
 Arc arcFromId(int ix) const { return Arc(ix); }
-int maxNodeId() const { return graph->maxNodeId(); };
+int maxNodeId() const { return _graph->maxNodeId(); };
 int maxArcId() const { return arcs.size() - 1; }
 Node source(const Arc& arc) const { return arcs[arc.id].source;}
 Node target(const Arc& arc) const { return arcs[arc.id].target;}
-typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const {
-return graph->notifier(Node());
+return _graph->notifier(Node());
 }
-template <typename _Value>
+template <typename V>
-class NodeMap : public Graph::template NodeMap<_Value> {
+class NodeMap : public GR::template NodeMap<V> {
 public:
-typedef typename _Graph::template NodeMap<_Value> Parent;
+typedef typename GR::template NodeMap<V> Parent;
-explicit NodeMap(const SmartArcSetBase<Graph>& arcset)
+explicit NodeMap(const SmartArcSetBase<GR>& arcset)
-: Parent(*arcset.graph) { }
+: Parent(*arcset._graph) { }
-NodeMap(const SmartArcSetBase<Graph>& arcset, const _Value& value)
+NodeMap(const SmartArcSetBase<GR>& arcset, const V& value)
-: Parent(*arcset.graph, value) { }
+: Parent(*arcset._graph, value) { }
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 /// original graph is valid in this arc set, therefore the node
 /// objects of the original graph can be used directly with this
 /// class. The node handling functions (id handling, observing, and
 /// iterators) works equivalently as in the original graph.
 ///
-/// \param _Graph The type of the graph which shares its node set with
+/// \param GR The type of the graph which shares its node set with
 /// this class. Its interface must conform to the
 /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 /// concept.
 ///
 /// This implementation is slightly faster than the \c ListArcSet,
 /// the arc set is invalidated, and it cannot be used anymore. The
 /// validity can be checked with the \c valid() member function.
 ///
 /// This class is fully conform to the \ref concepts::Digraph
 /// "Digraph" concept.
-template <typename _Graph>
+template <typename GR>
-class SmartArcSet : public ArcSetExtender<SmartArcSetBase<_Graph> > {
+class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
 public:
-typedef ArcSetExtender<SmartArcSetBase<_Graph> > Parent;
+typedef ArcSetExtender<SmartArcSetBase<GR> > Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
-typedef _Graph Graph;
+typedef GR Graph;
 protected:
 typedef typename Parent::NodesImplBase NodesImplBase;
 class NodesImpl : public NodesImplBase {
 public:
 typedef NodesImplBase Parent;
-NodesImpl(const Graph& graph, SmartArcSet& arcset)
+NodesImpl(const GR& graph, SmartArcSet& arcset)
 : Parent(graph), _arcset(arcset) {}
 virtual ~NodesImpl() {}
 bool attached() const {
 private:
 SmartArcSet& _arcset;
 };
-NodesImpl nodes;
+NodesImpl _nodes;
 public:
 /// \brief Constructor of the ArcSet.
 ///
 /// Constructor of the ArcSet.
-SmartArcSet(const Graph& graph) : nodes(graph, *this) {
+SmartArcSet(const GR& graph) : _nodes(graph, *this) {
-Parent::initalize(graph, nodes);
+Parent::initalize(graph, _nodes);
 }
 /// \brief Add a new arc to the digraph.
 ///
 /// Add a new arc to the digraph with source node \c s
 ///
 /// This functions gives back false if the ArcSet is
 /// invalidated. It occurs when a node in the underlying graph is
 /// erased and it is not isolated in the ArcSet.
 bool valid() const {
-return nodes.attached();
+return _nodes.attached();
 }
 };
-template <typename _Graph>
+template <typename GR>
 class SmartEdgeSetBase {
 public:
-typedef _Graph Graph;
+typedef GR Graph;
-typedef typename Graph::Node Node;
+typedef typename GR::Node Node;
-typedef typename Graph::NodeIt NodeIt;
+typedef typename GR::NodeIt NodeIt;
 protected:
 struct NodeT {
 int first_out;
 NodeT() : first_out(-1) {}
 };
-typedef typename ItemSetTraits<Graph, Node>::
+typedef typename ItemSetTraits<GR, Node>::
 template Map<NodeT>::Type NodesImplBase;
-NodesImplBase* nodes;
+NodesImplBase* _nodes;
 struct ArcT {
 Node target;
 int next_out;
 ArcT() {}
 };
 std::vector<ArcT> arcs;
-const Graph* graph;
+const GR* _graph;
-void initalize(const Graph& _graph, NodesImplBase& _nodes) {
+void initalize(const GR& graph, NodesImplBase& nodes) {
-graph = &_graph;
+_graph = &graph;
-nodes = &_nodes;
+_nodes = &nodes;
 }
 public:
 class Edge {
 arcs.push_back(ArcT());
 arcs[n].target = u;
 arcs[n | 1].target = v;
-arcs[n].next_out = (*nodes)[v].first_out;
+arcs[n].next_out = (*_nodes)[v].first_out;
-(*nodes)[v].first_out = n;
+(*_nodes)[v].first_out = n;
-arcs[n | 1].next_out = (*nodes)[u].first_out;
+arcs[n | 1].next_out = (*_nodes)[u].first_out;
-(*nodes)[u].first_out = (n | 1);
+(*_nodes)[u].first_out = (n | 1);
 return Edge(n / 2);
 }
 void clear() {
 Node node;
 for (first(node); node != INVALID; next(node)) {
-(*nodes)[node].first_out = -1;
+(*_nodes)[node].first_out = -1;
 }
 arcs.clear();
 }
 void first(Node& node) const {
-graph->first(node);
+_graph->first(node);
 }
 void next(Node& node) const {
-graph->next(node);
+_graph->next(node);
 }
 void first(Arc& arc) const {
 arc.id = arcs.size() - 1;
 }
 void next(Edge& arc) const {
 --arc.id;
 }
 void firstOut(Arc& arc, const Node& node) const {
-arc.id = (*nodes)[node].first_out;
+arc.id = (*_nodes)[node].first_out;
 }
 void nextOut(Arc& arc) const {
 arc.id = arcs[arc.id].next_out;
 }
 void firstIn(Arc& arc, const Node& node) const {
-arc.id = (((*nodes)[node].first_out) ^ 1);
+arc.id = (((*_nodes)[node].first_out) ^ 1);
 if (arc.id == -2) arc.id = -1;
 }
 void nextIn(Arc& arc) const {
 arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
 if (arc.id == -2) arc.id = -1;
 }
 void firstInc(Edge &arc, bool& dir, const Node& node) const {
-int de = (*nodes)[node].first_out;
+int de = (*_nodes)[node].first_out;
 if (de != -1 ) {
 arc.id = de / 2;
 dir = ((de & 1) == 1);
 } else {
 arc.id = -1;
 static Arc direct(Edge edge, bool dir) {
 return Arc(edge.id * 2 + (dir ? 1 : 0));
 }
-int id(Node node) const { return graph->id(node); }
+int id(Node node) const { return _graph->id(node); }
 static int id(Arc arc) { return arc.id; }
 static int id(Edge arc) { return arc.id; }
-Node nodeFromId(int id) const { return graph->nodeFromId(id); }
+Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
 static Arc arcFromId(int id) { return Arc(id); }
 static Edge edgeFromId(int id) { return Edge(id);}
-int maxNodeId() const { return graph->maxNodeId(); };
+int maxNodeId() const { return _graph->maxNodeId(); };
 int maxArcId() const { return arcs.size() - 1; }
 int maxEdgeId() const { return arcs.size() / 2 - 1; }
 Node source(Arc e) const { return arcs[e.id ^ 1].target; }
 Node target(Arc e) const { return arcs[e.id].target; }
 Node u(Edge e) const { return arcs[2 * e.id].target; }
 Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
-typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const {
-return graph->notifier(Node());
+return _graph->notifier(Node());
 }
-template <typename _Value>
+template <typename V>
-class NodeMap : public Graph::template NodeMap<_Value> {
+class NodeMap : public GR::template NodeMap<V> {
 public:
-typedef typename _Graph::template NodeMap<_Value> Parent;
+typedef typename GR::template NodeMap<V> Parent;
-explicit NodeMap(const SmartEdgeSetBase<Graph>& arcset)
+explicit NodeMap(const SmartEdgeSetBase<GR>& arcset)
-: Parent(*arcset.graph) { }
+: Parent(*arcset._graph) { }
-NodeMap(const SmartEdgeSetBase<Graph>& arcset, const _Value& value)
+NodeMap(const SmartEdgeSetBase<GR>& arcset, const V& value)
-: Parent(*arcset.graph, value) { }
+: Parent(*arcset._graph, value) { }
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 /// graph is valid in this arc set, therefore the node objects of
 /// the original graph can be used directly with this class. The
 /// node handling functions (id handling, observing, and iterators)
 /// works equivalently as in the original graph.
 ///
-/// \param _Graph The type of the graph which shares its node set
+/// \param GR The type of the graph which shares its node set
 /// with this class. Its interface must conform to the
 /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
 ///  concept.
 ///
 /// This implementation is slightly faster than the \c ListEdgeSet,
 /// is invalidated, and it cannot be used anymore. The validity can
 /// be checked with the \c valid() member function.
 ///
 /// This class is fully conform to the \ref concepts::Graph
 /// "Graph" concept.
-template <typename _Graph>
+template <typename GR>
-class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<_Graph> > {
+class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {
 public:
-typedef EdgeSetExtender<SmartEdgeSetBase<_Graph> > Parent;
+typedef EdgeSetExtender<SmartEdgeSetBase<GR> > Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 typedef typename Parent::Edge Edge;
-typedef _Graph Graph;
+typedef GR Graph;
 protected:
 typedef typename Parent::NodesImplBase NodesImplBase;
 class NodesImpl : public NodesImplBase {
 public:
 typedef NodesImplBase Parent;
-NodesImpl(const Graph& graph, SmartEdgeSet& arcset)
+NodesImpl(const GR& graph, SmartEdgeSet& arcset)
 : Parent(graph), _arcset(arcset) {}
 virtual ~NodesImpl() {}
 bool attached() const {
 private:
 SmartEdgeSet& _arcset;
 };
-NodesImpl nodes;
+NodesImpl _nodes;
 public:
 /// \brief Constructor of the EdgeSet.
 ///
 /// Constructor of the EdgeSet.
-SmartEdgeSet(const Graph& graph) : nodes(graph, *this) {
+SmartEdgeSet(const GR& graph) : _nodes(graph, *this) {
-Parent::initalize(graph, nodes);
+Parent::initalize(graph, _nodes);
 }
 /// \brief Add a new edge to the graph.
 ///
 /// Add a new edge to the graph with node \c u
 ///
 /// This functions gives back false if the EdgeSet is
 /// invalidated. It occurs when a node in the underlying graph is
 /// erased and it is not isolated in the EdgeSet.
 bool valid() const {
-return nodes.attached();
+return _nodes.attached();
 }
 };
 }

changeset 543	e7eb04ece02c
parent 468	68fe66e2b34a
child 550	c5fd2d996909