Ticket #325: stl-iterators-bipartite-7111be01ce58.patch

contrib/stlit_test/stlit_test.cc

@@ -3 +3 @@
 
 
 #include <iostream>
+#include <lemon/bits/stl_iterators.h>
 #include <lemon/list_graph.h>
-#include <lemon/bits/stl_iterators.h>
+#include <lemon/smart_graph.h>
 
 
 using namespace std;
@@ -72 +73 @@
   vector<ListDigraph::Node> v1(n);
   copy(g.nodes().begin(), g.nodes().end(), v1.begin());
 
-  vector<ListDigraph::Node> v(g.nodes().begin(), g.nodes().end());
-  g.addArc(v[0],v[1]);
-  g.addArc(v[0],v[2]);
+  vector<ListDigraph::Node> vect(g.nodes().begin(), g.nodes().end());
+  g.addArc(vect[0],vect[1]);
+  g.addArc(vect[0],vect[2]);
 
-  for(auto e: g.outArcs(v[0]))
+  for(auto e: g.outArcs(vect[0]))
     cout<<g.id(g.target(e))<<endl;
 
   cout<<endl;
@@ -94 +95 @@
   st1->operator==(st2);
 
 
-  ListGraph g2;
+  //ListGraph g2;
+  SmartGraph g2;
+  g2.addEdge(g2.addNode(), g2.addNode());
   for(auto u: g2.nodes())
     cout<<g2.id(u)<<endl;
   for(auto a: g2.outArcs(*g2.nodes().begin()))
     cout<<g2.id(g2.target(a))<<endl;
 
+  cout<<endl;
+
+  //ListBpGraph g3;
+  SmartBpGraph g3;
+  g3.addEdge(g3.addBlueNode(), g3.addRedNode());
+  for(auto u: g3.nodes()) {
+    for(auto e: g3.incEdges(u))
+      cout<<g3.id(g3.v(e))<<endl;
+    for(auto a: g3.outArcs(u))
+      cout<<g3.id(g3.target(a))<<endl;
+    for(auto a: g3.inArcs(u))
+      cout<<g3.id(g3.target(a))<<endl;
+  }
+  for(auto e: g3.edges())
+    cout<<g3.id(g3.u(e))<<endl;
+  for(auto a: g3.arcs())
+    cout<<g3.id(g3.target(a))<<endl;
+  for(auto u: g3.redNodes())
+    cout<<g3.id(u)<<endl;
+  for(auto u: g3.blueNodes())
+      cout<<g3.id(u)<<endl;
+
   return 0;
 }

lemon/bits/graph_extender.h

@@ -947 +947 @@
 
     };
 
+    LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
+      return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
+    }
+
+
     class RedNodeIt : public RedNode {
       const BpGraph* _graph;
     public:
@@ -969 +974 @@
 
     };
 
+    LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
+      return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
+    }
+
+
     class BlueNodeIt : public BlueNode {
       const BpGraph* _graph;
     public:
@@ -991 +1001 @@
 
     };
 
+    LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
+      return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
+    }
+
+
 
     class ArcIt : public Arc {
       const BpGraph* _graph;
@@ -1014 +1029 @@
 
     };
 
+    LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
+      return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
+    }
+
 
     class OutArcIt : public Arc {
       const BpGraph* _graph;
@@ -1038 +1057 @@
 
     };
 
+    LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
+      return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
+    }
+
 
     class InArcIt : public Arc {
       const BpGraph* _graph;
@@ -1062 +1085 @@
 
     };
 
+    LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
+      return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
+    }
+
 
     class EdgeIt : public Parent::Edge {
       const BpGraph* _graph;
@@ -1085 +1112 @@
 
     };
 
+    LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
+      return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
+    }
+
+
     class IncEdgeIt : public Parent::Edge {
       friend class BpGraphExtender;
       const BpGraph* _graph;
@@ -1110 +1142 @@
       }
     };
 
+    LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
+      return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
+    }
+
+
     // \brief Base node of the iterator
     //
     // Returns the base node (ie. the source in this case) of the iterator

lemon/concepts/bpgraph.h

@@ -221 +221 @@
         RedNodeIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the red nodes of the graph.
+      ///
+      /// This function can be used for iterating on
+      /// the red nodes of the graph. It returns a wrapped RedNodeIt,
+      /// which looks like an STL container (by having begin() and end())
+      /// which you can use in range-based for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph, you can write:
+      ///\code
+      /// for(auto v: g.redNodes())
+      ///   doSomething(v);
+      ///\endcode
+      LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
+        return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
+      }
+
+
       /// Iterator class for the blue nodes.
 
       /// This iterator goes through each blue node of the graph.
