Ticket #325: stl-iterators-V2-15af6cbd7751.patch

contrib/stlit_test/stlit_test.cc

@@ -4 +4 @@
 
 #include <iostream>
 #include <lemon/list_graph.h>
-#include <lemon/stl_iterators.h>
+#include <lemon/bits/stl_iterators.h>
 
 
 using namespace std;
@@ -21 +21 @@
 
 
 //  //for(ListDigraph::NodeIt u(g); u!=INVALID; ++u)
-//  for(auto u: g.nodeColl())
+//  for(auto u: g.nodes())
 //    cout<<g.id(u)<<endl;
 
 
@@ -30 +30 @@
   for(int k=0; k<100000; k++){
     int i=0;
     for(ListDigraph::NodeIt u(g); u!=INVALID; ++u){
-    //for(auto u: g.nodeColl()){
+    //for(auto u: g.nodes()){
       v[i]=u;
       i++;
     }
@@ -57 +57 @@
   for(int i=0; i<n; i++)
     g.addNode();
 
-  for(auto u: g.nodeColl())
+  for(auto u: g.nodes())
     cout<<g.id(u)<<endl;
 
-  //Test postincrement
-//  for(auto it=g.nodeColl().begin(); it!=g.nodeColl().end(); it++) {
-//    auto u=*it;
-//    cout<<g.id(u)<<endl;
-//  }
-
+  /*//Test postincrement
+  for(auto it=g.nodes().begin(); it!=g.nodes().end(); it++) {
+    auto u=*it;
+    cout<<g.id(u)<<endl;
+  }*/
 
 
   cout<<endl;
 
   vector<ListDigraph::Node> v1(n);
-  copy(g.nodeColl().begin(), g.nodeColl().end(), v1.begin());
+  copy(g.nodes().begin(), g.nodes().end(), v1.begin());
 
-  vector<ListDigraph::Node> v(g.nodeColl().begin(), g.nodeColl().end());
+  vector<ListDigraph::Node> v(g.nodes().begin(), g.nodes().end());
   g.addArc(v[0],v[1]);
   g.addArc(v[0],v[2]);
 
@@ -83 +82 @@
   cout<<endl;
 
 
-  ToStlit<ListDigraph::NodeIt> st1 = g.nodeColl().begin();
-  //auto st1 = g.nodeColl().begin();
+  LemonItWrapper<ListDigraph::NodeIt> st1 = g.nodes().begin();
+  //auto st1 = g.nodes().begin();
   auto st2 = st1; //test assignment
   ++st1; //test preincrement
   st1++; //test postincrement
@@ -94 +93 @@
 
   st1->operator==(st2);
 
+
+  ListGraph g2;
+  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;
+
   return 0;
 }

lemon/bits/graph_extender.h

@@ -27 +27 @@
 #include <lemon/concept_check.h>
 #include <lemon/concepts/maps.h>
 
-#include <lemon/stl_iterators.h>
+#include <lemon/bits/stl_iterators.h>
 
 //\ingroup graphbits
 //\file
@@ -118 +118 @@
 
     };
 
-    LemonitWrapper1<NodeIt, Digraph> nodeColl() {
-      return LemonitWrapper1<NodeIt, Digraph>(*this);
+    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
+      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
     }
 
+
     class ArcIt : public Arc {
       const Digraph* _digraph;
     public:
@@ -144 +145 @@
 
     };
 
+    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
+      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
+    }
+
 
     class OutArcIt : public Arc {
       const Digraph* _digraph;
@@ -168 +173 @@
 
     };
 
-    LemonitWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u){
-      return LemonitWrapper2<OutArcIt, Digraph, Node>(*this, u);
+    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
+      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
     }
 
 
@@ -196 +201 @@
 
     };
 
+    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
+      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
+    }
+
     // \brief Base node of the iterator
     //
     // Returns the base node (i.e. the source in this case) of the iterator
@@ -445 +454 @@
 
     };
 
+    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
+      return LemonRangeWrapper1<NodeIt, Graph>(*this);
+    }
+
 
     class ArcIt : public Arc {
       const Graph* _graph;
@@ -468 +481 @@
 
     };
 
+    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
+      return LemonRangeWrapper1<ArcIt, Graph>(*this);
+    }
+
 
     class OutArcIt : public Arc {
       const Graph* _graph;
@@ -492 +509 @@
 
     };
 
+    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
+      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
+    }
+
 
     class InArcIt : public Arc {
       const Graph* _graph;
@@ -516 +537 @@
 
     };
 
+    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
+      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
+    }
+
 
     class EdgeIt : public Parent::Edge {
       const Graph* _graph;
@@ -539 +564 @@
 
     };
 
