COIN-OR::LEMON - Graph Library

Changeset 1336:0759d974de81 in lemon for lemon/smart_graph.h


Ignore:
Timestamp:
01/05/14 22:24:56 (6 years ago)
Author:
Gabor Gevay <ggab90@…>
Branch:
default
Phase:
public
Message:

STL style iterators (#325)

For

  • graph types,
  • graph adaptors,
  • paths,
  • iterable maps,
  • LP rows/cols and
  • active nodes is BellmanFord?
File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/smart_graph.h

    r1270 r1336  
    4848    };
    4949
    50     std::vector<NodeT> nodes;
    51     std::vector<ArcT> arcs;
     50    std::vector<NodeT> _nodes;
     51    std::vector<ArcT> _arcs;
    5252
    5353  public:
     
    6060  public:
    6161
    62     SmartDigraphBase() : nodes(), arcs() { }
     62    SmartDigraphBase() : _nodes(), _arcs() { }
    6363    SmartDigraphBase(const SmartDigraphBase &_g)
    64       : nodes(_g.nodes), arcs(_g.arcs) { }
     64      : _nodes(_g._nodes), _arcs(_g._arcs) { }
    6565
    6666    typedef True NodeNumTag;
    6767    typedef True ArcNumTag;
    6868
    69     int nodeNum() const { return nodes.size(); }
    70     int arcNum() const { return arcs.size(); }
    71 
    72     int maxNodeId() const { return nodes.size()-1; }
    73     int maxArcId() const { return arcs.size()-1; }
     69    int nodeNum() const { return _nodes.size(); }
     70    int arcNum() const { return _arcs.size(); }
     71
     72    int maxNodeId() const { return _nodes.size()-1; }
     73    int maxArcId() const { return _arcs.size()-1; }
    7474
    7575    Node addNode() {
    76       int n = nodes.size();
    77       nodes.push_back(NodeT());
    78       nodes[n].first_in = -1;
    79       nodes[n].first_out = -1;
     76      int n = _nodes.size();
     77      _nodes.push_back(NodeT());
     78      _nodes[n].first_in = -1;
     79      _nodes[n].first_out = -1;
    8080      return Node(n);
    8181    }
    8282
    8383    Arc addArc(Node u, Node v) {
    84       int n = arcs.size();
    85       arcs.push_back(ArcT());
    86       arcs[n].source = u._id;
    87       arcs[n].target = v._id;
    88       arcs[n].next_out = nodes[u._id].first_out;
    89       arcs[n].next_in = nodes[v._id].first_in;
    90       nodes[u._id].first_out = nodes[v._id].first_in = n;
     84      int n = _arcs.size();
     85      _arcs.push_back(ArcT());
     86      _arcs[n].source = u._id;
     87      _arcs[n].target = v._id;
     88      _arcs[n].next_out = _nodes[u._id].first_out;
     89      _arcs[n].next_in = _nodes[v._id].first_in;
     90      _nodes[u._id].first_out = _nodes[v._id].first_in = n;
    9191
    9292      return Arc(n);
     
    9494
    9595    void clear() {
    96       arcs.clear();
    97       nodes.clear();
    98     }
    99 
    100     Node source(Arc a) const { return Node(arcs[a._id].source); }
    101     Node target(Arc a) const { return Node(arcs[a._id].target); }
     96      _arcs.clear();
     97      _nodes.clear();
     98    }
     99
     100    Node source(Arc a) const { return Node(_arcs[a._id].source); }
     101    Node target(Arc a) const { return Node(_arcs[a._id].target); }
    102102
    103103    static int id(Node v) { return v._id; }
     
    108108
    109109    bool valid(Node n) const {
    110       return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     110      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
    111111    }
    112112    bool valid(Arc a) const {
    113       return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     113      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
    114114    }
    115115
     
    146146
    147147    void first(Node& node) const {
    148       node._id = nodes.size() - 1;
     148      node._id = _nodes.size() - 1;
    149149    }
    150150
     
    154154
    155155    void first(Arc& arc) const {
    156       arc._id = arcs.size() - 1;
     156      arc._id = _arcs.size() - 1;
    157157    }
    158158
     
    162162
    163163    void firstOut(Arc& arc, const Node& node) const {
    164       arc._id = nodes[node._id].first_out;
     164      arc._id = _nodes[node._id].first_out;
    165165    }
    166166
    167167    void nextOut(Arc& arc) const {
    168       arc._id = arcs[arc._id].next_out;
     168      arc._id = _arcs[arc._id].next_out;
    169169    }
    170170
    171171    void firstIn(Arc& arc, const Node& node) const {
    172       arc._id = nodes[node._id].first_in;
     172      arc._id = _nodes[node._id].first_in;
    173173    }
    174174
    175175    void nextIn(Arc& arc) const {
    176       arc._id = arcs[arc._id].next_in;
     176      arc._id = _arcs[arc._id].next_in;
    177177    }
    178178
     
    267267    {
    268268      Node b = addNode();
    269       nodes[b._id].first_out=nodes[n._id].first_out;
    270       nodes[n._id].first_out=-1;
    271       for(int i=nodes[b._id].first_out; i!=-1; i=arcs[i].next_out) {
    272         arcs[i].source=b._id;
     269      _nodes[b._id].first_out=_nodes[n._id].first_out;
     270      _nodes[n._id].first_out=-1;
     271      for(int i=_nodes[b._id].first_out; i!=-1; i=_arcs[i].next_out) {
     272        _arcs[i].source=b._id;
    273273      }
    274274      if(connect) addArc(n,b);
     
    292292    /// to build the digraph.
    293293    /// \sa reserveArc()
    294     void reserveNode(int n) { nodes.reserve(n); };
     294    void reserveNode(int n) { _nodes.reserve(n); };
    295295
    296296    /// Reserve memory for arcs.
     
    302302    /// to build the digraph.
    303303    /// \sa reserveNode()
    304     void reserveArc(int m) { arcs.reserve(m); };
     304    void reserveArc(int m) { _arcs.reserve(m); };
    305305
    306306  public:
     
    312312    void restoreSnapshot(const Snapshot &s)
    313313    {
    314       while(s.arc_num<arcs.size()) {
    315         Arc arc = arcFromId(arcs.size()-1);
     314      while(s.arc_num<_arcs.size()) {
     315        Arc arc = arcFromId(_arcs.size()-1);
    316316        Parent::notifier(Arc()).erase(arc);
    317         nodes[arcs.back().source].first_out=arcs.back().next_out;
    318         nodes[arcs.back().target].first_in=arcs.back().next_in;
    319         arcs.pop_back();
    320       }
    321       while(s.node_num<nodes.size()) {
    322         Node node = nodeFromId(nodes.size()-1);
     317        _nodes[_arcs.back().source].first_out=_arcs.back().next_out;
     318        _nodes[_arcs.back().target].first_in=_arcs.back().next_in;
     319        _arcs.pop_back();
     320      }
     321      while(s.node_num<_nodes.size()) {
     322        Node node = nodeFromId(_nodes.size()-1);
    323323        Parent::notifier(Node()).erase(node);
    324         nodes.pop_back();
     324        _nodes.pop_back();
    325325      }
    326326    }
     
    363363      ///
    364364      Snapshot(SmartDigraph &gr) : _graph(&gr) {
    365         node_num=_graph->nodes.size();
    366         arc_num=_graph->arcs.size();
     365        node_num=_graph->_nodes.size();
     366        arc_num=_graph->_arcs.size();
    367367      }
    368368
     
    374374      void save(SmartDigraph &gr) {
    375375        _graph=&gr;
    376         node_num=_graph->nodes.size();
    377         arc_num=_graph->arcs.size();
     376        node_num=_graph->_nodes.size();
     377        arc_num=_graph->_arcs.size();
    378378      }
    379379
     
    403403    };
    404404
    405     std::vector<NodeT> nodes;
    406     std::vector<ArcT> arcs;
     405    std::vector<NodeT> _nodes;
     406    std::vector<ArcT> _arcs;
    407407
    408408  public:
     
    466466
    467467    SmartGraphBase()
    468       : nodes(), arcs() {}
     468      : _nodes(), _arcs() {}
    469469
    470470    typedef True NodeNumTag;
     
    472472    typedef True ArcNumTag;
    473473
    474     int nodeNum() const { return nodes.size(); }
    475     int edgeNum() const { return arcs.size() / 2; }
    476     int arcNum() const { return arcs.size(); }
    477 
    478     int maxNodeId() const { return nodes.size()-1; }
    479     int maxEdgeId() const { return arcs.size() / 2 - 1; }
    480     int maxArcId() const { return arcs.size()-1; }
    481 
    482     Node source(Arc e) const { return Node(arcs[e._id ^ 1].target); }
    483     Node target(Arc e) const { return Node(arcs[e._id].target); }
    484 
    485     Node u(Edge e) const { return Node(arcs[2 * e._id].target); }
    486     Node v(Edge e) const { return Node(arcs[2 * e._id + 1].target); }
     474    int nodeNum() const { return _nodes.size(); }
     475    int edgeNum() const { return _arcs.size() / 2; }
     476    int arcNum() const { return _arcs.size(); }
     477
     478    int maxNodeId() const { return _nodes.size()-1; }
     479    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
     480    int maxArcId() const { return _arcs.size()-1; }
     481
     482    Node source(Arc e) const { return Node(_arcs[e._id ^ 1].target); }
     483    Node target(Arc e) const { return Node(_arcs[e._id].target); }
     484
     485    Node u(Edge e) const { return Node(_arcs[2 * e._id].target); }
     486    Node v(Edge e) const { return Node(_arcs[2 * e._id + 1].target); }
    487487
    488488    static bool direction(Arc e) {
     
    495495
    496496    void first(Node& node) const {
    497       node._id = nodes.size() - 1;
     497      node._id = _nodes.size() - 1;
    498498    }
    499499
     
    503503
    504504    void first(Arc& arc) const {
    505       arc._id = arcs.size() - 1;
     505      arc._id = _arcs.size() - 1;
    506506    }
    507507
     
    511511
    512512    void first(Edge& arc) const {
    513       arc._id = arcs.size() / 2 - 1;
     513      arc._id = _arcs.size() / 2 - 1;
    514514    }
    515515
     
    519519
    520520    void firstOut(Arc &arc, const Node& v) const {
    521       arc._id = nodes[v._id].first_out;
     521      arc._id = _nodes[v._id].first_out;
    522522    }
    523523    void nextOut(Arc &arc) const {
    524       arc._id = arcs[arc._id].next_out;
     524      arc._id = _arcs[arc._id].next_out;
    525525    }
    526526
    527527    void firstIn(Arc &arc, const Node& v) const {
    528       arc._id = ((nodes[v._id].first_out) ^ 1);
     528      arc._id = ((_nodes[v._id].first_out) ^ 1);
    529529      if (arc._id == -2) arc._id = -1;
    530530    }
    531531    void nextIn(Arc &arc) const {
    532       arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
     532      arc._id = ((_arcs[arc._id ^ 1].next_out) ^ 1);
    533533      if (arc._id == -2) arc._id = -1;
    534534    }
    535535
    536536    void firstInc(Edge &arc, bool& d, const Node& v) const {
    537       int de = nodes[v._id].first_out;
     537      int de = _nodes[v._id].first_out;
    538538      if (de != -1) {
    539539        arc._id = de / 2;
     
    545545    }
    546546    void nextInc(Edge &arc, bool& d) const {
    547       int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
     547      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
    548548      if (de != -1) {
    549549        arc._id = de / 2;
     
    564564
    565565    bool valid(Node n) const {
    566       return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     566      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
    567567    }
    568568    bool valid(Arc a) const {
    569       return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     569      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
    570570    }
    571571    bool valid(Edge e) const {
    572       return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
     572      return e._id >= 0 && 2 * e._id < static_cast<int>(_arcs.size());
    573573    }
    574574
    575575    Node addNode() {
    576       int n = nodes.size();
    577       nodes.push_back(NodeT());
    578       nodes[n].first_out = -1;
     576      int n = _nodes.size();
     577      _nodes.push_back(NodeT());
     578      _nodes[n].first_out = -1;
    579579
    580580      return Node(n);
     
    582582
    583583    Edge addEdge(Node u, Node v) {
    584       int n = arcs.size();
    585       arcs.push_back(ArcT());
    586       arcs.push_back(ArcT());
    587 
    588       arcs[n].target = u._id;
    589       arcs[n | 1].target = v._id;
    590 
    591       arcs[n].next_out = nodes[v._id].first_out;
    592       nodes[v._id].first_out = n;
    593 
    594       arcs[n | 1].next_out = nodes[u._id].first_out;
    595       nodes[u._id].first_out = (n | 1);
     584      int n = _arcs.size();
     585      _arcs.push_back(ArcT());
     586      _arcs.push_back(ArcT());
     587
     588      _arcs[n].target = u._id;
     589      _arcs[n | 1].target = v._id;
     590
     591      _arcs[n].next_out = _nodes[v._id].first_out;
     592      _nodes[v._id].first_out = n;
     593
     594      _arcs[n | 1].next_out = _nodes[u._id].first_out;
     595      _nodes[u._id].first_out = (n | 1);
    596596
    597597      return Edge(n / 2);
     
    599599
    600600    void clear() {
    601       arcs.clear();
    602       nodes.clear();
     601      _arcs.clear();
     602      _nodes.clear();
    603603    }
    604604
     
    702702    /// to build the graph.
    703703    /// \sa reserveEdge()
    704     void reserveNode(int n) { nodes.reserve(n); };
     704    void reserveNode(int n) { _nodes.reserve(n); };
    705705
    706706    /// Reserve memory for edges.
     
    712712    /// to build the graph.
    713713    /// \sa reserveNode()
    714     void reserveEdge(int m) { arcs.reserve(2 * m); };
     714    void reserveEdge(int m) { _arcs.reserve(2 * m); };
    715715
    716716  public:
     
    723723    {
    724724      s._graph = this;
    725       s.node_num = nodes.size();
    726       s.arc_num = arcs.size();
     725      s.node_num = _nodes.size();
     726      s.arc_num = _arcs.size();
    727727    }
    728728
    729729    void restoreSnapshot(const Snapshot &s)
    730730    {
    731       while(s.arc_num<arcs.size()) {
    732         int n=arcs.size()-1;
     731      while(s.arc_num<_arcs.size()) {
     732        int n=_arcs.size()-1;
    733733        Edge arc=edgeFromId(n/2);
    734734        Parent::notifier(Edge()).erase(arc);
     
    737737        dir.push_back(arcFromId(n-1));
    738738        Parent::notifier(Arc()).erase(dir);
    739         nodes[arcs[n-1].target].first_out=arcs[n].next_out;
    740         nodes[arcs[n].target].first_out=arcs[n-1].next_out;
    741         arcs.pop_back();
    742         arcs.pop_back();
    743       }
    744       while(s.node_num<nodes.size()) {
    745         int n=nodes.size()-1;
     739        _nodes[_arcs[n-1].target].first_out=_arcs[n].next_out;
     740        _nodes[_arcs[n].target].first_out=_arcs[n-1].next_out;
     741        _arcs.pop_back();
     742        _arcs.pop_back();
     743      }
     744      while(s.node_num<_nodes.size()) {
     745        int n=_nodes.size()-1;
    746746        Node node = nodeFromId(n);
    747747        Parent::notifier(Node()).erase(node);
    748         nodes.pop_back();
     748        _nodes.pop_back();
    749749      }
    750750    }
     
    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;
     
    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
     
    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(); }
    930 
    931     int maxNodeId() const { return nodes.size()-1; }
     928    int edgeNum() const { return _arcs.size() / 2; }
     929    int arcNum() const { return _arcs.size(); }
     930
     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; }
    936 
    937     bool red(Node n) const { return nodes[n._id].red; }
    938     bool blue(Node n) const { return !nodes[n._id].red; }
     934    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
     935    int maxArcId() const { return _arcs.size()-1; }
     936
     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
     
    960960
    961961    void first(Node& node) const {
    962       node._id = nodes.size() - 1;
     962      node._id = _nodes.size() - 1;
    963963    }
    964964
     
    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
     
    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
     
    992992
    993993    void first(Edge& arc) const {
    994       arc._id = arcs.size() / 2 - 1;
     994      arc._id = _arcs.size() / 2 - 1;
    995995    }
    996996
     
    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;
     
    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;
     
    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; }
     
    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
     
    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
     
    10811081
    10821082    Edge addEdge(RedNode u, BlueNode v) {
    1083       int n = arcs.size();
    1084       arcs.push_back(ArcT());
    1085       arcs.push_back(ArcT());
    1086 
    1087       arcs[n].target = u._id;
    1088       arcs[n | 1].target = v._id;
    1089 
    1090       arcs[n].next_out = nodes[v._id].first_out;
    1091       nodes[v._id].first_out = n;
    1092 
    1093       arcs[n | 1].next_out = nodes[u._id].first_out;
    1094       nodes[u._id].first_out = (n | 1);
     1083      int n = _arcs.size();
     1084      _arcs.push_back(ArcT());
     1085      _arcs.push_back(ArcT());
     1086
     1087      _arcs[n].target = u._id;
     1088      _arcs[n | 1].target = v._id;
     1089
     1090      _arcs[n].next_out = _nodes[v._id].first_out;
     1091      _nodes[v._id].first_out = n;
     1092
     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);
     
    10981098
    10991099    void clear() {
    1100       arcs.clear();
    1101       nodes.clear();
     1100      _arcs.clear();
     1101      _nodes.clear();
    11021102      first_red = -1;
    11031103      first_blue = -1;
     
    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.
     
    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:
     
    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);
     
    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();
    1255       }
    1256       while(s.node_num<nodes.size()) {
    1257         int n=nodes.size()-1;
     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();
     1255      }
     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;
     
    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;
     
    12751275        }
    12761276        Parent::notifier(Node()).erase(node);
    1277         nodes.pop_back();
     1277        _nodes.pop_back();
    12781278      }
    12791279    }
Note: See TracChangeset for help on using the changeset viewer.