@@ -264 +280 @@
         BlueNodeIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the blue nodes of the graph.
+      ///
+      /// This function can be used for iterating on
+      /// the blue nodes of the graph. It returns a wrapped BlueNodeIt,
+      /// which looks like an STL container (by having begin() and end())
+      /// which you can use in range-based for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph, you can write:
+      ///\code
+      /// for(auto v: g.blueNodes())
+      ///   doSomething(v);
+      ///\endcode
+      LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
+        return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
+      }
+
+
       /// Iterator class for the nodes.
 
       /// This iterator goes through each node of the graph.
@@ -307 +339 @@
         NodeIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the nodes of the graph.
+      ///
+      /// This function can be used for iterating on
+      /// the nodes of the graph. It returns a wrapped NodeIt,
+      /// which looks like an STL container (by having begin() and end())
+      /// which you can use in range-based for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph, you can write:
+      ///\code
+      /// for(auto v: g.nodes())
+      ///   doSomething(v);
+      ///\endcode
+      LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
+        return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
+      }
+
+
 
       /// The edge type of the graph
 
@@ -395 +443 @@
         EdgeIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the edges of the graph.
+      ///
+      /// This function can be used for iterating on the
+      /// edges of the graph. It returns a wrapped
+      /// EdgeIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph, you can write:
+      ///\code
+      /// for(auto e: g.edges())
+      ///   doSomething(e);
+      ///\endcode
+      LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
+        return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
+      }
+
+
       /// Iterator class for the incident edges of a node.
 
       /// This iterator goes trough the incident undirected edges
@@ -443 +508 @@
         IncEdgeIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the incident edges
+      ///  of a certain node of the graph.
+      ///
+      /// This function can be used for iterating on the
+      /// incident undirected edges of a certain node of the graph.
+      /// It returns a wrapped
+      /// IncEdgeIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph and u is a Node, you can write:
+      ///\code
+      /// for(auto e: g.incEdges(u))
+      ///   doSomething(e);
+      ///\endcode
+      LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
+        return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
+      }
+
+
       /// The arc type of the graph
 
       /// This class identifies a directed arc of the graph. It also serves
@@ -539 +623 @@
         ArcIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the directed arcs of the graph.
+      ///
+      /// This function can be used for iterating on the
+      /// arcs of the graph. It returns a wrapped
+      /// ArcIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph you can write:
+      ///\code
+      /// for(auto a: g.arcs())
+      ///   doSomething(a);
+      ///\endcode
+      LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
+        return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
+      }
+
+
       /// Iterator class for the outgoing arcs of a node.
 
       /// This iterator goes trough the \e outgoing directed arcs of a
@@ -587 +688 @@
         OutArcIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the outgoing directed arcs of a
+      /// certain node of the graph.
+      ///
+      /// This function can be used for iterating on the
+      /// outgoing arcs of a certain node of the graph. It returns a wrapped
+      /// OutArcIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph and u is a Node, you can write:
+      ///\code
+      /// for(auto a: g.outArcs(u))
+      ///   doSomething(a);
+      ///\endcode
+      LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
+        return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
+      }
+
+
       /// Iterator class for the incoming arcs of a node.
 
       /// This iterator goes trough the \e incoming directed arcs of a
@@ -635 +754 @@
         InArcIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the incoming directed arcs of a
+      /// certain node of the graph.
+      ///
+      /// This function can be used for iterating on the
+      /// incoming arcs of a certain node of the graph. It returns a wrapped
+      /// InArcIt, which looks like an STL container
+      /// (by having begin() and end()) which you can use in range-based
+      /// for loops, stl algorithms, etc.
+      /// For example if g is a BpGraph and u is a Node, you can write:
+      ///\code
+      /// for(auto a: g.inArcs(u))
+      ///   doSomething(a);
+      ///\endcode
+      LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
+        return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
+      }
+
+
       /// \brief Standard graph map type for the nodes.
       ///
       /// Standard graph map type for the nodes.

lemon/list_graph.h

@@ -1617 +1617 @@
       int prev_out, next_out;
     };
 
-    std::vector<NodeT> nodes;
+    std::vector<NodeT> _nodes;
 
     int first_node, first_red, first_blue;
     int max_red, max_blue;
 
     int first_free_red, first_free_blue;
 