+    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
+      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
+    }
+
+
     class IncEdgeIt : public Parent::Edge {
       friend class GraphExtender;
       const Graph* _graph;
@@ -564 +594 @@
       }
     };
 
+    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
+      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
+    }
+
+
     // \brief Base node of the iterator
     //
     // Returns the base node (ie. the source in this case) of the iterator

stl_iterators.h

@@ -1 +1 @@
 /* -*- mode: C++; indent-tabs-mode: nil; -*-
  */
 
-#ifndef LEMON_ITERATOR_WRAPPERS_H_
-#define LEMON_ITERATOR_WRAPPERS_H_
+#ifndef STL_ITERATORS_H_
+#define STL_ITERATORS_H_
 
 #include <lemon/core.h>
 
@@ -16 +16 @@
   /// (so that STL algorithms work).
   /// \c T should be the lemon iterator to be decorated.
   template<class T>
-  struct ToStlit
+  struct LemonItWrapper
       : public T, public std::iterator<std::input_iterator_tag, T> {
 
-    ToStlit(const T &x) : T(x) {}
+    LemonItWrapper(const T &x) : T(x) {}
 
     //Lemon iterators don't have operator*, (because they rather
     //inherit from their "value_type"),
     //so we add one that just returns the object.
     const T& operator*() const {
-      return *this;
+      return static_cast<const T&>(*this);
     }
 
     //I can't think of any use case for this with Lemon iterators,
     //but maybe it should be included for completeness.
-    T* operator->() {
-      return this;
+    const T* operator->() {
+      return static_cast<const T*>(this);
     }
 
     //Lemon iterators don't have postincrement.
     void operator++(int) {
       T::operator++();
     }
-    //We also have to redefine preincrement, because it disappeared
-    //when postincrement was defined.
-    T& operator++() {
-      return T::operator++();
-    }
+
+    using T::operator++;
 
   };
 
@@ -57 +54 @@
   /// \c LIT is the Lemon iterator that will be wrapped
   /// \c P is the type of the parameter of the constructor of \c LIT.
   template<class LIT, class P>
-  class LemonitWrapper1{
+  class LemonRangeWrapper1{
     const P &_p;
-    typedef ToStlit<LIT> It;
+    typedef LemonItWrapper<LIT> It;
   public:
-    LemonitWrapper1(const P &p) : _p(p) {}
+    LemonRangeWrapper1(const P &p) : _p(p) {}
     It begin() const {
       return It(LIT(_p));
     }
@@ -70 +67 @@
     }
   };
 
-  /*
-  /// \brief Gets the collection of nodes of a graph.
-  ///
-  /// This function can be used for iterating on
-  /// the nodes of a 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 you can write:
-  ///\code
-  /// ListDigraph g;
-  /// for(auto v: nodeColl(g))
-  ///   doSomething(v);
-  ///
-  /// //Using an STL algorithm:
-  /// copy(nodes(g).begin(), nodes(g).end(), vect);
-  ///\endcode
-  template<class GR>
-  LemonitWrapper1<typename GR::NodeIt, GR> nodeColl(const GR &g){
-    return LemonitWrapper1<typename GR::NodeIt, GR>(g);
-  }
-  */
 
   /// \brief A generic wrapper for Lemon iterators for range-based for loops.
   ///
@@ -103 +79 @@
   /// \c P1 and \c P2 are the types of the parameters
   /// of the constructor of \c LIT.
   template<class LIT, class P1, class P2>
-  class LemonitWrapper2{
+  class LemonRangeWrapper2{
     const P1 &_p1;
     const P2 &_p2;
-    typedef ToStlit<LIT> It;
+    typedef LemonItWrapper<LIT> It;
   public:
-    LemonitWrapper2(const P1 &p1, const P2 &p2) : _p1(p1), _p2(p2) {}
+    LemonRangeWrapper2(const P1 &p1, const P2 &p2) : _p1(p1), _p2(p2) {}
     It begin() const {
       return It(LIT(_p1, _p2));
     }
@@ -117 +93 @@
     }
   };
 
-  /*template<class GR>
-  LemonitWrapper2<typename GR::OutArcIt, GR, typename GR::Node>
-  outArcs(const GR &g, typename GR::Node n){
-    return LemonitWrapper2<typename GR::OutArcIt, GR, typename GR::Node>(g,n);
-  }*/
-
-
-
-
-
-
-/*
-  //This is a variadic template version of LemonitWrapper,
-  //to avoid having separate classes for 1 and 2 parameter versions.
-  //The drawback of this is that it would require a C++11 compiler.
-
-  #include <tuple>
-
-  template<class LIT, class... P>
-  class LemonitWrapper {
-    const std::tuple<const P&...> _p;
-    typedef ToStlit<LIT> It;
-
-    //This is based on http://stackoverflow.com/a/7858971/708357
-    template<int ...> struct Seq {};
-    template<int N, int ...S> struct Gens : Gens<N-1, N-1, S...> {};
-    template<int ...S> struct Gens<0, S...>{ typedef Seq<S...> Type; };
-    template<int ...S> It callConstr(Seq<S...>) const {
-      return LIT(std::get<S>(_p)...);
-    }
-  public:
-    LemonitWrapper(const P&... p) : _p(p...) {}
-
-    It begin() const {
-      return It(callConstr(typename Gens<sizeof...(P)>::Type()));
-    }
-    It end() const {
-      return It(lemon::INVALID);
-    }
-  };
-
-
-  template<class GR>
-  LemonitWrapper<typename GR::NodeIt, GR> nodes___var(const GR &g){
-    return LemonitWrapper<typename GR::NodeIt, GR>(g);
-  }
-
-  template<class GR>
-  LemonitWrapper<typename GR::OutArcIt, GR, typename GR::Node>
-  outArcs___var(const GR &g, typename GR::Node n){
-    return LemonitWrapper<typename GR::OutArcIt, GR, typename GR::Node>(g,n);
-  }
-*/
 
 }
 
