COIN-OR::LEMON - Graph Library

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

File stl-iterators-bipartite-7111be01ce58.patch, 39.2 KB (added by Gábor Gévay, 7 years ago)
  • contrib/stlit_test/stlit_test.cc

    # HG changeset patch
    # User Gabor Gevay <ggab90@gmail.com>
    # Date 1390004235 -3600
    #      Sat Jan 18 01:17:15 2014 +0100
    # Node ID 7111be01ce588ac18d555c061a7b551ba470ab39
    # Parent  15af6cbd77513ccf5ebcff573c1275858c6dd166
    STL style iterators for bipartite graphs.
    
    diff --git a/contrib/stlit_test/stlit_test.cc b/contrib/stlit_test/stlit_test.cc
    a b  
    33
    44
    55#include <iostream>
     6#include <lemon/bits/stl_iterators.h>
    67#include <lemon/list_graph.h>
    7 #include <lemon/bits/stl_iterators.h>
     8#include <lemon/smart_graph.h>
    89
    910
    1011using namespace std;
     
    7273  vector<ListDigraph::Node> v1(n);
    7374  copy(g.nodes().begin(), g.nodes().end(), v1.begin());
    7475
    75   vector<ListDigraph::Node> v(g.nodes().begin(), g.nodes().end());
    76   g.addArc(v[0],v[1]);
    77   g.addArc(v[0],v[2]);
     76  vector<ListDigraph::Node> vect(g.nodes().begin(), g.nodes().end());
     77  g.addArc(vect[0],vect[1]);
     78  g.addArc(vect[0],vect[2]);
    7879
    79   for(auto e: g.outArcs(v[0]))
     80  for(auto e: g.outArcs(vect[0]))
    8081    cout<<g.id(g.target(e))<<endl;
    8182
    8283  cout<<endl;
     
    9495  st1->operator==(st2);
    9596
    9697
    97   ListGraph g2;
     98  //ListGraph g2;
     99  SmartGraph g2;
     100  g2.addEdge(g2.addNode(), g2.addNode());
    98101  for(auto u: g2.nodes())
    99102    cout<<g2.id(u)<<endl;
    100103  for(auto a: g2.outArcs(*g2.nodes().begin()))
    101104    cout<<g2.id(g2.target(a))<<endl;
    102105
     106  cout<<endl;
     107
     108  //ListBpGraph g3;
     109  SmartBpGraph g3;
     110  g3.addEdge(g3.addBlueNode(), g3.addRedNode());
     111  for(auto u: g3.nodes()) {
     112    for(auto e: g3.incEdges(u))
     113      cout<<g3.id(g3.v(e))<<endl;
     114    for(auto a: g3.outArcs(u))
     115      cout<<g3.id(g3.target(a))<<endl;
     116    for(auto a: g3.inArcs(u))
     117      cout<<g3.id(g3.target(a))<<endl;
     118  }
     119  for(auto e: g3.edges())
     120    cout<<g3.id(g3.u(e))<<endl;
     121  for(auto a: g3.arcs())
     122    cout<<g3.id(g3.target(a))<<endl;
     123  for(auto u: g3.redNodes())
     124    cout<<g3.id(u)<<endl;
     125  for(auto u: g3.blueNodes())
     126      cout<<g3.id(u)<<endl;
     127
    103128  return 0;
    104129}
  • lemon/bits/graph_extender.h

    diff --git a/lemon/bits/graph_extender.h b/lemon/bits/graph_extender.h
    a b  
    947947
    948948    };
    949949
     950    LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
     951      return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
     952    }
     953
     954
    950955    class RedNodeIt : public RedNode {
    951956      const BpGraph* _graph;
    952957    public:
     
    969974
    970975    };
    971976
     977    LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
     978      return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
     979    }
     980
     981
    972982    class BlueNodeIt : public BlueNode {
    973983      const BpGraph* _graph;
    974984    public:
     
    9911001
    9921002    };
    9931003
     1004    LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
     1005      return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
     1006    }
     1007
     1008
    9941009
    9951010    class ArcIt : public Arc {
    9961011      const BpGraph* _graph;
     
    10141029
    10151030    };
    10161031
     1032    LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
     1033      return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
     1034    }
     1035
    10171036
    10181037    class OutArcIt : public Arc {
    10191038      const BpGraph* _graph;
     
    10381057
    10391058    };
    10401059
     1060    LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
     1061      return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
     1062    }
     1063
    10411064
    10421065    class InArcIt : public Arc {
    10431066      const BpGraph* _graph;
     
    10621085
    10631086    };
    10641087
     1088    LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
     1089      return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
     1090    }
     1091
    10651092
    10661093    class EdgeIt : public Parent::Edge {
    10671094      const BpGraph* _graph;
     
    10851112
    10861113    };
    10871114
     1115    LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
     1116      return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
     1117    }
     1118
     1119
    10881120    class IncEdgeIt : public Parent::Edge {
    10891121      friend class BpGraphExtender;
    10901122      const BpGraph* _graph;
     
    11101142      }
    11111143    };
    11121144
     1145    LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
     1146      return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
     1147    }
     1148
     1149
    11131150    // \brief Base node of the iterator
    11141151    //
    11151152    // Returns the base node (ie. the source in this case) of the iterator
  • lemon/concepts/bpgraph.h

    diff --git a/lemon/concepts/bpgraph.h b/lemon/concepts/bpgraph.h
    a b  
    221221        RedNodeIt& operator++() { return *this; }
    222222      };
    223223
     224      /// \brief Gets the collection of the red nodes of the graph.
     225      ///
     226      /// This function can be used for iterating on
     227      /// the red nodes of the graph. It returns a wrapped RedNodeIt,
     228      /// which looks like an STL container (by having begin() and end())
     229      /// which you can use in range-based for loops, stl algorithms, etc.
     230      /// For example if g is a BpGraph, you can write:
     231      ///\code
     232      /// for(auto v: g.redNodes())
     233      ///   doSomething(v);
     234      ///\endcode
     235      LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
     236        return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
     237      }
     238
     239
    224240      /// Iterator class for the blue nodes.
    225241
    226242      /// This iterator goes through each blue node of the graph.
     
    264280        BlueNodeIt& operator++() { return *this; }
    265281      };
    266282
     283      /// \brief Gets the collection of the blue nodes of the graph.
     284      ///
     285      /// This function can be used for iterating on
     286      /// the blue nodes of the graph. It returns a wrapped BlueNodeIt,
     287      /// which looks like an STL container (by having begin() and end())
     288      /// which you can use in range-based for loops, stl algorithms, etc.
     289      /// For example if g is a BpGraph, you can write:
     290      ///\code
     291      /// for(auto v: g.blueNodes())
     292      ///   doSomething(v);
     293      ///\endcode
     294      LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
     295        return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
     296      }
     297
     298
    267299      /// Iterator class for the nodes.
    268300
    269301      /// This iterator goes through each node of the graph.
     
    307339        NodeIt& operator++() { return *this; }
    308340      };
    309341
     342      /// \brief Gets the collection of the nodes of the graph.
     343      ///
     344      /// This function can be used for iterating on
     345      /// the nodes of the graph. It returns a wrapped NodeIt,
     346      /// which looks like an STL container (by having begin() and end())
     347      /// which you can use in range-based for loops, stl algorithms, etc.
     348      /// For example if g is a BpGraph, you can write:
     349      ///\code
     350      /// for(auto v: g.nodes())
     351      ///   doSomething(v);
     352      ///\endcode
     353      LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
     354        return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
     355      }
     356
     357
    310358
    311359      /// The edge type of the graph
    312360
     
    395443        EdgeIt& operator++() { return *this; }
    396444      };
    397445
     446      /// \brief Gets the collection of the edges of the graph.
     447      ///
     448      /// This function can be used for iterating on the
     449      /// edges of the graph. It returns a wrapped
     450      /// EdgeIt, which looks like an STL container
     451      /// (by having begin() and end()) which you can use in range-based
     452      /// for loops, stl algorithms, etc.
     453      /// For example if g is a BpGraph, you can write:
     454      ///\code
     455      /// for(auto e: g.edges())
     456      ///   doSomething(e);
     457      ///\endcode
     458      LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
     459        return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
     460      }
     461
     462
    398463      /// Iterator class for the incident edges of a node.
    399464
    400465      /// This iterator goes trough the incident undirected edges
     
    443508        IncEdgeIt& operator++() { return *this; }
    444509      };
    445510
     511      /// \brief Gets the collection of the incident edges
     512      ///  of a certain node of the graph.
     513      ///
     514      /// This function can be used for iterating on the
     515      /// incident undirected edges of a certain node of the graph.
     516      /// It returns a wrapped
     517      /// IncEdgeIt, which looks like an STL container
     518      /// (by having begin() and end()) which you can use in range-based
     519      /// for loops, stl algorithms, etc.
     520      /// For example if g is a BpGraph and u is a Node, you can write:
     521      ///\code
     522      /// for(auto e: g.incEdges(u))
     523      ///   doSomething(e);
     524      ///\endcode
     525      LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
     526        return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
     527      }
     528
     529
    446530      /// The arc type of the graph
    447531
    448532      /// This class identifies a directed arc of the graph. It also serves
     
    539623        ArcIt& operator++() { return *this; }
    540624      };
    541625
     626      /// \brief Gets the collection of the directed arcs of the graph.
     627      ///
     628      /// This function can be used for iterating on the
     629      /// arcs of the graph. It returns a wrapped
     630      /// ArcIt, which looks like an STL container
     631      /// (by having begin() and end()) which you can use in range-based
     632      /// for loops, stl algorithms, etc.
     633      /// For example if g is a BpGraph you can write:
     634      ///\code
     635      /// for(auto a: g.arcs())
     636      ///   doSomething(a);
     637      ///\endcode
     638      LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
     639        return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
     640      }
     641
     642
    542643      /// Iterator class for the outgoing arcs of a node.
    543644
    544645      /// This iterator goes trough the \e outgoing directed arcs of a
     
    587688        OutArcIt& operator++() { return *this; }
    588689      };
    589690
     691      /// \brief Gets the collection of the outgoing directed arcs of a
     692      /// certain node of the graph.
     693      ///
     694      /// This function can be used for iterating on the
     695      /// outgoing arcs of a certain node of the graph. It returns a wrapped
     696      /// OutArcIt, which looks like an STL container
     697      /// (by having begin() and end()) which you can use in range-based
     698      /// for loops, stl algorithms, etc.
     699      /// For example if g is a BpGraph and u is a Node, you can write:
     700      ///\code
     701      /// for(auto a: g.outArcs(u))
     702      ///   doSomething(a);
     703      ///\endcode
     704      LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
     705        return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
     706      }
     707
     708
    590709      /// Iterator class for the incoming arcs of a node.
    591710
    592711      /// This iterator goes trough the \e incoming directed arcs of a
     
    635754        InArcIt& operator++() { return *this; }
    636755      };
    637756
     757      /// \brief Gets the collection of the incoming directed arcs of a
     758      /// certain node of the graph.
     759      ///
     760      /// This function can be used for iterating on the
     761      /// incoming arcs of a certain node of the graph. It returns a wrapped
     762      /// InArcIt, which looks like an STL container
     763      /// (by having begin() and end()) which you can use in range-based
     764      /// for loops, stl algorithms, etc.
     765      /// For example if g is a BpGraph and u is a Node, you can write:
     766      ///\code
     767      /// for(auto a: g.inArcs(u))
     768      ///   doSomething(a);
     769      ///\endcode
     770      LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
     771        return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
     772      }
     773
     774
    638775      /// \brief Standard graph map type for the nodes.
    639776      ///
    640777      /// Standard graph map type for the nodes.
  • lemon/list_graph.h

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    16171617      int prev_out, next_out;
    16181618    };
    16191619
    1620     std::vector<NodeT> nodes;
     1620    std::vector<NodeT> _nodes;
    16211621
    16221622    int first_node, first_red, first_blue;
    16231623    int max_red, max_blue;
    16241624
    16251625    int first_free_red, first_free_blue;
    16261626
    1627     std::vector<ArcT> arcs;
     1627    std::vector<ArcT> _arcs;
    16281628
    16291629    int first_free_arc;
    16301630
     
    17061706    };
    17071707
    17081708    ListBpGraphBase()
    1709       : nodes(), first_node(-1),
     1709      : _nodes(), first_node(-1),
    17101710        first_red(-1), first_blue(-1),
    17111711        max_red(-1), max_blue(-1),
    17121712        first_free_red(-1), first_free_blue(-1),
    1713         arcs(), first_free_arc(-1) {}
    1714 
    1715 
    1716     bool red(Node n) const { return nodes[n.id].red; }
    1717     bool blue(Node n) const { return !nodes[n.id].red; }
     1713        _arcs(), first_free_arc(-1) {}
     1714
     1715
     1716    bool red(Node n) const { return _nodes[n.id].red; }
     1717    bool blue(Node n) const { return !_nodes[n.id].red; }
    17181718
    17191719    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
    17201720    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
    17211721
    1722     int maxNodeId() const { return nodes.size()-1; }
     1722    int maxNodeId() const { return _nodes.size()-1; }
    17231723    int maxRedId() const { return max_red; }
    17241724    int maxBlueId() const { return max_blue; }
    1725     int maxEdgeId() const { return arcs.size() / 2 - 1; }
    1726     int maxArcId() const { return arcs.size()-1; }
    1727 
    1728     Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
    1729     Node target(Arc e) const { return Node(arcs[e.id].target); }
     1725    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
     1726    int maxArcId() const { return _arcs.size()-1; }
     1727
     1728    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
     1729    Node target(Arc e) const { return Node(_arcs[e.id].target); }
    17301730
    17311731    RedNode redNode(Edge e) const {
    1732       return RedNode(arcs[2 * e.id].target);
     1732      return RedNode(_arcs[2 * e.id].target);
    17331733    }
    17341734    BlueNode blueNode(Edge e) const {
    1735       return BlueNode(arcs[2 * e.id + 1].target);
     1735      return BlueNode(_arcs[2 * e.id + 1].target);
    17361736    }
    17371737
    17381738    static bool direction(Arc e) {
     
    17481748    }
    17491749
    17501750    void next(Node& node) const {
    1751       node.id = nodes[node.id].next;
     1751      node.id = _nodes[node.id].next;
    17521752    }
    17531753
    17541754    void first(RedNode& node) const {
     
    17561756    }
    17571757
    17581758    void next(RedNode& node) const {
    1759       node.id = nodes[node.id].partition_next;
     1759      node.id = _nodes[node.id].partition_next;
    17601760    }
    17611761
    17621762    void first(BlueNode& node) const {
     
    17641764    }
    17651765
    17661766    void next(BlueNode& node) const {
    1767       node.id = nodes[node.id].partition_next;
     1767      node.id = _nodes[node.id].partition_next;
    17681768    }
    17691769
    17701770    void first(Arc& e) const {
    17711771      int n = first_node;
    1772       while (n != -1 && nodes[n].first_out == -1) {
    1773         n = nodes[n].next;
     1772      while (n != -1 && _nodes[n].first_out == -1) {
     1773        n = _nodes[n].next;
    17741774      }
    1775       e.id = (n == -1) ? -1 : nodes[n].first_out;
     1775      e.id = (n == -1) ? -1 : _nodes[n].first_out;
    17761776    }
    17771777
    17781778    void next(Arc& e) const {
    1779       if (arcs[e.id].next_out != -1) {
    1780         e.id = arcs[e.id].next_out;
     1779      if (_arcs[e.id].next_out != -1) {
     1780        e.id = _arcs[e.id].next_out;
    17811781      } else {
    1782         int n = nodes[arcs[e.id ^ 1].target].next;
    1783         while(n != -1 && nodes[n].first_out == -1) {
    1784           n = nodes[n].next;
     1782        int n = _nodes[_arcs[e.id ^ 1].target].next;
     1783        while(n != -1 && _nodes[n].first_out == -1) {
     1784          n = _nodes[n].next;
    17851785        }
    1786         e.id = (n == -1) ? -1 : nodes[n].first_out;
     1786        e.id = (n == -1) ? -1 : _nodes[n].first_out;
    17871787      }
    17881788    }
    17891789
    17901790    void first(Edge& e) const {
    17911791      int n = first_node;
    17921792      while (n != -1) {
    1793         e.id = nodes[n].first_out;
     1793        e.id = _nodes[n].first_out;
    17941794        while ((e.id & 1) != 1) {
    1795           e.id = arcs[e.id].next_out;
     1795          e.id = _arcs[e.id].next_out;
    17961796        }
    17971797        if (e.id != -1) {
    17981798          e.id /= 2;
    17991799          return;
    18001800        }
    1801         n = nodes[n].next;
     1801        n = _nodes[n].next;
    18021802      }
    18031803      e.id = -1;
    18041804    }
    18051805
    18061806    void next(Edge& e) const {
    1807       int n = arcs[e.id * 2].target;
    1808       e.id = arcs[(e.id * 2) | 1].next_out;
     1807      int n = _arcs[e.id * 2].target;
     1808      e.id = _arcs[(e.id * 2) | 1].next_out;
    18091809      while ((e.id & 1) != 1) {
    1810         e.id = arcs[e.id].next_out;
     1810        e.id = _arcs[e.id].next_out;
    18111811      }
    18121812      if (e.id != -1) {
    18131813        e.id /= 2;
    18141814        return;
    18151815      }
    1816       n = nodes[n].next;
     1816      n = _nodes[n].next;
    18171817      while (n != -1) {
    1818         e.id = nodes[n].first_out;
     1818        e.id = _nodes[n].first_out;
    18191819        while ((e.id & 1) != 1) {
    1820           e.id = arcs[e.id].next_out;
     1820          e.id = _arcs[e.id].next_out;
    18211821        }
    18221822        if (e.id != -1) {
    18231823          e.id /= 2;
    18241824          return;
    18251825        }
    1826         n = nodes[n].next;
     1826        n = _nodes[n].next;
    18271827      }
    18281828      e.id = -1;
    18291829    }
    18301830
    18311831    void firstOut(Arc &e, const Node& v) const {
    1832       e.id = nodes[v.id].first_out;
     1832      e.id = _nodes[v.id].first_out;
    18331833    }
    18341834    void nextOut(Arc &e) const {
    1835       e.id = arcs[e.id].next_out;
     1835      e.id = _arcs[e.id].next_out;
    18361836    }
    18371837
    18381838    void firstIn(Arc &e, const Node& v) const {
    1839       e.id = ((nodes[v.id].first_out) ^ 1);
     1839      e.id = ((_nodes[v.id].first_out) ^ 1);
    18401840      if (e.id == -2) e.id = -1;
    18411841    }
    18421842    void nextIn(Arc &e) const {
    1843       e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
     1843      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
    18441844      if (e.id == -2) e.id = -1;
    18451845    }
    18461846
    18471847    void firstInc(Edge &e, bool& d, const Node& v) const {
    1848       int a = nodes[v.id].first_out;
     1848      int a = _nodes[v.id].first_out;
    18491849      if (a != -1 ) {
    18501850        e.id = a / 2;
    18511851        d = ((a & 1) == 1);
     
    18551855      }
    18561856    }
    18571857    void nextInc(Edge &e, bool& d) const {
    1858       int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
     1858      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
    18591859      if (a != -1 ) {
    18601860        e.id = a / 2;
    18611861        d = ((a & 1) == 1);
     
    18661866    }
    18671867
    18681868    static int id(Node v) { return v.id; }
    1869     int id(RedNode v) const { return nodes[v.id].partition_index; }
    1870     int id(BlueNode v) const { return nodes[v.id].partition_index; }
     1869    int id(RedNode v) const { return _nodes[v.id].partition_index; }
     1870    int id(BlueNode v) const { return _nodes[v.id].partition_index; }
    18711871    static int id(Arc e) { return e.id; }
    18721872    static int id(Edge e) { return e.id; }
    18731873
     
    18761876    static Edge edgeFromId(int id) { return Edge(id);}
    18771877
    18781878    bool valid(Node n) const {
    1879       return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
    1880         nodes[n.id].prev != -2;
     1879      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
     1880        _nodes[n.id].prev != -2;
    18811881    }
    18821882
    18831883    bool valid(Arc a) const {
    1884       return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
    1885         arcs[a.id].prev_out != -2;
     1884      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
     1885        _arcs[a.id].prev_out != -2;
    18861886    }
    18871887
    18881888    bool valid(Edge e) const {
    1889       return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
    1890         arcs[2 * e.id].prev_out != -2;
     1889      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
     1890        _arcs[2 * e.id].prev_out != -2;
    18911891    }
    18921892
    18931893    RedNode addRedNode() {
    18941894      int n;
    18951895
    18961896      if(first_free_red==-1) {
    1897         n = nodes.size();
    1898         nodes.push_back(NodeT());
    1899         nodes[n].partition_index = ++max_red;
    1900         nodes[n].red = true;
     1897        n = _nodes.size();
     1898        _nodes.push_back(NodeT());
     1899        _nodes[n].partition_index = ++max_red;
     1900        _nodes[n].red = true;
    19011901      } else {
    19021902        n = first_free_red;
    1903         first_free_red = nodes[n].next;
     1903        first_free_red = _nodes[n].next;
    19041904      }
    19051905
    1906       nodes[n].next = first_node;
    1907       if (first_node != -1) nodes[first_node].prev = n;
     1906      _nodes[n].next = first_node;
     1907      if (first_node != -1) _nodes[first_node].prev = n;
    19081908      first_node = n;
    1909       nodes[n].prev = -1;
    1910 
    1911       nodes[n].partition_next = first_red;
    1912       if (first_red != -1) nodes[first_red].partition_prev = n;
     1909      _nodes[n].prev = -1;
     1910
     1911      _nodes[n].partition_next = first_red;
     1912      if (first_red != -1) _nodes[first_red].partition_prev = n;
    19131913      first_red = n;
    1914       nodes[n].partition_prev = -1;
    1915 
    1916       nodes[n].first_out = -1;
     1914      _nodes[n].partition_prev = -1;
     1915
     1916      _nodes[n].first_out = -1;
    19171917
    19181918      return RedNode(n);
    19191919    }
     
    19221922      int n;
    19231923
    19241924      if(first_free_blue==-1) {
    1925         n = nodes.size();
    1926         nodes.push_back(NodeT());
    1927         nodes[n].partition_index = ++max_blue;
    1928         nodes[n].red = false;
     1925        n = _nodes.size();
     1926        _nodes.push_back(NodeT());
     1927        _nodes[n].partition_index = ++max_blue;
     1928        _nodes[n].red = false;
    19291929      } else {
    19301930        n = first_free_blue;
    1931         first_free_blue = nodes[n].next;
     1931        first_free_blue = _nodes[n].next;
    19321932      }
    19331933
    1934       nodes[n].next = first_node;
    1935       if (first_node != -1) nodes[first_node].prev = n;
     1934      _nodes[n].next = first_node;
     1935      if (first_node != -1) _nodes[first_node].prev = n;
    19361936      first_node = n;
    1937       nodes[n].prev = -1;
    1938 
    1939       nodes[n].partition_next = first_blue;
    1940       if (first_blue != -1) nodes[first_blue].partition_prev = n;
     1937      _nodes[n].prev = -1;
     1938
     1939      _nodes[n].partition_next = first_blue;
     1940      if (first_blue != -1) _nodes[first_blue].partition_prev = n;
    19411941      first_blue = n;
    1942       nodes[n].partition_prev = -1;
    1943 
    1944       nodes[n].first_out = -1;
     1942      _nodes[n].partition_prev = -1;
     1943
     1944      _nodes[n].first_out = -1;
    19451945
    19461946      return BlueNode(n);
    19471947    }
     
    19501950      int n;
    19511951
    19521952      if (first_free_arc == -1) {
    1953         n = arcs.size();
    1954         arcs.push_back(ArcT());
    1955         arcs.push_back(ArcT());
     1953        n = _arcs.size();
     1954        _arcs.push_back(ArcT());
     1955        _arcs.push_back(ArcT());
    19561956      } else {
    19571957        n = first_free_arc;
    1958         first_free_arc = arcs[n].next_out;
     1958        first_free_arc = _arcs[n].next_out;
    19591959      }
    19601960
    1961       arcs[n].target = u.id;
    1962       arcs[n | 1].target = v.id;
    1963 
    1964       arcs[n].next_out = nodes[v.id].first_out;
    1965       if (nodes[v.id].first_out != -1) {
    1966         arcs[nodes[v.id].first_out].prev_out = n;
     1961      _arcs[n].target = u.id;
     1962      _arcs[n | 1].target = v.id;
     1963
     1964      _arcs[n].next_out = _nodes[v.id].first_out;
     1965      if (_nodes[v.id].first_out != -1) {
     1966        _arcs[_nodes[v.id].first_out].prev_out = n;
    19671967      }
    1968       arcs[n].prev_out = -1;
    1969       nodes[v.id].first_out = n;
    1970 
    1971       arcs[n | 1].next_out = nodes[u.id].first_out;
    1972       if (nodes[u.id].first_out != -1) {
    1973         arcs[nodes[u.id].first_out].prev_out = (n | 1);
     1968      _arcs[n].prev_out = -1;
     1969      _nodes[v.id].first_out = n;
     1970
     1971      _arcs[n | 1].next_out = _nodes[u.id].first_out;
     1972      if (_nodes[u.id].first_out != -1) {
     1973        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
    19741974      }
    1975       arcs[n | 1].prev_out = -1;
    1976       nodes[u.id].first_out = (n | 1);
     1975      _arcs[n | 1].prev_out = -1;
     1976      _nodes[u.id].first_out = (n | 1);
    19771977
    19781978      return Edge(n / 2);
    19791979    }
     
    19811981    void erase(const Node& node) {
    19821982      int n = node.id;
    19831983
    1984       if(nodes[n].next != -1) {
    1985         nodes[nodes[n].next].prev = nodes[n].prev;
     1984      if(_nodes[n].next != -1) {
     1985        _nodes[_nodes[n].next].prev = _nodes[n].prev;
    19861986      }
    19871987
    1988       if(nodes[n].prev != -1) {
    1989         nodes[nodes[n].prev].next = nodes[n].next;
     1988      if(_nodes[n].prev != -1) {
     1989        _nodes[_nodes[n].prev].next = _nodes[n].next;
    19901990      } else {
    1991         first_node = nodes[n].next;
     1991        first_node = _nodes[n].next;
    19921992      }
    19931993
    1994       if (nodes[n].partition_next != -1) {
    1995         nodes[nodes[n].partition_next].partition_prev = nodes[n].partition_prev;
     1994      if (_nodes[n].partition_next != -1) {
     1995        _nodes[_nodes[n].partition_next].partition_prev = _nodes[n].partition_prev;
    19961996      }
    19971997
    1998       if (nodes[n].partition_prev != -1) {
    1999         nodes[nodes[n].partition_prev].partition_next = nodes[n].partition_next;
     1998      if (_nodes[n].partition_prev != -1) {
     1999        _nodes[_nodes[n].partition_prev].partition_next = _nodes[n].partition_next;
    20002000      } else {
    2001         if (nodes[n].red) {
    2002           first_red = nodes[n].partition_next;
     2001        if (_nodes[n].red) {
     2002          first_red = _nodes[n].partition_next;
    20032003        } else {
    2004           first_blue = nodes[n].partition_next;
     2004          first_blue = _nodes[n].partition_next;
    20052005        }
    20062006      }
    20072007
    2008       if (nodes[n].red) {
    2009         nodes[n].next = first_free_red;
     2008      if (_nodes[n].red) {
     2009        _nodes[n].next = first_free_red;
    20102010        first_free_red = n;
    20112011      } else {
    2012         nodes[n].next = first_free_blue;
     2012        _nodes[n].next = first_free_blue;
    20132013        first_free_blue = n;
    20142014      }
    2015       nodes[n].prev = -2;
     2015      _nodes[n].prev = -2;
    20162016    }
    20172017
    20182018    void erase(const Edge& edge) {
    20192019      int n = edge.id * 2;
    20202020
    2021       if (arcs[n].next_out != -1) {
    2022         arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
     2021      if (_arcs[n].next_out != -1) {
     2022        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
    20232023      }
    20242024
    2025       if (arcs[n].prev_out != -1) {
    2026         arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
     2025      if (_arcs[n].prev_out != -1) {
     2026        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
    20272027      } else {
    2028         nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
     2028        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
    20292029      }
    20302030
    2031       if (arcs[n | 1].next_out != -1) {
    2032         arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
     2031      if (_arcs[n | 1].next_out != -1) {
     2032        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
    20332033      }
    20342034
    2035       if (arcs[n | 1].prev_out != -1) {
    2036         arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
     2035      if (_arcs[n | 1].prev_out != -1) {
     2036        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
    20372037      } else {
    2038         nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
     2038        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
    20392039      }
    20402040
    2041       arcs[n].next_out = first_free_arc;
     2041      _arcs[n].next_out = first_free_arc;
    20422042      first_free_arc = n;
    2043       arcs[n].prev_out = -2;
    2044       arcs[n | 1].prev_out = -2;
     2043      _arcs[n].prev_out = -2;
     2044      _arcs[n | 1].prev_out = -2;
    20452045
    20462046    }
    20472047
    20482048    void clear() {
    2049       arcs.clear();
    2050       nodes.clear();
     2049      _arcs.clear();
     2050      _nodes.clear();
    20512051      first_node = first_free_arc = first_red = first_blue =
    20522052        max_red = max_blue = first_free_red = first_free_blue = -1;
    20532053    }
     
    20552055  protected:
    20562056
    20572057    void changeRed(Edge e, RedNode n) {
    2058       if(arcs[(2 * e.id) | 1].next_out != -1) {
    2059         arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
    2060           arcs[(2 * e.id) | 1].prev_out;
     2058      if(_arcs[(2 * e.id) | 1].next_out != -1) {
     2059        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
     2060          _arcs[(2 * e.id) | 1].prev_out;
    20612061      }
    2062       if(arcs[(2 * e.id) | 1].prev_out != -1) {
    2063         arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
    2064           arcs[(2 * e.id) | 1].next_out;
     2062      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
     2063        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
     2064          _arcs[(2 * e.id) | 1].next_out;
    20652065      } else {
    2066         nodes[arcs[2 * e.id].target].first_out =
    2067           arcs[(2 * e.id) | 1].next_out;
     2066        _nodes[_arcs[2 * e.id].target].first_out =
     2067          _arcs[(2 * e.id) | 1].next_out;
    20682068      }
    20692069
    2070       if (nodes[n.id].first_out != -1) {
    2071         arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
     2070      if (_nodes[n.id].first_out != -1) {
     2071        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
    20722072      }
    2073       arcs[2 * e.id].target = n.id;
    2074       arcs[(2 * e.id) | 1].prev_out = -1;
    2075       arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
    2076       nodes[n.id].first_out = ((2 * e.id) | 1);
     2073      _arcs[2 * e.id].target = n.id;
     2074      _arcs[(2 * e.id) | 1].prev_out = -1;
     2075      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
     2076      _nodes[n.id].first_out = ((2 * e.id) | 1);
    20772077    }
    20782078
    20792079    void changeBlue(Edge e, BlueNode n) {
    2080        if(arcs[2 * e.id].next_out != -1) {
    2081         arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
     2080       if(_arcs[2 * e.id].next_out != -1) {
     2081        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
    20822082      }
    2083       if(arcs[2 * e.id].prev_out != -1) {
    2084         arcs[arcs[2 * e.id].prev_out].next_out =
    2085           arcs[2 * e.id].next_out;
     2083      if(_arcs[2 * e.id].prev_out != -1) {
     2084        _arcs[_arcs[2 * e.id].prev_out].next_out =
     2085          _arcs[2 * e.id].next_out;
    20862086      } else {
    2087         nodes[arcs[(2 * e.id) | 1].target].first_out =
    2088           arcs[2 * e.id].next_out;
     2087        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
     2088          _arcs[2 * e.id].next_out;
    20892089      }
    20902090
    2091       if (nodes[n.id].first_out != -1) {
    2092         arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
     2091      if (_nodes[n.id].first_out != -1) {
     2092        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
    20932093      }
    2094       arcs[(2 * e.id) | 1].target = n.id;
    2095       arcs[2 * e.id].prev_out = -1;
    2096       arcs[2 * e.id].next_out = nodes[n.id].first_out;
    2097       nodes[n.id].first_out = 2 * e.id;
     2094      _arcs[(2 * e.id) | 1].target = n.id;
     2095      _arcs[2 * e.id].prev_out = -1;
     2096      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
     2097      _nodes[n.id].first_out = 2 * e.id;
    20982098    }
    20992099
    21002100  };
     
    22492249    /// then it is worth reserving space for this amount before starting
    22502250    /// to build the graph.
    22512251    /// \sa reserveEdge()
    2252     void reserveNode(int n) { nodes.reserve(n); };
     2252    void reserveNode(int n) { _nodes.reserve(n); };
    22532253
    22542254    /// Reserve memory for edges.
    22552255
     
    22592259    /// then it is worth reserving space for this amount before starting
    22602260    /// to build the graph.
    22612261    /// \sa reserveNode()
    2262     void reserveEdge(int m) { arcs.reserve(2 * m); };
     2262    void reserveEdge(int m) { _arcs.reserve(2 * m); };
    22632263
    22642264    /// \brief Class to make a snapshot of the graph and restore
    22652265    /// it later.
  • lemon/smart_graph.h

    diff --git a/lemon/smart_graph.h b/lemon/smart_graph.h
    a b  
    825825      int next_out;
    826826    };
    827827
    828     std::vector<NodeT> nodes;
    829     std::vector<ArcT> arcs;
     828    std::vector<NodeT> _nodes;
     829    std::vector<ArcT> _arcs;
    830830
    831831    int first_red, first_blue;
    832832    int max_red, max_blue;
     
    915915
    916916
    917917    SmartBpGraphBase()
    918       : nodes(), arcs(), first_red(-1), first_blue(-1),
     918      : _nodes(), _arcs(), first_red(-1), first_blue(-1),
    919919        max_red(-1), max_blue(-1) {}
    920920
    921921    typedef True NodeNumTag;
    922922    typedef True EdgeNumTag;
    923923    typedef True ArcNumTag;
    924924
    925     int nodeNum() const { return nodes.size(); }
     925    int nodeNum() const { return _nodes.size(); }
    926926    int redNum() const { return max_red + 1; }
    927927    int blueNum() const { return max_blue + 1; }
    928     int edgeNum() const { return arcs.size() / 2; }
    929     int arcNum() const { return arcs.size(); }
     928    int edgeNum() const { return _arcs.size() / 2; }
     929    int arcNum() const { return _arcs.size(); }
    930930
    931     int maxNodeId() const { return nodes.size()-1; }
     931    int maxNodeId() const { return _nodes.size()-1; }
    932932    int maxRedId() const { return max_red; }
    933933    int maxBlueId() const { return max_blue; }
    934     int maxEdgeId() const { return arcs.size() / 2 - 1; }
    935     int maxArcId() const { return arcs.size()-1; }
     934    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
     935    int maxArcId() const { return _arcs.size()-1; }
    936936
    937     bool red(Node n) const { return nodes[n._id].red; }
    938     bool blue(Node n) const { return !nodes[n._id].red; }
     937    bool red(Node n) const { return _nodes[n._id].red; }
     938    bool blue(Node n) const { return !_nodes[n._id].red; }
    939939
    940940    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
    941941    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
    942942
    943     Node source(Arc a) const { return Node(arcs[a._id ^ 1].target); }
    944     Node target(Arc a) const { return Node(arcs[a._id].target); }
     943    Node source(Arc a) const { return Node(_arcs[a._id ^ 1].target); }
     944    Node target(Arc a) const { return Node(_arcs[a._id].target); }
    945945
    946946    RedNode redNode(Edge e) const {
    947       return RedNode(arcs[2 * e._id].target);
     947      return RedNode(_arcs[2 * e._id].target);
    948948    }
    949949    BlueNode blueNode(Edge e) const {
    950       return BlueNode(arcs[2 * e._id + 1].target);
     950      return BlueNode(_arcs[2 * e._id + 1].target);
    951951    }
    952952
    953953    static bool direction(Arc a) {
     
    959959    }
    960960
    961961    void first(Node& node) const {
    962       node._id = nodes.size() - 1;
     962      node._id = _nodes.size() - 1;
    963963    }
    964964
    965965    static void next(Node& node) {
     
    971971    }
    972972
    973973    void next(RedNode& node) const {
    974       node._id = nodes[node._id].partition_next;
     974      node._id = _nodes[node._id].partition_next;
    975975    }
    976976
    977977    void first(BlueNode& node) const {
     
    979979    }
    980980
    981981    void next(BlueNode& node) const {
    982       node._id = nodes[node._id].partition_next;
     982      node._id = _nodes[node._id].partition_next;
    983983    }
    984984
    985985    void first(Arc& arc) const {
    986       arc._id = arcs.size() - 1;
     986      arc._id = _arcs.size() - 1;
    987987    }
    988988
    989989    static void next(Arc& arc) {
     
    991991    }
    992992
    993993    void first(Edge& arc) const {
    994       arc._id = arcs.size() / 2 - 1;
     994      arc._id = _arcs.size() / 2 - 1;
    995995    }
    996996
    997997    static void next(Edge& arc) {
     
    999999    }
    10001000
    10011001    void firstOut(Arc &arc, const Node& v) const {
    1002       arc._id = nodes[v._id].first_out;
     1002      arc._id = _nodes[v._id].first_out;
    10031003    }
    10041004    void nextOut(Arc &arc) const {
    1005       arc._id = arcs[arc._id].next_out;
     1005      arc._id = _arcs[arc._id].next_out;
    10061006    }
    10071007
    10081008    void firstIn(Arc &arc, const Node& v) const {
    1009       arc._id = ((nodes[v._id].first_out) ^ 1);
     1009      arc._id = ((_nodes[v._id].first_out) ^ 1);
    10101010      if (arc._id == -2) arc._id = -1;
    10111011    }
    10121012    void nextIn(Arc &arc) const {
    1013       arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
     1013      arc._id = ((_arcs[arc._id ^ 1].next_out) ^ 1);
    10141014      if (arc._id == -2) arc._id = -1;
    10151015    }
    10161016
    10171017    void firstInc(Edge &arc, bool& d, const Node& v) const {
    1018       int de = nodes[v._id].first_out;
     1018      int de = _nodes[v._id].first_out;
    10191019      if (de != -1) {
    10201020        arc._id = de / 2;
    10211021        d = ((de & 1) == 1);
     
    10251025      }
    10261026    }
    10271027    void nextInc(Edge &arc, bool& d) const {
    1028       int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
     1028      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
    10291029      if (de != -1) {
    10301030        arc._id = de / 2;
    10311031        d = ((de & 1) == 1);
     
    10361036    }
    10371037
    10381038    static int id(Node v) { return v._id; }
    1039     int id(RedNode v) const { return nodes[v._id].partition_index; }
    1040     int id(BlueNode v) const { return nodes[v._id].partition_index; }
     1039    int id(RedNode v) const { return _nodes[v._id].partition_index; }
     1040    int id(BlueNode v) const { return _nodes[v._id].partition_index; }
    10411041    static int id(Arc e) { return e._id; }
    10421042    static int id(Edge e) { return e._id; }
    10431043
     
    10461046    static Edge edgeFromId(int id) { return Edge(id);}
    10471047
    10481048    bool valid(Node n) const {
    1049       return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     1049      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
    10501050    }
    10511051    bool valid(Arc a) const {
    1052       return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     1052      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
    10531053    }
    10541054    bool valid(Edge e) const {
    1055       return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
     1055      return e._id >= 0 && 2 * e._id < static_cast<int>(_arcs.size());
    10561056    }
    10571057
    10581058    RedNode addRedNode() {
    1059       int n = nodes.size();
    1060       nodes.push_back(NodeT());
    1061       nodes[n].first_out = -1;
    1062       nodes[n].red = true;
    1063       nodes[n].partition_index = ++max_red;
    1064       nodes[n].partition_next = first_red;
     1059      int n = _nodes.size();
     1060      _nodes.push_back(NodeT());
     1061      _nodes[n].first_out = -1;
     1062      _nodes[n].red = true;
     1063      _nodes[n].partition_index = ++max_red;
     1064      _nodes[n].partition_next = first_red;
    10651065      first_red = n;
    10661066
    10671067      return RedNode(n);
    10681068    }
    10691069
    10701070    BlueNode addBlueNode() {
    1071       int n = nodes.size();
    1072       nodes.push_back(NodeT());
    1073       nodes[n].first_out = -1;
    1074       nodes[n].red = false;
    1075       nodes[n].partition_index = ++max_blue;
    1076       nodes[n].partition_next = first_blue;
     1071      int n = _nodes.size();
     1072      _nodes.push_back(NodeT());
     1073      _nodes[n].first_out = -1;
     1074      _nodes[n].red = false;
     1075      _nodes[n].partition_index = ++max_blue;
     1076      _nodes[n].partition_next = first_blue;
    10771077      first_blue = n;
    10781078
    10791079      return BlueNode(n);
    10801080    }
    10811081
    10821082    Edge addEdge(RedNode u, BlueNode v) {
    1083       int n = arcs.size();
    1084       arcs.push_back(ArcT());
    1085       arcs.push_back(ArcT());
     1083      int n = _arcs.size();
     1084      _arcs.push_back(ArcT());
     1085      _arcs.push_back(ArcT());
    10861086
    1087       arcs[n].target = u._id;
    1088       arcs[n | 1].target = v._id;
     1087      _arcs[n].target = u._id;
     1088      _arcs[n | 1].target = v._id;
    10891089
    1090       arcs[n].next_out = nodes[v._id].first_out;
    1091       nodes[v._id].first_out = n;
     1090      _arcs[n].next_out = _nodes[v._id].first_out;
     1091      _nodes[v._id].first_out = n;
    10921092
    1093       arcs[n | 1].next_out = nodes[u._id].first_out;
    1094       nodes[u._id].first_out = (n | 1);
     1093      _arcs[n | 1].next_out = _nodes[u._id].first_out;
     1094      _nodes[u._id].first_out = (n | 1);
    10951095
    10961096      return Edge(n / 2);
    10971097    }
    10981098
    10991099    void clear() {
    1100       arcs.clear();
    1101       nodes.clear();
     1100      _arcs.clear();
     1101      _nodes.clear();
    11021102      first_red = -1;
    11031103      first_blue = -1;
    11041104      max_blue = -1;
     
    12131213    /// then it is worth reserving space for this amount before starting
    12141214    /// to build the graph.
    12151215    /// \sa reserveEdge()
    1216     void reserveNode(int n) { nodes.reserve(n); };
     1216    void reserveNode(int n) { _nodes.reserve(n); };
    12171217
    12181218    /// Reserve memory for edges.
    12191219
     
    12231223    /// then it is worth reserving space for this amount before starting
    12241224    /// to build the graph.
    12251225    /// \sa reserveNode()
    1226     void reserveEdge(int m) { arcs.reserve(2 * m); };
     1226    void reserveEdge(int m) { _arcs.reserve(2 * m); };
    12271227
    12281228  public:
    12291229
     
    12341234    void saveSnapshot(Snapshot &s)
    12351235    {
    12361236      s._graph = this;
    1237       s.node_num = nodes.size();
    1238       s.arc_num = arcs.size();
     1237      s.node_num = _nodes.size();
     1238      s.arc_num = _arcs.size();
    12391239    }
    12401240
    12411241    void restoreSnapshot(const Snapshot &s)
    12421242    {
    1243       while(s.arc_num<arcs.size()) {
    1244         int n=arcs.size()-1;
     1243      while(s.arc_num<_arcs.size()) {
     1244        int n=_arcs.size()-1;
    12451245        Edge arc=edgeFromId(n/2);
    12461246        Parent::notifier(Edge()).erase(arc);
    12471247        std::vector<Arc> dir;
    12481248        dir.push_back(arcFromId(n));
    12491249        dir.push_back(arcFromId(n-1));
    12501250        Parent::notifier(Arc()).erase(dir);
    1251         nodes[arcs[n-1].target].first_out=arcs[n].next_out;
    1252         nodes[arcs[n].target].first_out=arcs[n-1].next_out;
    1253         arcs.pop_back();
    1254         arcs.pop_back();
     1251        _nodes[_arcs[n-1].target].first_out=_arcs[n].next_out;
     1252        _nodes[_arcs[n].target].first_out=_arcs[n-1].next_out;
     1253        _arcs.pop_back();
     1254        _arcs.pop_back();
    12551255      }
    1256       while(s.node_num<nodes.size()) {
    1257         int n=nodes.size()-1;
     1256      while(s.node_num<_nodes.size()) {
     1257        int n=_nodes.size()-1;
    12581258        Node node = nodeFromId(n);
    12591259        if (Parent::red(node)) {
    1260           first_red = nodes[n].partition_next;
     1260          first_red = _nodes[n].partition_next;
    12611261          if (first_red != -1) {
    1262             max_red = nodes[first_red].partition_index;
     1262            max_red = _nodes[first_red].partition_index;
    12631263          } else {
    12641264            max_red = -1;
    12651265          }
    12661266          Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));
    12671267        } else {
    1268           first_blue = nodes[n].partition_next;
     1268          first_blue = _nodes[n].partition_next;
    12691269          if (first_blue != -1) {
    1270             max_blue = nodes[first_blue].partition_index;
     1270            max_blue = _nodes[first_blue].partition_index;
    12711271          } else {
    12721272            max_blue = -1;
    12731273          }
    12741274          Parent::notifier(BlueNode()).erase(asBlueNodeUnsafe(node));
    12751275        }
    12761276        Parent::notifier(Node()).erase(node);
    1277         nodes.pop_back();
     1277        _nodes.pop_back();
    12781278      }
    12791279    }
    12801280