-    std::vector<ArcT> arcs;
+    std::vector<ArcT> _arcs;
 
     int first_free_arc;
 
@@ -1706 +1706 @@
     };
 
     ListBpGraphBase()
-      : nodes(), first_node(-1),
+      : _nodes(), first_node(-1),
         first_red(-1), first_blue(-1),
         max_red(-1), max_blue(-1),
         first_free_red(-1), first_free_blue(-1),
-        arcs(), first_free_arc(-1) {}
-
-
-    bool red(Node n) const { return nodes[n.id].red; }
-    bool blue(Node n) const { return !nodes[n.id].red; }
+        _arcs(), first_free_arc(-1) {}
+
+
+    bool red(Node n) const { return _nodes[n.id].red; }
+    bool blue(Node n) const { return !_nodes[n.id].red; }
 
     static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
     static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
 
-    int maxNodeId() const { return nodes.size()-1; }
+    int maxNodeId() const { return _nodes.size()-1; }
     int maxRedId() const { return max_red; }
     int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return arcs.size() / 2 - 1; }
-    int maxArcId() const { return arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(arcs[e.id].target); }
+    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
+    int maxArcId() const { return _arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
+    Node target(Arc e) const { return Node(_arcs[e.id].target); }
 
     RedNode redNode(Edge e) const {
-      return RedNode(arcs[2 * e.id].target);
+      return RedNode(_arcs[2 * e.id].target);
     }
     BlueNode blueNode(Edge e) const {
-      return BlueNode(arcs[2 * e.id + 1].target);
+      return BlueNode(_arcs[2 * e.id + 1].target);
     }
 
     static bool direction(Arc e) {
@@ -1748 +1748 @@
     }
 
     void next(Node& node) const {
-      node.id = nodes[node.id].next;
+      node.id = _nodes[node.id].next;
     }
 
     void first(RedNode& node) const {
@@ -1756 +1756 @@
     }
 
     void next(RedNode& node) const {
-      node.id = nodes[node.id].partition_next;
+      node.id = _nodes[node.id].partition_next;
     }
 
     void first(BlueNode& node) const {
@@ -1764 +1764 @@
     }
 
     void next(BlueNode& node) const {
-      node.id = nodes[node.id].partition_next;
+      node.id = _nodes[node.id].partition_next;
     }
 
     void first(Arc& e) const {
       int n = first_node;
-      while (n != -1 && nodes[n].first_out == -1) {
-        n = nodes[n].next;
+      while (n != -1 && _nodes[n].first_out == -1) {
+        n = _nodes[n].next;
       }
-      e.id = (n == -1) ? -1 : nodes[n].first_out;
+      e.id = (n == -1) ? -1 : _nodes[n].first_out;
     }
 
     void next(Arc& e) const {
-      if (arcs[e.id].next_out != -1) {
-        e.id = arcs[e.id].next_out;
+      if (_arcs[e.id].next_out != -1) {
+        e.id = _arcs[e.id].next_out;
       } else {
-        int n = nodes[arcs[e.id ^ 1].target].next;
-        while(n != -1 && nodes[n].first_out == -1) {
-          n = nodes[n].next;
+        int n = _nodes[_arcs[e.id ^ 1].target].next;
+        while(n != -1 && _nodes[n].first_out == -1) {
+          n = _nodes[n].next;
         }
-        e.id = (n == -1) ? -1 : nodes[n].first_out;
+        e.id = (n == -1) ? -1 : _nodes[n].first_out;
       }
     }
 
     void first(Edge& e) const {
       int n = first_node;
       while (n != -1) {
-        e.id = nodes[n].first_out;
+        e.id = _nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = arcs[e.id].next_out;
+          e.id = _arcs[e.id].next_out;
         }
         if (e.id != -1) {
           e.id /= 2;
           return;
         }
-        n = nodes[n].next;
+        n = _nodes[n].next;
       }
       e.id = -1;
     }
 
     void next(Edge& e) const {
-      int n = arcs[e.id * 2].target;
-      e.id = arcs[(e.id * 2) | 1].next_out;
+      int n = _arcs[e.id * 2].target;
+      e.id = _arcs[(e.id * 2) | 1].next_out;
       while ((e.id & 1) != 1) {
-        e.id = arcs[e.id].next_out;
+        e.id = _arcs[e.id].next_out;
       }
       if (e.id != -1) {
         e.id /= 2;
         return;
       }
-      n = nodes[n].next;
+      n = _nodes[n].next;
       while (n != -1) {
-        e.id = nodes[n].first_out;
+        e.id = _nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = arcs[e.id].next_out;
+          e.id = _arcs[e.id].next_out;
         }
         if (e.id != -1) {
           e.id /= 2;
           return;
         }
-        n = nodes[n].next;
+        n = _nodes[n].next;
       }
       e.id = -1;
     }
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = nodes[v.id].first_out;
+      e.id = _nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id = arcs[e.id].next_out;
+      e.id = _arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = ((nodes[v.id].first_out) ^ 1);
+      e.id = ((_nodes[v.id].first_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
     void nextIn(Arc &e) const {
-      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
+      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
 
     void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = nodes[v.id].first_out;
+      int a = _nodes[v.id].first_out;
       if (a != -1 ) {
         e.id = a / 2;
         d = ((a & 1) == 1);
@@ -1855 +1855 @@
       }
     }
     void nextInc(Edge &e, bool& d) const {
-      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
+      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
       if (a != -1 ) {
         e.id = a / 2;
         d = ((a & 1) == 1);
@@ -1866 +1866 @@
     }
 
     static int id(Node v) { return v.id; }
-    int id(RedNode v) const { return nodes[v.id].partition_index; }
-    int id(BlueNode v) const { return nodes[v.id].partition_index; }
+    int id(RedNode v) const { return _nodes[v.id].partition_index; }
+    int id(BlueNode v) const { return _nodes[v.id].partition_index; }
     static int id(Arc e) { return e.id; }
     static int id(Edge e) { return e.id; }
 
@@ -1876 +1876 @@
     static Edge edgeFromId(int id) { return Edge(id);}
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
-        nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
+        _nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
-        arcs[a.id].prev_out != -2;
+      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
+        _arcs[a.id].prev_out != -2;
     }
 
     bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
-        arcs[2 * e.id].prev_out != -2;
+      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
+        _arcs[2 * e.id].prev_out != -2;
     }
 
     RedNode addRedNode() {
       int n;
 
       if(first_free_red==-1) {
-        n = nodes.size();
-        nodes.push_back(NodeT());
-        nodes[n].partition_index = ++max_red;
-        nodes[n].red = true;
+        n = _nodes.size();
+        _nodes.push_back(NodeT());
+        _nodes[n].partition_index = ++max_red;
+        _nodes[n].red = true;
       } else {
         n = first_free_red;
-        first_free_red = nodes[n].next;
+        first_free_red = _nodes[n].next;
       }
 
-      nodes[n].next = first_node;
-      if (first_node != -1) nodes[first_node].prev = n;
+      _nodes[n].next = first_node;
+      if (first_node != -1) _nodes[first_node].prev = n;
       first_node = n;
-      nodes[n].prev = -1;
-
-      nodes[n].partition_next = first_red;
-      if (first_red != -1) nodes[first_red].partition_prev = n;
+      _nodes[n].prev = -1;
+
+      _nodes[n].partition_next = first_red;
+      if (first_red != -1) _nodes[first_red].partition_prev = n;
       first_red = n;
-      nodes[n].partition_prev = -1;
-
-      nodes[n].first_out = -1;
+      _nodes[n].partition_prev = -1;
+
+      _nodes[n].first_out = -1;
 
       return RedNode(n);
     }
@@ -1922 +1922 @@
       int n;
 
       if(first_free_blue==-1) {
-        n = nodes.size();
-        nodes.push_back(NodeT());
-        nodes[n].partition_index = ++max_blue;
-        nodes[n].red = false;
+        n = _nodes.size();
+        _nodes.push_back(NodeT());
+        _nodes[n].partition_index = ++max_blue;
+        _nodes[n].red = false;
       } else {
         n = first_free_blue;
-        first_free_blue = nodes[n].next;
+        first_free_blue = _nodes[n].next;
       }
 
-      nodes[n].next = first_node;
-      if (first_node != -1) nodes[first_node].prev = n;
+      _nodes[n].next = first_node;
+      if (first_node != -1) _nodes[first_node].prev = n;
       first_node = n;
-      nodes[n].prev = -1;
-
-      nodes[n].partition_next = first_blue;
-      if (first_blue != -1) nodes[first_blue].partition_prev = n;
+      _nodes[n].prev = -1;
+
+      _nodes[n].partition_next = first_blue;
+      if (first_blue != -1) _nodes[first_blue].partition_prev = n;
       first_blue = n;
-      nodes[n].partition_prev = -1;
-
-      nodes[n].first_out = -1;
+      _nodes[n].partition_prev = -1;
+
+      _nodes[n].first_out = -1;
 
       return BlueNode(n);
     }
@@ -1950 +1950 @@
       int n;
 
       if (first_free_arc == -1) {
-        n = arcs.size();
-        arcs.push_back(ArcT());
-        arcs.push_back(ArcT());
+        n = _arcs.size();
+        _arcs.push_back(ArcT());
+        _arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = arcs[n].next_out;
+        first_free_arc = _arcs[n].next_out;
       }
 
-      arcs[n].target = u.id;
-      arcs[n | 1].target = v.id;
-
-      arcs[n].next_out = nodes[v.id].first_out;
-      if (nodes[v.id].first_out != -1) {
-        arcs[nodes[v.id].first_out].prev_out = n;
+      _arcs[n].target = u.id;
+      _arcs[n | 1].target = v.id;
+
+      _arcs[n].next_out = _nodes[v.id].first_out;
+      if (_nodes[v.id].first_out != -1) {
+        _arcs[_nodes[v.id].first_out].prev_out = n;
       }
-      arcs[n].prev_out = -1;
-      nodes[v.id].first_out = n;
-
-      arcs[n | 1].next_out = nodes[u.id].first_out;
-      if (nodes[u.id].first_out != -1) {
-        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+      _arcs[n].prev_out = -1;
+      _nodes[v.id].first_out = n;
+
+      _arcs[n | 1].next_out = _nodes[u.id].first_out;
+      if (_nodes[u.id].first_out != -1) {
+        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
       }
-      arcs[n | 1].prev_out = -1;
-      nodes[u.id].first_out = (n | 1);
+      _arcs[n | 1].prev_out = -1;
+      _nodes[u.id].first_out = (n | 1);
 
       return Edge(n / 2);
     }
@@ -1981 +1981 @@
     void erase(const Node& node) {
       int n = node.id;
 
-      if(nodes[n].next != -1) {
-        nodes[nodes[n].next].prev = nodes[n].prev;
+      if(_nodes[n].next != -1) {
+        _nodes[_nodes[n].next].prev = _nodes[n].prev;
       }
 
-      if(nodes[n].prev != -1) {
-        nodes[nodes[n].prev].next = nodes[n].next;
+      if(_nodes[n].prev != -1) {
+        _nodes[_nodes[n].prev].next = _nodes[n].next;
       } else {
-        first_node = nodes[n].next;
+        first_node = _nodes[n].next;
       }
 
-      if (nodes[n].partition_next != -1) {
-        nodes[nodes[n].partition_next].partition_prev = nodes[n].partition_prev;
+      if (_nodes[n].partition_next != -1) {
+        _nodes[_nodes[n].partition_next].partition_prev = _nodes[n].partition_prev;
       }
 
-      if (nodes[n].partition_prev != -1) {
-        nodes[nodes[n].partition_prev].partition_next = nodes[n].partition_next;
+      if (_nodes[n].partition_prev != -1) {
+        _nodes[_nodes[n].partition_prev].partition_next = _nodes[n].partition_next;
       } else {
-        if (nodes[n].red) {
-          first_red = nodes[n].partition_next;
+        if (_nodes[n].red) {
+          first_red = _nodes[n].partition_next;
         } else {
-          first_blue = nodes[n].partition_next;
+          first_blue = _nodes[n].partition_next;
         }
       }
 
-      if (nodes[n].red) {
-        nodes[n].next = first_free_red;
+      if (_nodes[n].red) {
+        _nodes[n].next = first_free_red;
         first_free_red = n;
       } else {
-        nodes[n].next = first_free_blue;
+        _nodes[n].next = first_free_blue;
         first_free_blue = n;
       }
-      nodes[n].prev = -2;
+      _nodes[n].prev = -2;
     }
 
     void erase(const Edge& edge) {
       int n = edge.id * 2;
 
-      if (arcs[n].next_out != -1) {
-        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      if (_arcs[n].next_out != -1) {
+        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
       }
 
-      if (arcs[n].prev_out != -1) {
-        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
+      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].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;
+      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;
+      _arcs[n].next_out = first_free_arc;
       first_free_arc = n;
-      arcs[n].prev_out = -2;
-      arcs[n | 1].prev_out = -2;
+      _arcs[n].prev_out = -2;
+      _arcs[n | 1].prev_out = -2;
 
     }
 
     void clear() {
-      arcs.clear();
-      nodes.clear();
+      _arcs.clear();
+      _nodes.clear();
       first_node = first_free_arc = first_red = first_blue =
         max_red = max_blue = first_free_red = first_free_blue = -1;
     }
@@ -2055 +2055 @@
   protected:
 
     void changeRed(Edge e, RedNode n) {
-      if(arcs[(2 * e.id) | 1].next_out != -1) {
-        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
-          arcs[(2 * e.id) | 1].prev_out;
+      if(_arcs[(2 * e.id) | 1].next_out != -1) {
+        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
+          _arcs[(2 * e.id) | 1].prev_out;
       }
-      if(arcs[(2 * e.id) | 1].prev_out != -1) {
-        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
-          arcs[(2 * e.id) | 1].next_out;
+      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
+        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
+          _arcs[(2 * e.id) | 1].next_out;
       } else {
-        nodes[arcs[2 * e.id].target].first_out =
-          arcs[(2 * e.id) | 1].next_out;
+        _nodes[_arcs[2 * e.id].target].first_out =
+          _arcs[(2 * e.id) | 1].next_out;
       }
 
-      if (nodes[n.id].first_out != -1) {
-        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+      if (_nodes[n.id].first_out != -1) {
+        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
       }
-      arcs[2 * e.id].target = n.id;
-      arcs[(2 * e.id) | 1].prev_out = -1;
-      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
-      nodes[n.id].first_out = ((2 * e.id) | 1);
+      _arcs[2 * e.id].target = n.id;
+      _arcs[(2 * e.id) | 1].prev_out = -1;
+      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
+      _nodes[n.id].first_out = ((2 * e.id) | 1);
     }
 
     void changeBlue(Edge e, BlueNode n) {
-       if(arcs[2 * e.id].next_out != -1) {
-        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+       if(_arcs[2 * e.id].next_out != -1) {
+        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
       }
-      if(arcs[2 * e.id].prev_out != -1) {
-        arcs[arcs[2 * e.id].prev_out].next_out =
-          arcs[2 * e.id].next_out;
+      if(_arcs[2 * e.id].prev_out != -1) {
+        _arcs[_arcs[2 * e.id].prev_out].next_out =
+          _arcs[2 * e.id].next_out;
       } else {
-        nodes[arcs[(2 * e.id) | 1].target].first_out =
-          arcs[2 * e.id].next_out;
+        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
+          _arcs[2 * e.id].next_out;
       }
 
-      if (nodes[n.id].first_out != -1) {
-        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+      if (_nodes[n.id].first_out != -1) {
+        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
       }
-      arcs[(2 * e.id) | 1].target = n.id;
-      arcs[2 * e.id].prev_out = -1;
-      arcs[2 * e.id].next_out = nodes[n.id].first_out;
-      nodes[n.id].first_out = 2 * e.id;
+      _arcs[(2 * e.id) | 1].target = n.id;
+      _arcs[2 * e.id].prev_out = -1;
+      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
+      _nodes[n.id].first_out = 2 * e.id;
     }
 
   };
@@ -2249 +2249 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
+    void reserveNode(int n) { _nodes.reserve(n); };
 
     /// Reserve memory for edges.
 
@@ -2259 +2259 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
+    void reserveEdge(int m) { _arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
     /// it later.

lemon/smart_graph.h

@@ -825 +825 @@
       int next_out;
     };
 
-    std::vector<NodeT> nodes;
-    std::vector<ArcT> arcs;
+    std::vector<NodeT> _nodes;
+    std::vector<ArcT> _arcs;
 
     int first_red, first_blue;
     int max_red, max_blue;
@@ -915 +915 @@
 
 
     SmartBpGraphBase()
-      : nodes(), arcs(), first_red(-1), first_blue(-1),
+      : _nodes(), _arcs(), first_red(-1), first_blue(-1),
         max_red(-1), max_blue(-1) {}
 
     typedef True NodeNumTag;
     typedef True EdgeNumTag;
     typedef True ArcNumTag;
 
-    int nodeNum() const { return nodes.size(); }
+    int nodeNum() const { return _nodes.size(); }
     int redNum() const { return max_red + 1; }
     int blueNum() const { return max_blue + 1; }
-    int edgeNum() const { return arcs.size() / 2; }
-    int arcNum() const { return arcs.size(); }
+    int edgeNum() const { return _arcs.size() / 2; }
+    int arcNum() const { return _arcs.size(); }
 
-    int maxNodeId() const { return nodes.size()-1; }
+    int maxNodeId() const { return _nodes.size()-1; }
     int maxRedId() const { return max_red; }
     int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return arcs.size() / 2 - 1; }
-    int maxArcId() const { return arcs.size()-1; }
+    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
+    int maxArcId() const { return _arcs.size()-1; }
 
-    bool red(Node n) const { return nodes[n._id].red; }
-    bool blue(Node n) const { return !nodes[n._id].red; }
+    bool red(Node n) const { return _nodes[n._id].red; }
+    bool blue(Node n) const { return !_nodes[n._id].red; }
 
     static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
     static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
 
-    Node source(Arc a) const { return Node(arcs[a._id ^ 1].target); }
-    Node target(Arc a) const { return Node(arcs[a._id].target); }
+    Node source(Arc a) const { return Node(_arcs[a._id ^ 1].target); }
+    Node target(Arc a) const { return Node(_arcs[a._id].target); }
 
     RedNode redNode(Edge e) const {
-      return RedNode(arcs[2 * e._id].target);
+      return RedNode(_arcs[2 * e._id].target);
     }
     BlueNode blueNode(Edge e) const {
-      return BlueNode(arcs[2 * e._id + 1].target);
+      return BlueNode(_arcs[2 * e._id + 1].target);
     }
 
     static bool direction(Arc a) {
@@ -959 +959 @@
     }
 
     void first(Node& node) const {
-      node._id = nodes.size() - 1;
+      node._id = _nodes.size() - 1;
     }
 
     static void next(Node& node) {
@@ -971 +971 @@
     }
 
     void next(RedNode& node) const {
-      node._id = nodes[node._id].partition_next;
+      node._id = _nodes[node._id].partition_next;
     }
 
     void first(BlueNode& node) const {
@@ -979 +979 @@
     }
 
     void next(BlueNode& node) const {
-      node._id = nodes[node._id].partition_next;
+      node._id = _nodes[node._id].partition_next;
     }
 
     void first(Arc& arc) const {
-      arc._id = arcs.size() - 1;
+      arc._id = _arcs.size() - 1;
     }
 
     static void next(Arc& arc) {
@@ -991 +991 @@
     }
 
     void first(Edge& arc) const {
-      arc._id = arcs.size() / 2 - 1;
+      arc._id = _arcs.size() / 2 - 1;
     }
 
     static void next(Edge& arc) {
@@ -999 +999 @@
     }
 
     void firstOut(Arc &arc, const Node& v) const {
-      arc._id = nodes[v._id].first_out;
+      arc._id = _nodes[v._id].first_out;
     }
     void nextOut(Arc &arc) const {
-      arc._id = arcs[arc._id].next_out;
+      arc._id = _arcs[arc._id].next_out;
     }
 
     void firstIn(Arc &arc, const Node& v) const {
-      arc._id = ((nodes[v._id].first_out) ^ 1);
+      arc._id = ((_nodes[v._id].first_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
     void nextIn(Arc &arc) const {
-      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
+      arc._id = ((_arcs[arc._id ^ 1].next_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
 
     void firstInc(Edge &arc, bool& d, const Node& v) const {
-      int de = nodes[v._id].first_out;
+      int de = _nodes[v._id].first_out;
       if (de != -1) {
         arc._id = de / 2;
         d = ((de & 1) == 1);
@@ -1025 +1025 @@
       }
     }
     void nextInc(Edge &arc, bool& d) const {
-      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
+      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
       if (de != -1) {
         arc._id = de / 2;
         d = ((de & 1) == 1);
@@ -1036 +1036 @@
     }
 
     static int id(Node v) { return v._id; }
-    int id(RedNode v) const { return nodes[v._id].partition_index; }
-    int id(BlueNode v) const { return nodes[v._id].partition_index; }
+    int id(RedNode v) const { return _nodes[v._id].partition_index; }
+    int id(BlueNode v) const { return _nodes[v._id].partition_index; }
     static int id(Arc e) { return e._id; }
     static int id(Edge e) { return e._id; }
 
@@ -1046 +1046 @@
     static Edge edgeFromId(int id) { return Edge(id);}
 
     bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
+      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
     }
     bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
+      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
     }
     bool valid(Edge e) const {
-      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
+      return e._id >= 0 && 2 * e._id < static_cast<int>(_arcs.size());
     }
 
     RedNode addRedNode() {
-      int n = nodes.size();
-      nodes.push_back(NodeT());
-      nodes[n].first_out = -1;
-      nodes[n].red = true;
-      nodes[n].partition_index = ++max_red;
-      nodes[n].partition_next = first_red;
+      int n = _nodes.size();
+      _nodes.push_back(NodeT());
+      _nodes[n].first_out = -1;
+      _nodes[n].red = true;
+      _nodes[n].partition_index = ++max_red;
+      _nodes[n].partition_next = first_red;
       first_red = n;
 
       return RedNode(n);
     }
 
     BlueNode addBlueNode() {
-      int n = nodes.size();
-      nodes.push_back(NodeT());
-      nodes[n].first_out = -1;
-      nodes[n].red = false;
-      nodes[n].partition_index = ++max_blue;
-      nodes[n].partition_next = first_blue;
+      int n = _nodes.size();
+      _nodes.push_back(NodeT());
+      _nodes[n].first_out = -1;
+      _nodes[n].red = false;
+      _nodes[n].partition_index = ++max_blue;
+      _nodes[n].partition_next = first_blue;
       first_blue = n;
 
       return BlueNode(n);
     }
 
     Edge addEdge(RedNode u, BlueNode v) {
-      int n = arcs.size();
-      arcs.push_back(ArcT());
-      arcs.push_back(ArcT());
+      int n = _arcs.size();
+      _arcs.push_back(ArcT());
+      _arcs.push_back(ArcT());
 
-      arcs[n].target = u._id;
-      arcs[n | 1].target = v._id;
+      _arcs[n].target = u._id;
+      _arcs[n | 1].target = v._id;
 
-      arcs[n].next_out = nodes[v._id].first_out;
-      nodes[v._id].first_out = n;
+      _arcs[n].next_out = _nodes[v._id].first_out;
+      _nodes[v._id].first_out = n;
 
-      arcs[n | 1].next_out = nodes[u._id].first_out;
-      nodes[u._id].first_out = (n | 1);
+      _arcs[n | 1].next_out = _nodes[u._id].first_out;
+      _nodes[u._id].first_out = (n | 1);
 
       return Edge(n / 2);
     }
 
     void clear() {
-      arcs.clear();
-      nodes.clear();
+      _arcs.clear();
+      _nodes.clear();
       first_red = -1;
       first_blue = -1;
       max_blue = -1;
@@ -1213 +1213 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
+    void reserveNode(int n) { _nodes.reserve(n); };
 
     /// Reserve memory for edges.
 
@@ -1223 +1223 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
+    void reserveEdge(int m) { _arcs.reserve(2 * m); };
 
   public:
 
@@ -1234 +1234 @@
     void saveSnapshot(Snapshot &s)
     {
       s._graph = this;
-      s.node_num = nodes.size();
-      s.arc_num = arcs.size();
+      s.node_num = _nodes.size();
+      s.arc_num = _arcs.size();
     }
 
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<arcs.size()) {
-        int n=arcs.size()-1;
+      while(s.arc_num<_arcs.size()) {
+        int n=_arcs.size()-1;
         Edge arc=edgeFromId(n/2);
         Parent::notifier(Edge()).erase(arc);
         std::vector<Arc> dir;
         dir.push_back(arcFromId(n));
         dir.push_back(arcFromId(n-1));
         Parent::notifier(Arc()).erase(dir);
-        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
-        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
-        arcs.pop_back();
-        arcs.pop_back();
+        _nodes[_arcs[n-1].target].first_out=_arcs[n].next_out;
+        _nodes[_arcs[n].target].first_out=_arcs[n-1].next_out;
+        _arcs.pop_back();
+        _arcs.pop_back();
       }
-      while(s.node_num<nodes.size()) {
-        int n=nodes.size()-1;
+      while(s.node_num<_nodes.size()) {
+        int n=_nodes.size()-1;
         Node node = nodeFromId(n);
         if (Parent::red(node)) {
-          first_red = nodes[n].partition_next;
+          first_red = _nodes[n].partition_next;
           if (first_red != -1) {
-            max_red = nodes[first_red].partition_index;
+            max_red = _nodes[first_red].partition_index;
           } else {
             max_red = -1;
           }
           Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));
         } else {
-          first_blue = nodes[n].partition_next;
+          first_blue = _nodes[n].partition_next;
           if (first_blue != -1) {
-            max_blue = nodes[first_blue].partition_index;
+            max_blue = _nodes[first_blue].partition_index;
           } else {
             max_blue = -1;
           }
           Parent::notifier(BlueNode()).erase(asBlueNodeUnsafe(node));
         }
         Parent::notifier(Node()).erase(node);
-        nodes.pop_back();
+        _nodes.pop_back();
       }
     }