-#endif /* LEMON_ITERATOR_WRAPPERS_H_ */
+#endif /* STL_ITERATORS_H_ */

lemon/concepts/digraph.h

@@ -27 +27 @@
 #include <lemon/concepts/maps.h>
 #include <lemon/concept_check.h>
 #include <lemon/concepts/graph_components.h>
-#include <lemon/stl_iterators.h>
+#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
   namespace concepts {
@@ -157 +157 @@
       /// For example you can write:
       ///\code
       /// ListDigraph g;
-      /// for(auto v: g.nodeColl())
+      /// for(auto v: g.nodes())
       ///   doSomething(v);
       ///
       /// //Using an STL algorithm:
-      /// copy(g.nodeColl().begin(), g.nodeColl().end(), vect.begin());
+      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
       ///\endcode
-      LemonitWrapper1<NodeIt, Digraph> nodeColl() {
-        return LemonitWrapper1<NodeIt, Digraph>(*this);
+      LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
+        return LemonRangeWrapper1<NodeIt, Digraph>(*this);
       }
 
 
@@ -257 +257 @@
         OutArcIt& operator++() { return *this; }
       };
 
-      LemonitWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u){
-        return LemonitWrapper2<OutArcIt, Digraph, Node>(*this, u);
+      /// \brief Gets the collection of the outgoing arcs of a certain node
+      /// of the digraph.
+      ///
+      /// This function can be used for iterating on the
+      /// outgoing arcs of a certain node of the digraph. 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 Digraph and u is a node, you can write:
+      ///\code
+      /// for(auto a: g.outArcs(u))
+      ///   doSomething(a);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
+        return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
       }
 
 
@@ -307 +323 @@
         InArcIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the incoming arcs of a certain node
+      /// of the digraph.
+      ///
+      /// This function can be used for iterating on the
+      /// incoming arcs of a certain node of the digraph. 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 Digraph and u is a node, you can write:
+      ///\code
+      /// for(auto a: g.inArcs(u))
+      ///   doSomething(a);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
+        return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
+      }
+
+
       /// Iterator class for the arcs.
 
       /// This iterator goes through each arc of the digraph.
@@ -352 +389 @@
         ArcIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the arcs of the digraph.
+      ///
+      /// This function can be used for iterating on the
+      /// arcs of the digraph. 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 you can write:
+      ///\code
+      /// ListDigraph g;
+      /// for(auto a: g.arcs())
+      ///   doSomething(a);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
+        return LemonRangeWrapper1<ArcIt, Digraph>(*this);
+      }
+
+
       /// \brief The source node of the arc.
       ///
       /// Returns the source node of the given arc.

lemon/concepts/graph.h

@@ -180 +180 @@
         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 you can write:
+      ///\code
+      /// ListGraph g;
+      /// for(auto v: g.nodes())
+      ///   doSomething(v);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper1<NodeIt, Graph> nodes() const {
+        return LemonRangeWrapper1<NodeIt, Graph>(*this);
+      }
+
 
       /// The edge type of the graph
 
@@ -268 +287 @@
         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 you can write:
+      ///\code
+      /// ListGraph g;
+      /// for(auto e: g.edges())
+      ///   doSomething(e);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.edges().begin(), g.edges().end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper1<EdgeIt, Graph> edges() const {
+        return LemonRangeWrapper1<EdgeIt, Graph>(*this);
+      }
+
+
       /// Iterator class for the incident edges of a node.
 
       /// This iterator goes trough the incident undirected edges
@@ -316 +356 @@
         IncEdgeIt& operator++() { return *this; }
       };
 
+      /// \brief Gets the collection of the incident undirected 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 Graph and u is a Node, you can write:
+      ///\code
+      /// for(auto e: g.incEdges(u))
+      ///   doSomething(e);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.incEdges(u).begin(), g.incEdges(u).end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
+        return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
+      }
+
+
       /// The arc type of the graph
 
       /// This class identifies a directed arc of the graph. It also serves
@@ -411 +473 @@
         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 you can write:
+      ///\code
+      /// ListGraph g;
+      /// for(auto a: g.arcs())
+      ///   doSomething(a);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper1<ArcIt, Graph> arcs() const {
+        return LemonRangeWrapper1<ArcIt, Graph>(*this);
+      }
+
+
       /// Iterator class for the outgoing arcs of a node.
 
       /// This iterator goes trough the \e outgoing directed arcs of a
@@ -459 +542 @@
         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 Graph and u is a Node, you can write:
+      ///\code
+      /// for(auto a: g.outArcs(u))
+      ///   doSomething(a);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
+        return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
+      }
+
+
       /// Iterator class for the incoming arcs of a node.
 
       /// This iterator goes trough the \e incoming directed arcs of a
@@ -507 +611 @@
         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 directed 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 Graph and u is a Node, you can write:
+      ///\code
+      /// for(auto a: g.inArcs(u))
+      ///   doSomething(a);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
+      ///\endcode
+      LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
+        return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
+      }
+
       /// \brief Standard graph map type for the nodes.
       ///
       /// Standard graph map type for the nodes.

lemon/list_graph.h

@@ -48 +48 @@
       int next_in, next_out;
     };
 
-    std::vector<NodeT> nodes;
+    std::vector<NodeT> _nodes;
 
     int first_node;
 
     int first_free_node;
 
-    std::vector<ArcT> arcs;
+    std::vector<ArcT> _arcs;
 
     int first_free_arc;
 
@@ -97 +97 @@
 
 
     ListDigraphBase()
-      : nodes(), first_node(-1),
-        first_free_node(-1), arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return nodes.size()-1; }
-    int maxArcId() const { return arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(arcs[e.id].source); }
-    Node target(Arc e) const { return Node(arcs[e.id].target); }
+      : _nodes(), first_node(-1),
+        first_free_node(-1), _arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return _nodes.size()-1; }
+    int maxArcId() const { return _arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(_arcs[e.id].source); }
+    Node target(Arc e) const { return Node(_arcs[e.id].target); }
 
 
     void first(Node& node) const {
@@ -113 +113 @@
     }
 
     void next(Node& node) const {
-      node.id = nodes[node.id].next;
+      node.id = _nodes[node.id].next;
     }
 
 
     void first(Arc& arc) const {
       int n;
       for(n = first_node;
-          n != -1 && nodes[n].first_out == -1;
-          n = nodes[n].next) {}
-      arc.id = (n == -1) ? -1 : nodes[n].first_out;
+          n != -1 && _nodes[n].first_out == -1;
+          n = _nodes[n].next) {}
+      arc.id = (n == -1) ? -1 : _nodes[n].first_out;
     }
 
     void next(Arc& arc) const {
-      if (arcs[arc.id].next_out != -1) {
-        arc.id = arcs[arc.id].next_out;
+      if (_arcs[arc.id].next_out != -1) {
+        arc.id = _arcs[arc.id].next_out;
       } else {
         int n;
-        for(n = nodes[arcs[arc.id].source].next;
-            n != -1 && nodes[n].first_out == -1;
-            n = nodes[n].next) {}
-        arc.id = (n == -1) ? -1 : nodes[n].first_out;
+        for(n = _nodes[_arcs[arc.id].source].next;
+            n != -1 && _nodes[n].first_out == -1;
+            n = _nodes[n].next) {}
+        arc.id = (n == -1) ? -1 : _nodes[n].first_out;
       }
     }
 
     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_in;
+      e.id = _nodes[v.id].first_in;
     }
     void nextIn(Arc &e) const {
-      e.id=arcs[e.id].next_in;
+      e.id=_arcs[e.id].next_in;
     }
 
 
@@ -159 +159 @@
     static Arc arcFromId(int id) { return Arc(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_in != -2;
+      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
+        _arcs[a.id].prev_in != -2;
     }
 
     Node addNode() {
       int n;
 
       if(first_free_node==-1) {
-        n = nodes.size();
-        nodes.push_back(NodeT());
+        n = _nodes.size();
+        _nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = nodes[n].next;
+        first_free_node = _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].first_in = nodes[n].first_out = -1;
+      _nodes[n].prev = -1;
+
+      _nodes[n].first_in = _nodes[n].first_out = -1;
 
       return Node(n);
     }
@@ -193 +193 @@
       int n;
 
       if (first_free_arc == -1) {
-        n = arcs.size();
-        arcs.push_back(ArcT());
+        n = _arcs.size();
+        _arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = arcs[n].next_in;
+        first_free_arc = _arcs[n].next_in;
       }
 
-      arcs[n].source = u.id;
-      arcs[n].target = v.id;
-
-      arcs[n].next_out = nodes[u.id].first_out;
-      if(nodes[u.id].first_out != -1) {
-        arcs[nodes[u.id].first_out].prev_out = n;
+      _arcs[n].source = u.id;
+      _arcs[n].target = v.id;
+
+      _arcs[n].next_out = _nodes[u.id].first_out;
+      if(_nodes[u.id].first_out != -1) {
+        _arcs[_nodes[u.id].first_out].prev_out = n;
       }
 
-      arcs[n].next_in = nodes[v.id].first_in;
-      if(nodes[v.id].first_in != -1) {
-        arcs[nodes[v.id].first_in].prev_in = n;
+      _arcs[n].next_in = _nodes[v.id].first_in;
+      if(_nodes[v.id].first_in != -1) {
+        _arcs[_nodes[v.id].first_in].prev_in = n;
       }
 
-      arcs[n].prev_in = arcs[n].prev_out = -1;
-
-      nodes[u.id].first_out = nodes[v.id].first_in = n;
+      _arcs[n].prev_in = _arcs[n].prev_out = -1;
+
+      _nodes[u.id].first_out = _nodes[v.id].first_in = n;
 
       return Arc(n);
     }
@@ -223 +223 @@
     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;
       }
 
-      nodes[n].next = first_free_node;
+      _nodes[n].next = first_free_node;
       first_free_node = n;
-      nodes[n].prev = -2;
+      _nodes[n].prev = -2;
 
     }
 
     void erase(const Arc& arc) {
       int n = arc.id;
 
-      if(arcs[n].next_in!=-1) {
-        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+      if(_arcs[n].next_in!=-1) {
+        _arcs[_arcs[n].next_in].prev_in = _arcs[n].prev_in;
       }
 
-      if(arcs[n].prev_in!=-1) {
-        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
+      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_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].source].first_out = arcs[n].next_out;
+        _nodes[_arcs[n].source].first_out = _arcs[n].next_out;
       }
 
-      arcs[n].next_in = first_free_arc;
+      _arcs[n].next_in = first_free_arc;
       first_free_arc = n;
-      arcs[n].prev_in = -2;
+      _arcs[n].prev_in = -2;
     }
 
     void clear() {
-      arcs.clear();
-      nodes.clear();
+      _arcs.clear();
+      _nodes.clear();
       first_node = first_free_node = first_free_arc = -1;
     }
 
   protected:
     void changeTarget(Arc e, Node n)
     {
-      if(arcs[e.id].next_in != -1)
-        arcs[arcs[e.id].next_in].prev_in = arcs[e.id].prev_in;
-      if(arcs[e.id].prev_in != -1)
-        arcs[arcs[e.id].prev_in].next_in = arcs[e.id].next_in;
-      else nodes[arcs[e.id].target].first_in = arcs[e.id].next_in;
-      if (nodes[n.id].first_in != -1) {
-        arcs[nodes[n.id].first_in].prev_in = e.id;
+      if(_arcs[e.id].next_in != -1)
+        _arcs[_arcs[e.id].next_in].prev_in = _arcs[e.id].prev_in;
+      if(_arcs[e.id].prev_in != -1)
+        _arcs[_arcs[e.id].prev_in].next_in = _arcs[e.id].next_in;
+      else _nodes[_arcs[e.id].target].first_in = _arcs[e.id].next_in;
+      if (_nodes[n.id].first_in != -1) {
+        _arcs[_nodes[n.id].first_in].prev_in = e.id;
       }
-      arcs[e.id].target = n.id;
-      arcs[e.id].prev_in = -1;
-      arcs[e.id].next_in = nodes[n.id].first_in;
-      nodes[n.id].first_in = e.id;
+      _arcs[e.id].target = n.id;
+      _arcs[e.id].prev_in = -1;
+      _arcs[e.id].next_in = _nodes[n.id].first_in;
+      _nodes[n.id].first_in = e.id;
     }
     void changeSource(Arc e, Node n)
     {
-      if(arcs[e.id].next_out != -1)
-        arcs[arcs[e.id].next_out].prev_out = arcs[e.id].prev_out;
-      if(arcs[e.id].prev_out != -1)
-        arcs[arcs[e.id].prev_out].next_out = arcs[e.id].next_out;
-      else nodes[arcs[e.id].source].first_out = arcs[e.id].next_out;
-      if (nodes[n.id].first_out != -1) {
-        arcs[nodes[n.id].first_out].prev_out = e.id;
+      if(_arcs[e.id].next_out != -1)
+        _arcs[_arcs[e.id].next_out].prev_out = _arcs[e.id].prev_out;
+      if(_arcs[e.id].prev_out != -1)
+        _arcs[_arcs[e.id].prev_out].next_out = _arcs[e.id].next_out;
+      else _nodes[_arcs[e.id].source].first_out = _arcs[e.id].next_out;
+      if (_nodes[n.id].first_out != -1) {
+        _arcs[_nodes[n.id].first_out].prev_out = e.id;
       }
-      arcs[e.id].source = n.id;
-      arcs[e.id].prev_out = -1;
-      arcs[e.id].next_out = nodes[n.id].first_out;
-      nodes[n.id].first_out = e.id;
+      _arcs[e.id].source = n.id;
+      _arcs[e.id].prev_out = -1;
+      _arcs[e.id].next_out = _nodes[n.id].first_out;
+      _nodes[n.id].first_out = e.id;
     }
 
   };
@@ -486 +486 @@
     ///Snapshot feature.
     Node split(Node n, bool connect = true) {
       Node b = addNode();
-      nodes[b.id].first_out=nodes[n.id].first_out;
-      nodes[n.id].first_out=-1;
-      for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
-        arcs[i].source=b.id;
+      _nodes[b.id].first_out=_nodes[n.id].first_out;
+      _nodes[n.id].first_out=-1;
+      for(int i=_nodes[b.id].first_out; i!=-1; i=_arcs[i].next_out) {
+        _arcs[i].source=b.id;
       }
       if (connect) addArc(n,b);
       return b;
@@ -532 +532 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the digraph.
     /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
+    void reserveNode(int n) { _nodes.reserve(n); };
 
     /// Reserve memory for arcs.
 
@@ -542 +542 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the digraph.
     /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
+    void reserveArc(int m) { _arcs.reserve(m); };
 
     /// \brief Class to make a snapshot of the digraph and restore
     /// it later.
@@ -803 +803 @@
       int prev_out, next_out;
     };
 
-    std::vector<NodeT> nodes;
+    std::vector<NodeT> _nodes;
 
     int first_node;
 
     int first_free_node;
 
-    std::vector<ArcT> arcs;
+    std::vector<ArcT> _arcs;
 
     int first_free_arc;
 
@@ -867 +867 @@
     };
 
     ListGraphBase()
-      : nodes(), first_node(-1),
-        first_free_node(-1), arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return nodes.size()-1; }
-    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); }
-
-    Node u(Edge e) const { return Node(arcs[2 * e.id].target); }
-    Node v(Edge e) const { return Node(arcs[2 * e.id + 1].target); }
+      : _nodes(), first_node(-1),
+        first_free_node(-1), _arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return _nodes.size()-1; }
+    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); }
+
+    Node u(Edge e) const { return Node(_arcs[2 * e.id].target); }
+    Node v(Edge e) const { return Node(_arcs[2 * e.id + 1].target); }
 
     static bool direction(Arc e) {
       return (e.id & 1) == 1;
@@ -894 +894 @@
     }
 
     void next(Node& node) const {
-      node.id = nodes[node.id].next;
+      node.id = _nodes[node.id].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);
@@ -985 +985 @@
       }
     }
     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);
@@ -1004 +1004 @@
     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;
     }
 
     Node addNode() {
       int n;
 
       if(first_free_node==-1) {
-        n = nodes.size();
-        nodes.push_back(NodeT());
+        n = _nodes.size();
+        _nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = nodes[n].next;
+        first_free_node = _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].first_out = -1;
+      _nodes[n].prev = -1;
+
+      _nodes[n].first_out = -1;
 
       return Node(n);
     }
@@ -1043 +1043 @@
       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);
     }
@@ -1074 +1074 @@
     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;
       }
 
-      nodes[n].next = first_free_node;
+      _nodes[n].next = first_free_node;
       first_free_node = 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_node = first_free_arc = -1;
     }
 
   protected:
 
     void changeV(Edge e, Node 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;
     }
 
     void changeU(Edge e, Node 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);
     }
 
   };
@@ -1344 +1344 @@
     /// 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.
 
@@ -1354 +1354 @@
     /// 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

@@ -47 +47 @@
       ArcT() {}
     };
 
-    std::vector<NodeT> nodes;
-    std::vector<ArcT> arcs;
+    std::vector<NodeT> _nodes;
+    std::vector<ArcT> _arcs;
 
   public:
 
@@ -59 +59 @@
 
   public:
 
-    SmartDigraphBase() : nodes(), arcs() { }
+    SmartDigraphBase() : _nodes(), _arcs() { }
     SmartDigraphBase(const SmartDigraphBase &_g)
-      : nodes(_g.nodes), arcs(_g.arcs) { }
+      : _nodes(_g._nodes), _arcs(_g._arcs) { }
 
     typedef True NodeNumTag;
     typedef True ArcNumTag;
 
-    int nodeNum() const { return nodes.size(); }
-    int arcNum() const { return arcs.size(); }
+    int nodeNum() const { return _nodes.size(); }
+    int arcNum() const { return _arcs.size(); }
 
-    int maxNodeId() const { return nodes.size()-1; }
-    int maxArcId() const { return arcs.size()-1; }
+    int maxNodeId() const { return _nodes.size()-1; }
+    int maxArcId() const { return _arcs.size()-1; }
 
     Node addNode() {
-      int n = nodes.size();
-      nodes.push_back(NodeT());
-      nodes[n].first_in = -1;
-      nodes[n].first_out = -1;
+      int n = _nodes.size();
+      _nodes.push_back(NodeT());
+      _nodes[n].first_in = -1;
+      _nodes[n].first_out = -1;
       return Node(n);
     }
 
     Arc addArc(Node u, Node v) {
-      int n = arcs.size();
-      arcs.push_back(ArcT());
-      arcs[n].source = u._id;
-      arcs[n].target = v._id;
-      arcs[n].next_out = nodes[u._id].first_out;
-      arcs[n].next_in = nodes[v._id].first_in;
-      nodes[u._id].first_out = nodes[v._id].first_in = n;
+      int n = _arcs.size();
+      _arcs.push_back(ArcT());
+      _arcs[n].source = u._id;
+      _arcs[n].target = v._id;
+      _arcs[n].next_out = _nodes[u._id].first_out;
+      _arcs[n].next_in = _nodes[v._id].first_in;
+      _nodes[u._id].first_out = _nodes[v._id].first_in = n;
 
       return Arc(n);
     }
 
     void clear() {
-      arcs.clear();
-      nodes.clear();
+      _arcs.clear();
+      _nodes.clear();
     }
 
-    Node source(Arc a) const { return Node(arcs[a._id].source); }
-    Node target(Arc a) const { return Node(arcs[a._id].target); }
+    Node source(Arc a) const { return Node(_arcs[a._id].source); }
+    Node target(Arc a) const { return Node(_arcs[a._id].target); }
 
     static int id(Node v) { return v._id; }
     static int id(Arc a) { return a._id; }
@@ -107 +107 @@
     static Arc arcFromId(int id) { return Arc(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());
     }
 
     class Node {
@@ -145 +145 @@
     };
 
     void first(Node& node) const {
-      node._id = nodes.size() - 1;
+      node._id = _nodes.size() - 1;
     }
 
     static void next(Node& node) {
@@ -153 +153 @@
     }
 
     void first(Arc& arc) const {
-      arc._id = arcs.size() - 1;
+      arc._id = _arcs.size() - 1;
     }
 
     static void next(Arc& arc) {
@@ -161 +161 @@
     }
 
     void firstOut(Arc& arc, const Node& node) const {
-      arc._id = nodes[node._id].first_out;
+      arc._id = _nodes[node._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& node) const {
-      arc._id = nodes[node._id].first_in;
+      arc._id = _nodes[node._id].first_in;
     }
 
     void nextIn(Arc& arc) const {
-      arc._id = arcs[arc._id].next_in;
+      arc._id = _arcs[arc._id].next_in;
     }
 
   };
@@ -266 +266 @@
     Node split(Node n, bool connect = true)
     {
       Node b = addNode();
-      nodes[b._id].first_out=nodes[n._id].first_out;
-      nodes[n._id].first_out=-1;
-      for(int i=nodes[b._id].first_out; i!=-1; i=arcs[i].next_out) {
-        arcs[i].source=b._id;
+      _nodes[b._id].first_out=_nodes[n._id].first_out;
+      _nodes[n._id].first_out=-1;
+      for(int i=_nodes[b._id].first_out; i!=-1; i=_arcs[i].next_out) {
+        _arcs[i].source=b._id;
       }
       if(connect) addArc(n,b);
       return b;
@@ -291 +291 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the digraph.
     /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
+    void reserveNode(int n) { _nodes.reserve(n); };
 
     /// Reserve memory for arcs.
 
@@ -301 +301 @@
     /// then it is worth reserving space for this amount before starting
     /// to build the digraph.
     /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
+    void reserveArc(int m) { _arcs.reserve(m); };
 
   public:
 
@@ -311 +311 @@
 
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<arcs.size()) {
-        Arc arc = arcFromId(arcs.size()-1);
+      while(s.arc_num<_arcs.size()) {
+        Arc arc = arcFromId(_arcs.size()-1);
         Parent::notifier(Arc()).erase(arc);
-        nodes[arcs.back().source].first_out=arcs.back().next_out;
-        nodes[arcs.back().target].first_in=arcs.back().next_in;
-        arcs.pop_back();
+        _nodes[_arcs.back().source].first_out=_arcs.back().next_out;
+        _nodes[_arcs.back().target].first_in=_arcs.back().next_in;
+        _arcs.pop_back();
       }
-      while(s.node_num<nodes.size()) {
-        Node node = nodeFromId(nodes.size()-1);
+      while(s.node_num<_nodes.size()) {
+        Node node = nodeFromId(_nodes.size()-1);
         Parent::notifier(Node()).erase(node);
-        nodes.pop_back();
+        _nodes.pop_back();
       }
     }
 
@@ -362 +362 @@
       ///This constructor immediately makes a snapshot of the given digraph.
       ///
       Snapshot(SmartDigraph &gr) : _graph(&gr) {
-        node_num=_graph->nodes.size();
-        arc_num=_graph->arcs.size();
+        node_num=_graph->_nodes.size();
+        arc_num=_graph->_arcs.size();
       }
 
       ///Make a snapshot.
@@ -373 +373 @@
       ///call, the previous snapshot gets lost.
       void save(SmartDigraph &gr) {
         _graph=&gr;
-        node_num=_graph->nodes.size();
-        arc_num=_graph->arcs.size();
+        node_num=_graph->_nodes.size();
+        arc_num=_graph->_arcs.size();
       }
 
       ///Undo the changes until a snapshot.
@@ -402 +402 @@
       int next_out;
     };
 
-    std::vector<NodeT> nodes;
-    std::vector<ArcT> arcs;
+    std::vector<NodeT> _nodes;
+    std::vector<ArcT> _arcs;
 
   public:
 
@@ -465 +465 @@
 
 
     SmartGraphBase()
-      : nodes(), arcs() {}
+      : _nodes(), _arcs() {}
 
     typedef True NodeNumTag;
     typedef True EdgeNumTag;
     typedef True ArcNumTag;
 
-    int nodeNum() const { return nodes.size(); }
-    int edgeNum() const { return arcs.size() / 2; }
-    int arcNum() const { return arcs.size(); }
+    int nodeNum() const { return _nodes.size(); }
+    int edgeNum() const { return _arcs.size() / 2; }
+    int arcNum() const { return _arcs.size(); }
 
-    int maxNodeId() const { return nodes.size()-1; }
-    int maxEdgeId() const { return arcs.size() / 2 - 1; }
-    int maxArcId() const { return arcs.size()-1; }
+    int maxNodeId() const { return _nodes.size()-1; }
+    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); }
+    Node source(Arc e) const { return Node(_arcs[e._id ^ 1].target); }
+    Node target(Arc e) const { return Node(_arcs[e._id].target); }
 
-    Node u(Edge e) const { return Node(arcs[2 * e._id].target); }
-    Node v(Edge e) const { return Node(arcs[2 * e._id + 1].target); }
+    Node u(Edge e) const { return Node(_arcs[2 * e._id].target); }
+    Node v(Edge e) const { return Node(_arcs[2 * e._id + 1].target); }
 
     static bool direction(Arc e) {
       return (e._id & 1) == 1;
@@ -494 +494 @@
     }
 
     void first(Node& node) const {
-      node._id = nodes.size() - 1;
+      node._id = _nodes.size() - 1;
     }
 
     static void next(Node& node) {
@@ -502 +502 @@
     }
 
     void first(Arc& arc) const {
-      arc._id = arcs.size() - 1;
+      arc._id = _arcs.size() - 1;
     }
 
     static void next(Arc& arc) {
@@ -510 +510 @@
     }
 
     void first(Edge& arc) const {
-      arc._id = arcs.size() / 2 - 1;
+      arc._id = _arcs.size() / 2 - 1;
     }
 
     static void next(Edge& arc) {
@@ -518 +518 @@
     }
 
     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);
@@ -544 +544 @@
       }
     }
     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);
@@ -563 +563 @@
     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());
     }
 
     Node addNode() {
-      int n = nodes.size();
-      nodes.push_back(NodeT());
-      nodes[n].first_out = -1;
+      int n = _nodes.size();
+      _nodes.push_back(NodeT());
+      _nodes[n].first_out = -1;
 
       return Node(n);
     }
 
     Edge addEdge(Node u, Node 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();
     }
 
   };
@@ -701 +701 @@
     /// 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.
 
@@ -711 +711 @@
     /// 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:
 
@@ -722 +722 @@
     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);
         Parent::notifier(Node()).erase(node);
-        nodes.pop_back();
+        _nodes.pop_back();
       }
     }