COIN-OR::LEMON - Graph Library

Ticket #325: 0759d974de81-4add05447ca0-72af84645ac2.patch

File 0759d974de81-4add05447ca0-72af84645ac2.patch, 143.9 KB (added by Alpar Juttner, 6 years ago)
  • CMakeLists.txt

    # HG changeset patch
    # User Gabor Gevay <ggab90@gmail.com>
    # Date 1388957096 -3600
    #      Sun Jan 05 22:24:56 2014 +0100
    # Node ID 0759d974de816af3492dff5e02de2d361ad27841
    # Parent  39b6e65574c68620fda4e5faa9bd779c29c62190
    STL style iterators (#325)
    
    For
     * graph types,
     * graph adaptors,
     * paths,
     * iterable maps,
     * LP rows/cols and
     * active nodes is BellmanFord
    
    diff --git a/CMakeLists.txt b/CMakeLists.txt
    a b  
    262262
    263263ENABLE_TESTING()
    264264
     265
     266INCLUDE(CheckCXXCompilerFlag)
     267CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX11FLAG)
     268IF(CXX11FLAG)
     269  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     270ENDIF()
     271
     272
    265273IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
    266274  ADD_CUSTOM_TARGET(check ALL COMMAND ${CMAKE_CTEST_COMMAND})
    267275ELSE()
  • lemon/bellman_ford.h

    diff --git a/lemon/bellman_ford.h b/lemon/bellman_ford.h
    a b  
    2929#include <lemon/error.h>
    3030#include <lemon/maps.h>
    3131#include <lemon/path.h>
     32#include <lemon/bits/stl_iterators.h>
    3233
    3334#include <limits>
    3435
     
    690691      int _index;
    691692    };
    692693
     694    /// \brief Gets the collection of the active nodes.
     695    ///
     696    /// This function can be used for iterating on the active nodes of the
     697    /// Bellman-Ford algorithm after the last phase.
     698    /// These nodes should be checked in the next phase to
     699    /// find augmenting arcs outgoing from them.
     700    /// It returns a wrapped ActiveIt, which looks
     701    /// like an STL container (by having begin() and end())
     702    /// which you can use in range-based for loops, STL algorithms, etc.
     703    LemonRangeWrapper1<ActiveIt, BellmanFord>
     704        activeNodes(const BellmanFord& algorithm) const {
     705      return LemonRangeWrapper1<ActiveIt, BellmanFord>(algorithm);
     706    }
     707
     708
    693709    /// \name Query Functions
    694710    /// The result of the Bellman-Ford algorithm can be obtained using these
    695711    /// functions.\n
  • lemon/bits/graph_adaptor_extender.h

    diff --git a/lemon/bits/graph_adaptor_extender.h b/lemon/bits/graph_adaptor_extender.h
    a b  
    8585
    8686    };
    8787
     88    LemonRangeWrapper1<NodeIt, Adaptor> nodes() {
     89      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
     90    }
    8891
    8992    class ArcIt : public Arc {
    9093      const Adaptor* _adaptor;
     
    108111
    109112    };
    110113
     114    LemonRangeWrapper1<ArcIt, Adaptor> arcs() {
     115      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
     116    }
     117
    111118
    112119    class OutArcIt : public Arc {
    113120      const Adaptor* _adaptor;
     
    132139
    133140    };
    134141
     142    LemonRangeWrapper2<OutArcIt, Adaptor, Node> outArcs(const Node& u) const {
     143      return LemonRangeWrapper2<OutArcIt, Adaptor, Node>(*this, u);
     144    }
     145
    135146
    136147    class InArcIt : public Arc {
    137148      const Adaptor* _adaptor;
     
    156167
    157168    };
    158169
     170    LemonRangeWrapper2<InArcIt, Adaptor, Node> inArcs(const Node& u) const {
     171      return LemonRangeWrapper2<InArcIt, Adaptor, Node>(*this, u);
     172    }
     173
    159174    Node baseNode(const OutArcIt &e) const {
    160175      return Parent::source(e);
    161176    }
     
    254269
    255270    };
    256271
     272    LemonRangeWrapper1<NodeIt, Adaptor> nodes() {
     273      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
     274    }
     275
    257276
    258277    class ArcIt : public Arc {
    259278      const Adaptor* _adaptor;
     
    277296
    278297    };
    279298
     299    LemonRangeWrapper1<ArcIt, Adaptor> arcs() {
     300      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
     301    }
     302
    280303
    281304    class OutArcIt : public Arc {
    282305      const Adaptor* _adaptor;
     
    301324
    302325    };
    303326
     327    LemonRangeWrapper2<OutArcIt, Adaptor, Node> outArcs(const Node& u) const {
     328      return LemonRangeWrapper2<OutArcIt, Adaptor, Node>(*this, u);
     329    }
     330
    304331
    305332    class InArcIt : public Arc {
    306333      const Adaptor* _adaptor;
     
    325352
    326353    };
    327354
     355    LemonRangeWrapper2<InArcIt, Adaptor, Node> inArcs(const Node& u) const {
     356      return LemonRangeWrapper2<InArcIt, Adaptor, Node>(*this, u);
     357    }
     358
    328359    class EdgeIt : public Parent::Edge {
    329360      const Adaptor* _adaptor;
    330361    public:
     
    347378
    348379    };
    349380
     381    LemonRangeWrapper1<EdgeIt, Adaptor> edges() {
     382      return LemonRangeWrapper1<EdgeIt, Adaptor>(*this);
     383    }
     384
     385
    350386    class IncEdgeIt : public Edge {
    351387      friend class GraphAdaptorExtender;
    352388      const Adaptor* _adaptor;
     
    372408      }
    373409    };
    374410
     411    LemonRangeWrapper2<IncEdgeIt, Adaptor, Node> incEdges(const Node& u) const {
     412      return LemonRangeWrapper2<IncEdgeIt, Adaptor, Node>(*this, u);
     413    }
     414
     415
    375416    Node baseNode(const OutArcIt &a) const {
    376417      return Parent::source(a);
    377418    }
  • lemon/bits/graph_extender.h

    diff --git a/lemon/bits/graph_extender.h b/lemon/bits/graph_extender.h
    a b  
    2727#include <lemon/concept_check.h>
    2828#include <lemon/concepts/maps.h>
    2929
     30#include <lemon/bits/stl_iterators.h>
     31
    3032//\ingroup graphbits
    3133//\file
    3234//\brief Extenders for the graph types
     
    116118
    117119    };
    118120
     121    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
     122      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
     123    }
     124
    119125
    120126    class ArcIt : public Arc {
    121127      const Digraph* _digraph;
     
    139145
    140146    };
    141147
     148    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
     149      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
     150    }
     151
    142152
    143153    class OutArcIt : public Arc {
    144154      const Digraph* _digraph;
     
    163173
    164174    };
    165175
     176    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
     177      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
     178    }
     179
    166180
    167181    class InArcIt : public Arc {
    168182      const Digraph* _digraph;
     
    187201
    188202    };
    189203
     204    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
     205      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
     206    }
     207
    190208    // \brief Base node of the iterator
    191209    //
    192210    // Returns the base node (i.e. the source in this case) of the iterator
     
    436454
    437455    };
    438456
     457    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
     458      return LemonRangeWrapper1<NodeIt, Graph>(*this);
     459    }
     460
    439461
    440462    class ArcIt : public Arc {
    441463      const Graph* _graph;
     
    459481
    460482    };
    461483
     484    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
     485      return LemonRangeWrapper1<ArcIt, Graph>(*this);
     486    }
     487
    462488
    463489    class OutArcIt : public Arc {
    464490      const Graph* _graph;
     
    483509
    484510    };
    485511
     512    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
     513      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
     514    }
     515
    486516
    487517    class InArcIt : public Arc {
    488518      const Graph* _graph;
     
    507537
    508538    };
    509539
     540    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
     541      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
     542    }
     543
    510544
    511545    class EdgeIt : public Parent::Edge {
    512546      const Graph* _graph;
     
    530564
    531565    };
    532566
     567    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
     568      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
     569    }
     570
     571
    533572    class IncEdgeIt : public Parent::Edge {
    534573      friend class GraphExtender;
    535574      const Graph* _graph;
     
    555594      }
    556595    };
    557596
     597    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
     598      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
     599    }
     600
     601
    558602    // \brief Base node of the iterator
    559603    //
    560604    // Returns the base node (ie. the source in this case) of the iterator
     
    903947
    904948    };
    905949
     950    LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
     951      return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
     952    }
     953
     954
    906955    class RedNodeIt : public RedNode {
    907956      const BpGraph* _graph;
    908957    public:
     
    925974
    926975    };
    927976
     977    LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
     978      return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
     979    }
     980
     981
    928982    class BlueNodeIt : public BlueNode {
    929983      const BpGraph* _graph;
    930984    public:
     
    9471001
    9481002    };
    9491003
     1004    LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
     1005      return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
     1006    }
     1007
     1008
    9501009
    9511010    class ArcIt : public Arc {
    9521011      const BpGraph* _graph;
     
    9701029
    9711030    };
    9721031
     1032    LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
     1033      return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
     1034    }
     1035
    9731036
    9741037    class OutArcIt : public Arc {
    9751038      const BpGraph* _graph;
     
    9941057
    9951058    };
    9961059
     1060    LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
     1061      return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
     1062    }
     1063
    9971064
    9981065    class InArcIt : public Arc {
    9991066      const BpGraph* _graph;
     
    10181085
    10191086    };
    10201087
     1088    LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
     1089      return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
     1090    }
     1091
    10211092
    10221093    class EdgeIt : public Parent::Edge {
    10231094      const BpGraph* _graph;
     
    10411112
    10421113    };
    10431114
     1115    LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
     1116      return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
     1117    }
     1118
     1119
    10441120    class IncEdgeIt : public Parent::Edge {
    10451121      friend class BpGraphExtender;
    10461122      const BpGraph* _graph;
     
    10661142      }
    10671143    };
    10681144
     1145    LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
     1146      return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
     1147    }
     1148
     1149
    10691150    // \brief Base node of the iterator
    10701151    //
    10711152    // Returns the base node (ie. the source in this case) of the iterator
  • new file lemon/bits/stl_iterators.h

    diff --git a/lemon/bits/stl_iterators.h b/lemon/bits/stl_iterators.h
    new file mode 100644
    - +  
     1/* -*- mode: C++; indent-tabs-mode: nil; -*-
     2 */
     3
     4#ifndef STL_ITERATORS_H_
     5#define STL_ITERATORS_H_
     6
     7#include <lemon/core.h>
     8
     9namespace lemon {
     10
     11  /// \brief Template to make STL iterators from Lemon iterators.
     12  ///
     13  /// This template makes an STL iterator from a Lemon iterator
     14  /// by adding the missing features.
     15  /// It inherits from \c std::iterator to make \c iterator_concept work
     16  /// (so that STL algorithms work).
     17  /// \c T should be the lemon iterator to be decorated.
     18  template<class T>
     19  struct LemonItWrapper
     20      : public T, public std::iterator<std::input_iterator_tag, T> {
     21
     22    LemonItWrapper(const T &x) : T(x) {}
     23
     24    //Lemon iterators don't have operator*, (because they rather
     25    //inherit from their "value_type"),
     26    //so we add one that just returns the object.
     27    const T& operator*() const {
     28      return static_cast<const T&>(*this);
     29    }
     30
     31    //I can't think of any use case for this with Lemon iterators,
     32    //but maybe it should be included for completeness.
     33    const T* operator->() {
     34      return static_cast<const T*>(this);
     35    }
     36
     37    //Lemon iterators don't have postincrement.
     38    void operator++(int) {
     39      T::operator++();
     40    }
     41
     42    using T::operator++;
     43
     44  };
     45
     46
     47  /// \brief A generic wrapper for Lemon iterators for range-based for loops.
     48  ///
     49  /// This template can be used to create a class
     50  /// that has begin() and end() from a Lemon iterator
     51  /// (with a 1-parameter constructor)
     52  /// to make range-based for loops and STL algorithms work.
     53  ///
     54  /// \c LIT is the Lemon iterator that will be wrapped
     55  /// \c P is the type of the parameter of the constructor of \c LIT.
     56  template<class LIT, class P>
     57  class LemonRangeWrapper1 {
     58    const P &_p;
     59    typedef LemonItWrapper<LIT> It;
     60  public:
     61    LemonRangeWrapper1(const P &p) : _p(p) {}
     62    It begin() const {
     63      return It(LIT(_p));
     64    }
     65    It end() const {
     66      return It(lemon::INVALID);
     67    }
     68  };
     69
     70
     71  /// \brief A generic wrapper for Lemon iterators for range-based for loops.
     72  ///
     73  /// This template can be used to create a class
     74  /// that has begin() and end() from a Lemon iterator
     75  /// (with a 2-parameter constructor)
     76  /// to make range-based for loops and STL algorithms work.
     77  ///
     78  /// \c LIT is the Lemon iterator that will be wrapped
     79  /// \c P1 and \c P2 are the types of the parameters
     80  /// of the constructor of \c LIT.
     81  template<class LIT, class P1, class P2>
     82  class LemonRangeWrapper2 {
     83    const P1 &_p1;
     84    const P2 &_p2;
     85    typedef LemonItWrapper<LIT> It;
     86  public:
     87    LemonRangeWrapper2(const P1 &p1, const P2 &p2) : _p1(p1), _p2(p2) {}
     88    It begin() const {
     89      return It(LIT(_p1, _p2));
     90    }
     91    It end() const {
     92      return It(lemon::INVALID);
     93    }
     94  };
     95
     96
     97}
     98
     99#endif /* STL_ITERATORS_H_ */
  • lemon/cbc.cc

    diff --git a/lemon/cbc.cc b/lemon/cbc.cc
    a b  
    111111  }
    112112
    113113  void CbcMip::_eraseColId(int i) {
    114     cols.eraseIndex(i);
     114    _cols.eraseIndex(i);
    115115  }
    116116
    117117  void CbcMip::_eraseRowId(int i) {
    118     rows.eraseIndex(i);
     118    _rows.eraseIndex(i);
    119119  }
    120120
    121121  void CbcMip::_getColName(int c, std::string& name) const {
  • lemon/clp.cc

    diff --git a/lemon/clp.cc b/lemon/clp.cc
    a b  
    2929
    3030  ClpLp::ClpLp(const ClpLp& other) {
    3131    _prob = new ClpSimplex(*other._prob);
    32     rows = other.rows;
    33     cols = other.cols;
     32    _rows = other._rows;
     33    _cols = other._cols;
    3434    _init_temporals();
    3535    messageLevel(MESSAGE_NOTHING);
    3636  }
     
    103103  }
    104104
    105105  void ClpLp::_eraseColId(int i) {
    106     cols.eraseIndex(i);
    107     cols.shiftIndices(i);
     106    _cols.eraseIndex(i);
     107    _cols.shiftIndices(i);
    108108  }
    109109
    110110  void ClpLp::_eraseRowId(int i) {
    111     rows.eraseIndex(i);
    112     rows.shiftIndices(i);
     111    _rows.eraseIndex(i);
     112    _rows.shiftIndices(i);
    113113  }
    114114
    115115  void ClpLp::_getColName(int c, std::string& name) const {
  • lemon/clp.h

    diff --git a/lemon/clp.h b/lemon/clp.h
    a b  
    151151    SolveExitStatus solveBarrier();
    152152
    153153    ///Returns the constraint identifier understood by CLP.
    154     int clpRow(Row r) const { return rows(id(r)); }
     154    int clpRow(Row r) const { return _rows(id(r)); }
    155155
    156156    ///Returns the variable identifier understood by CLP.
    157     int clpCol(Col c) const { return cols(id(c)); }
     157    int clpCol(Col c) const { return _cols(id(c)); }
    158158
    159159  };
    160160
  • lemon/concepts/bpgraph.h

    diff --git a/lemon/concepts/bpgraph.h b/lemon/concepts/bpgraph.h
    a b  
    2727#include <lemon/concepts/maps.h>
    2828#include <lemon/concept_check.h>
    2929#include <lemon/core.h>
     30#include <lemon/bits/stl_iterators.h>
    3031
    3132namespace lemon {
    3233  namespace concepts {
     
    221222        RedNodeIt& operator++() { return *this; }
    222223      };
    223224
     225      /// \brief Gets the collection of the red nodes of the graph.
     226      ///
     227      /// This function can be used for iterating on
     228      /// the red nodes of the graph. It returns a wrapped RedNodeIt,
     229      /// which looks like an STL container (by having begin() and end())
     230      /// which you can use in range-based for loops, stl algorithms, etc.
     231      /// For example if g is a BpGraph, you can write:
     232      ///\code
     233      /// for(auto v: g.redNodes())
     234      ///   doSomething(v);
     235      ///\endcode
     236      LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
     237        return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
     238      }
     239
     240
    224241      /// Iterator class for the blue nodes.
    225242
    226243      /// This iterator goes through each blue node of the graph.
     
    264281        BlueNodeIt& operator++() { return *this; }
    265282      };
    266283
     284      /// \brief Gets the collection of the blue nodes of the graph.
     285      ///
     286      /// This function can be used for iterating on
     287      /// the blue nodes of the graph. It returns a wrapped BlueNodeIt,
     288      /// which looks like an STL container (by having begin() and end())
     289      /// which you can use in range-based for loops, stl algorithms, etc.
     290      /// For example if g is a BpGraph, you can write:
     291      ///\code
     292      /// for(auto v: g.blueNodes())
     293      ///   doSomething(v);
     294      ///\endcode
     295      LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
     296        return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
     297      }
     298
     299
    267300      /// Iterator class for the nodes.
    268301
    269302      /// This iterator goes through each node of the graph.
     
    307340        NodeIt& operator++() { return *this; }
    308341      };
    309342
     343      /// \brief Gets the collection of the nodes of the graph.
     344      ///
     345      /// This function can be used for iterating on
     346      /// the nodes of the graph. It returns a wrapped NodeIt,
     347      /// which looks like an STL container (by having begin() and end())
     348      /// which you can use in range-based for loops, stl algorithms, etc.
     349      /// For example if g is a BpGraph, you can write:
     350      ///\code
     351      /// for(auto v: g.nodes())
     352      ///   doSomething(v);
     353      ///\endcode
     354      LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
     355        return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
     356      }
     357
     358
    310359
    311360      /// The edge type of the graph
    312361
     
    395444        EdgeIt& operator++() { return *this; }
    396445      };
    397446
     447      /// \brief Gets the collection of the edges of the graph.
     448      ///
     449      /// This function can be used for iterating on the
     450      /// edges of the graph. It returns a wrapped
     451      /// EdgeIt, which looks like an STL container
     452      /// (by having begin() and end()) which you can use in range-based
     453      /// for loops, stl algorithms, etc.
     454      /// For example if g is a BpGraph, you can write:
     455      ///\code
     456      /// for(auto e: g.edges())
     457      ///   doSomething(e);
     458      ///\endcode
     459      LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
     460        return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
     461      }
     462
     463
    398464      /// Iterator class for the incident edges of a node.
    399465
    400466      /// This iterator goes trough the incident undirected edges
     
    443509        IncEdgeIt& operator++() { return *this; }
    444510      };
    445511
     512      /// \brief Gets the collection of the incident edges
     513      ///  of a certain node of the graph.
     514      ///
     515      /// This function can be used for iterating on the
     516      /// incident undirected edges of a certain node of the graph.
     517      /// It returns a wrapped
     518      /// IncEdgeIt, which looks like an STL container
     519      /// (by having begin() and end()) which you can use in range-based
     520      /// for loops, stl algorithms, etc.
     521      /// For example if g is a BpGraph and u is a Node, you can write:
     522      ///\code
     523      /// for(auto e: g.incEdges(u))
     524      ///   doSomething(e);
     525      ///\endcode
     526      LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
     527        return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
     528      }
     529
     530
    446531      /// The arc type of the graph
    447532
    448533      /// This class identifies a directed arc of the graph. It also serves
     
    539624        ArcIt& operator++() { return *this; }
    540625      };
    541626
     627      /// \brief Gets the collection of the directed arcs of the graph.
     628      ///
     629      /// This function can be used for iterating on the
     630      /// arcs of the graph. It returns a wrapped
     631      /// ArcIt, which looks like an STL container
     632      /// (by having begin() and end()) which you can use in range-based
     633      /// for loops, stl algorithms, etc.
     634      /// For example if g is a BpGraph you can write:
     635      ///\code
     636      /// for(auto a: g.arcs())
     637      ///   doSomething(a);
     638      ///\endcode
     639      LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
     640        return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
     641      }
     642
     643
    542644      /// Iterator class for the outgoing arcs of a node.
    543645
    544646      /// This iterator goes trough the \e outgoing directed arcs of a
     
    587689        OutArcIt& operator++() { return *this; }
    588690      };
    589691
     692      /// \brief Gets the collection of the outgoing directed arcs of a
     693      /// certain node of the graph.
     694      ///
     695      /// This function can be used for iterating on the
     696      /// outgoing arcs of a certain node of the graph. It returns a wrapped
     697      /// OutArcIt, which looks like an STL container
     698      /// (by having begin() and end()) which you can use in range-based
     699      /// for loops, stl algorithms, etc.
     700      /// For example if g is a BpGraph and u is a Node, you can write:
     701      ///\code
     702      /// for(auto a: g.outArcs(u))
     703      ///   doSomething(a);
     704      ///\endcode
     705      LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
     706        return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
     707      }
     708
     709
    590710      /// Iterator class for the incoming arcs of a node.
    591711
    592712      /// This iterator goes trough the \e incoming directed arcs of a
     
    635755        InArcIt& operator++() { return *this; }
    636756      };
    637757
     758      /// \brief Gets the collection of the incoming directed arcs of a
     759      /// certain node of the graph.
     760      ///
     761      /// This function can be used for iterating on the
     762      /// incoming arcs of a certain node of the graph. It returns a wrapped
     763      /// InArcIt, which looks like an STL container
     764      /// (by having begin() and end()) which you can use in range-based
     765      /// for loops, stl algorithms, etc.
     766      /// For example if g is a BpGraph and u is a Node, you can write:
     767      ///\code
     768      /// for(auto a: g.inArcs(u))
     769      ///   doSomething(a);
     770      ///\endcode
     771      LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
     772        return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
     773      }
     774
     775
    638776      /// \brief Standard graph map type for the nodes.
    639777      ///
    640778      /// Standard graph map type for the nodes.
  • lemon/concepts/digraph.h

    diff --git a/lemon/concepts/digraph.h b/lemon/concepts/digraph.h
    a b  
    2727#include <lemon/concepts/maps.h>
    2828#include <lemon/concept_check.h>
    2929#include <lemon/concepts/graph_components.h>
     30#include <lemon/bits/stl_iterators.h>
    3031
    3132namespace lemon {
    3233  namespace concepts {
     
    147148        NodeIt& operator++() { return *this; }
    148149      };
    149150
     151      /// \brief Gets the collection of the nodes of the digraph.
     152      ///
     153      /// This function can be used for iterating on
     154      /// the nodes of the digraph. It returns a wrapped NodeIt, which looks
     155      /// like an STL container (by having begin() and end())
     156      /// which you can use in range-based for loops, STL algorithms, etc.
     157      /// For example you can write:
     158      ///\code
     159      /// ListDigraph g;
     160      /// for(auto v: g.nodes())
     161      ///   doSomething(v);
     162      ///
     163      /// //Using an STL algorithm:
     164      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
     165      ///\endcode
     166      LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
     167        return LemonRangeWrapper1<NodeIt, Digraph>(*this);
     168      }
     169
    150170
    151171      /// The arc type of the digraph
    152172
     
    237257        OutArcIt& operator++() { return *this; }
    238258      };
    239259
     260      /// \brief Gets the collection of the outgoing arcs of a certain node
     261      /// of the digraph.
     262      ///
     263      /// This function can be used for iterating on the
     264      /// outgoing arcs of a certain node of the digraph. It returns a wrapped
     265      /// OutArcIt, which looks like an STL container
     266      /// (by having begin() and end()) which you can use in range-based
     267      /// for loops, STL algorithms, etc.
     268      /// For example if g is a Digraph and u is a node, you can write:
     269      ///\code
     270      /// for(auto a: g.outArcs(u))
     271      ///   doSomething(a);
     272      ///
     273      /// //Using an STL algorithm:
     274      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
     275      ///\endcode
     276      LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
     277        return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
     278      }
     279
     280
    240281      /// Iterator class for the incoming arcs of a node.
    241282
    242283      /// This iterator goes trough the \e incoming arcs of a certain node
     
    282323        InArcIt& operator++() { return *this; }
    283324      };
    284325
     326      /// \brief Gets the collection of the incoming arcs of a certain node
     327      /// of the digraph.
     328      ///
     329      /// This function can be used for iterating on the
     330      /// incoming arcs of a certain node of the digraph. It returns a wrapped
     331      /// InArcIt, which looks like an STL container
     332      /// (by having begin() and end()) which you can use in range-based
     333      /// for loops, STL algorithms, etc.
     334      /// For example if g is a Digraph and u is a node, you can write:
     335      ///\code
     336      /// for(auto a: g.inArcs(u))
     337      ///   doSomething(a);
     338      ///
     339      /// //Using an STL algorithm:
     340      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
     341      ///\endcode
     342      LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
     343        return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
     344      }
     345
     346
    285347      /// Iterator class for the arcs.
    286348
    287349      /// This iterator goes through each arc of the digraph.
     
    327389        ArcIt& operator++() { return *this; }
    328390      };
    329391
     392      /// \brief Gets the collection of the arcs of the digraph.
     393      ///
     394      /// This function can be used for iterating on the
     395      /// arcs of the digraph. It returns a wrapped
     396      /// ArcIt, which looks like an STL container
     397      /// (by having begin() and end()) which you can use in range-based
     398      /// for loops, STL algorithms, etc.
     399      /// For example you can write:
     400      ///\code
     401      /// ListDigraph g;
     402      /// for(auto a: g.arcs())
     403      ///   doSomething(a);
     404      ///
     405      /// //Using an STL algorithm:
     406      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
     407      ///\endcode
     408      LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
     409        return LemonRangeWrapper1<ArcIt, Digraph>(*this);
     410      }
     411
     412
    330413      /// \brief The source node of the arc.
    331414      ///
    332415      /// Returns the source node of the given arc.
  • lemon/concepts/graph.h

    diff --git a/lemon/concepts/graph.h b/lemon/concepts/graph.h
    a b  
    2727#include <lemon/concepts/maps.h>
    2828#include <lemon/concept_check.h>
    2929#include <lemon/core.h>
     30#include <lemon/bits/stl_iterators.h>
    3031
    3132namespace lemon {
    3233  namespace concepts {
     
    180181        NodeIt& operator++() { return *this; }
    181182      };
    182183
     184      /// \brief Gets the collection of the nodes of the graph.
     185      ///
     186      /// This function can be used for iterating on
     187      /// the nodes of the graph. It returns a wrapped NodeIt, which looks
     188      /// like an STL container (by having begin() and end())
     189      /// which you can use in range-based for loops, STL algorithms, etc.
     190      /// For example you can write:
     191      ///\code
     192      /// ListGraph g;
     193      /// for(auto v: g.nodes())
     194      ///   doSomething(v);
     195      ///
     196      /// //Using an STL algorithm:
     197      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
     198      ///\endcode
     199      LemonRangeWrapper1<NodeIt, Graph> nodes() const {
     200        return LemonRangeWrapper1<NodeIt, Graph>(*this);
     201      }
     202
    183203
    184204      /// The edge type of the graph
    185205
     
    268288        EdgeIt& operator++() { return *this; }
    269289      };
    270290
     291      /// \brief Gets the collection of the edges of the graph.
     292      ///
     293      /// This function can be used for iterating on the
     294      /// edges of the graph. It returns a wrapped
     295      /// EdgeIt, which looks like an STL container
     296      /// (by having begin() and end()) which you can use in range-based
     297      /// for loops, STL algorithms, etc.
     298      /// For example you can write:
     299      ///\code
     300      /// ListGraph g;
     301      /// for(auto e: g.edges())
     302      ///   doSomething(e);
     303      ///
     304      /// //Using an STL algorithm:
     305      /// copy(g.edges().begin(), g.edges().end(), vect.begin());
     306      ///\endcode
     307      LemonRangeWrapper1<EdgeIt, Graph> edges() const {
     308        return LemonRangeWrapper1<EdgeIt, Graph>(*this);
     309      }
     310
     311
    271312      /// Iterator class for the incident edges of a node.
    272313
    273314      /// This iterator goes trough the incident undirected edges
     
    316357        IncEdgeIt& operator++() { return *this; }
    317358      };
    318359
     360      /// \brief Gets the collection of the incident undirected edges
     361      ///  of a certain node of the graph.
     362      ///
     363      /// This function can be used for iterating on the
     364      /// incident undirected edges of a certain node of the graph.
     365      /// It returns a wrapped
     366      /// IncEdgeIt, which looks like an STL container
     367      /// (by having begin() and end()) which you can use in range-based
     368      /// for loops, STL algorithms, etc.
     369      /// For example if g is a Graph and u is a Node, you can write:
     370      ///\code
     371      /// for(auto e: g.incEdges(u))
     372      ///   doSomething(e);
     373      ///
     374      /// //Using an STL algorithm:
     375      /// copy(g.incEdges(u).begin(), g.incEdges(u).end(), vect.begin());
     376      ///\endcode
     377      LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
     378        return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
     379      }
     380
     381
    319382      /// The arc type of the graph
    320383
    321384      /// This class identifies a directed arc of the graph. It also serves
     
    411474        ArcIt& operator++() { return *this; }
    412475      };
    413476
     477      /// \brief Gets the collection of the directed arcs of the graph.
     478      ///
     479      /// This function can be used for iterating on the
     480      /// arcs of the graph. It returns a wrapped
     481      /// ArcIt, which looks like an STL container
     482      /// (by having begin() and end()) which you can use in range-based
     483      /// for loops, STL algorithms, etc.
     484      /// For example you can write:
     485      ///\code
     486      /// ListGraph g;
     487      /// for(auto a: g.arcs())
     488      ///   doSomething(a);
     489      ///
     490      /// //Using an STL algorithm:
     491      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
     492      ///\endcode
     493      LemonRangeWrapper1<ArcIt, Graph> arcs() const {
     494        return LemonRangeWrapper1<ArcIt, Graph>(*this);
     495      }
     496
     497
    414498      /// Iterator class for the outgoing arcs of a node.
    415499
    416500      /// This iterator goes trough the \e outgoing directed arcs of a
     
    459543        OutArcIt& operator++() { return *this; }
    460544      };
    461545
     546      /// \brief Gets the collection of the outgoing directed arcs of a
     547      /// certain node of the graph.
     548      ///
     549      /// This function can be used for iterating on the
     550      /// outgoing arcs of a certain node of the graph. It returns a wrapped
     551      /// OutArcIt, which looks like an STL container
     552      /// (by having begin() and end()) which you can use in range-based
     553      /// for loops, STL algorithms, etc.
     554      /// For example if g is a Graph and u is a Node, you can write:
     555      ///\code
     556      /// for(auto a: g.outArcs(u))
     557      ///   doSomething(a);
     558      ///
     559      /// //Using an STL algorithm:
     560      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
     561      ///\endcode
     562      LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
     563        return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
     564      }
     565
     566
    462567      /// Iterator class for the incoming arcs of a node.
    463568
    464569      /// This iterator goes trough the \e incoming directed arcs of a
     
    507612        InArcIt& operator++() { return *this; }
    508613      };
    509614
     615      /// \brief Gets the collection of the incoming directed arcs of
     616      /// a certain node of the graph.
     617      ///
     618      /// This function can be used for iterating on the
     619      /// incoming directed arcs of a certain node of the graph. It returns
     620      /// a wrapped InArcIt, which looks like an STL container
     621      /// (by having begin() and end()) which you can use in range-based
     622      /// for loops, STL algorithms, etc.
     623      /// For example if g is a Graph and u is a Node, you can write:
     624      ///\code
     625      /// for(auto a: g.inArcs(u))
     626      ///   doSomething(a);
     627      ///
     628      /// //Using an STL algorithm:
     629      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
     630      ///\endcode
     631      LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
     632        return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
     633      }
     634
    510635      /// \brief Standard graph map type for the nodes.
    511636      ///
    512637      /// Standard graph map type for the nodes.
  • lemon/concepts/path.h

    diff --git a/lemon/concepts/path.h b/lemon/concepts/path.h
    a b  
    2626
    2727#include <lemon/core.h>
    2828#include <lemon/concept_check.h>
     29#include <lemon/bits/stl_iterators.h>
    2930
    3031namespace lemon {
    3132  namespace concepts {
     
    115116
    116117      };
    117118
     119      /// \brief Gets the collection of the arcs of the path.
     120      ///
     121      /// This function can be used for iterating on the
     122      /// arcs of the path. It returns a wrapped
     123      /// ArcIt, which looks like an STL container
     124      /// (by having begin() and end()) which you can use in range-based
     125      /// for loops, STL algorithms, etc.
     126      /// For example you can write:
     127      ///\code
     128      /// for(auto a: p.arcs())
     129      ///   doSomething(a);
     130      ///\endcode
     131      LemonRangeWrapper1<ArcIt, Path> arcs() const {
     132        return LemonRangeWrapper1<ArcIt, Path>(*this);
     133      }
     134
     135
    118136      template <typename _Path>
    119137      struct Constraints {
    120138        void constraints() {
     
    264282
    265283      };
    266284
     285      /// \brief Gets the collection of the arcs of the path.
     286      ///
     287      /// This function can be used for iterating on the
     288      /// arcs of the path. It returns a wrapped
     289      /// ArcIt, which looks like an STL container
     290      /// (by having begin() and end()) which you can use in range-based
     291      /// for loops, STL algorithms, etc.
     292      /// For example you can write:
     293      ///\code
     294      /// for(auto a: p.arcs())
     295      ///   doSomething(a);
     296      ///\endcode
     297      LemonRangeWrapper1<ArcIt, PathDumper> arcs() const {
     298        return LemonRangeWrapper1<ArcIt, PathDumper>(*this);
     299      }
     300
     301
    267302      /// \brief LEMON style iterator for enumerating the arcs of a path
    268303      /// in reverse direction.
    269304      ///
     
    293328
    294329      };
    295330
     331      /// \brief Gets the collection of the arcs of the path
     332      /// in reverse direction.
     333      ///
     334      /// This function can be used for iterating on the
     335      /// arcs of the path in reverse direction. It returns a wrapped
     336      /// RevArcIt, which looks like an STL container
     337      /// (by having begin() and end()) which you can use in range-based
     338      /// for loops, STL algorithms, etc.
     339      /// For example you can write:
     340      ///\code
     341      /// for(auto a: p.revArcs())
     342      ///   doSomething(a);
     343      ///\endcode
     344      LemonRangeWrapper1<RevArcIt, PathDumper> revArcs() const {
     345        return LemonRangeWrapper1<RevArcIt, PathDumper>(*this);
     346      }
     347
     348
    296349      template <typename _Path>
    297350      struct Constraints {
    298351        void constraints() {
  • lemon/cplex.cc

    diff --git a/lemon/cplex.cc b/lemon/cplex.cc
    a b  
    8787    : LpBase() {
    8888    int status;
    8989    _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);
    90     rows = cplex.rows;
    91     cols = cplex.cols;
     90    _rows = cplex._rows;
     91    _cols = cplex._cols;
    9292    messageLevel(MESSAGE_NOTHING);
    9393  }
    9494
     
    158158  }
    159159
    160160  void CplexBase::_eraseColId(int i) {
    161     cols.eraseIndex(i);
    162     cols.shiftIndices(i);
     161    _cols.eraseIndex(i);
     162    _cols.shiftIndices(i);
    163163  }
    164164  void CplexBase::_eraseRowId(int i) {
    165     rows.eraseIndex(i);
    166     rows.shiftIndices(i);
     165    _rows.eraseIndex(i);
     166    _rows.shiftIndices(i);
    167167  }
    168168
    169169  void CplexBase::_getColName(int col, std::string &name) const {
  • lemon/glpk.cc

    diff --git a/lemon/glpk.cc b/lemon/glpk.cc
    a b  
    3838    lp = glp_create_prob();
    3939    glp_copy_prob(lp, other.lp, GLP_ON);
    4040    glp_create_index(lp);
    41     rows = other.rows;
    42     cols = other.cols;
     41    _rows = other._rows;
     42    _cols = other._cols;
    4343    messageLevel(MESSAGE_NOTHING);
    4444  }
    4545
     
    108108  }
    109109
    110110  void GlpkBase::_eraseColId(int i) {
    111     cols.eraseIndex(i);
    112     cols.shiftIndices(i);
     111    _cols.eraseIndex(i);
     112    _cols.shiftIndices(i);
    113113  }
    114114
    115115  void GlpkBase::_eraseRowId(int i) {
    116     rows.eraseIndex(i);
    117     rows.shiftIndices(i);
     116    _rows.eraseIndex(i);
     117    _rows.shiftIndices(i);
    118118  }
    119119
    120120  void GlpkBase::_getColName(int c, std::string& name) const {
  • lemon/glpk.h

    diff --git a/lemon/glpk.h b/lemon/glpk.h
    a b  
    141141    _solver_bits::VoidPtr lpx() const {return lp;}
    142142
    143143    ///Returns the constraint identifier understood by GLPK.
    144     int lpxRow(Row r) const { return rows(id(r)); }
     144    int lpxRow(Row r) const { return _rows(id(r)); }
    145145
    146146    ///Returns the variable identifier understood by GLPK.
    147     int lpxCol(Col c) const { return cols(id(c)); }
     147    int lpxCol(Col c) const { return _cols(id(c)); }
    148148
    149149#ifdef DOXYGEN
    150150    /// Write the problem or the solution to a file in the given format
  • lemon/list_graph.h

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    4848      int next_in, next_out;
    4949    };
    5050
    51     std::vector<NodeT> nodes;
     51    std::vector<NodeT> _nodes;
    5252
    5353    int first_node;
    5454
    5555    int first_free_node;
    5656
    57     std::vector<ArcT> arcs;
     57    std::vector<ArcT> _arcs;
    5858
    5959    int first_free_arc;
    6060
     
    9797
    9898
    9999    ListDigraphBase()
    100       : nodes(), first_node(-1),
    101         first_free_node(-1), arcs(), first_free_arc(-1) {}
    102 
    103 
    104     int maxNodeId() const { return nodes.size()-1; }
    105     int maxArcId() const { return arcs.size()-1; }
    106 
    107     Node source(Arc e) const { return Node(arcs[e.id].source); }
    108     Node target(Arc e) const { return Node(arcs[e.id].target); }
     100      : _nodes(), first_node(-1),
     101        first_free_node(-1), _arcs(), first_free_arc(-1) {}
     102
     103
     104    int maxNodeId() const { return _nodes.size()-1; }
     105    int maxArcId() const { return _arcs.size()-1; }
     106
     107    Node source(Arc e) const { return Node(_arcs[e.id].source); }
     108    Node target(Arc e) const { return Node(_arcs[e.id].target); }
    109109
    110110
    111111    void first(Node& node) const {
     
    113113    }
    114114
    115115    void next(Node& node) const {
    116       node.id = nodes[node.id].next;
     116      node.id = _nodes[node.id].next;
    117117    }
    118118
    119119
    120120    void first(Arc& arc) const {
    121121      int n;
    122122      for(n = first_node;
    123           n != -1 && nodes[n].first_out == -1;
    124           n = nodes[n].next) {}
    125       arc.id = (n == -1) ? -1 : nodes[n].first_out;
     123          n != -1 && _nodes[n].first_out == -1;
     124          n = _nodes[n].next) {}
     125      arc.id = (n == -1) ? -1 : _nodes[n].first_out;
    126126    }
    127127
    128128    void next(Arc& arc) const {
    129       if (arcs[arc.id].next_out != -1) {
    130         arc.id = arcs[arc.id].next_out;
     129      if (_arcs[arc.id].next_out != -1) {
     130        arc.id = _arcs[arc.id].next_out;
    131131      } else {
    132132        int n;
    133         for(n = nodes[arcs[arc.id].source].next;
    134             n != -1 && nodes[n].first_out == -1;
    135             n = nodes[n].next) {}
    136         arc.id = (n == -1) ? -1 : nodes[n].first_out;
     133        for(n = _nodes[_arcs[arc.id].source].next;
     134            n != -1 && _nodes[n].first_out == -1;
     135            n = _nodes[n].next) {}
     136        arc.id = (n == -1) ? -1 : _nodes[n].first_out;
    137137      }
    138138    }
    139139
    140140    void firstOut(Arc &e, const Node& v) const {
    141       e.id = nodes[v.id].first_out;
     141      e.id = _nodes[v.id].first_out;
    142142    }
    143143    void nextOut(Arc &e) const {
    144       e.id=arcs[e.id].next_out;
     144      e.id=_arcs[e.id].next_out;
    145145    }
    146146
    147147    void firstIn(Arc &e, const Node& v) const {
    148       e.id = nodes[v.id].first_in;
     148      e.id = _nodes[v.id].first_in;
    149149    }
    150150    void nextIn(Arc &e) const {
    151       e.id=arcs[e.id].next_in;
     151      e.id=_arcs[e.id].next_in;
    152152    }
    153153
    154154
     
    159159    static Arc arcFromId(int id) { return Arc(id);}
    160160
    161161    bool valid(Node n) const {
    162       return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
    163         nodes[n.id].prev != -2;
     162      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
     163        _nodes[n.id].prev != -2;
    164164    }
    165165
    166166    bool valid(Arc a) const {
    167       return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
    168         arcs[a.id].prev_in != -2;
     167      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
     168        _arcs[a.id].prev_in != -2;
    169169    }
    170170
    171171    Node addNode() {
    172172      int n;
    173173
    174174      if(first_free_node==-1) {
    175         n = nodes.size();
    176         nodes.push_back(NodeT());
     175        n = _nodes.size();
     176        _nodes.push_back(NodeT());
    177177      } else {
    178178        n = first_free_node;
    179         first_free_node = nodes[n].next;
     179        first_free_node = _nodes[n].next;
    180180      }
    181181
    182       nodes[n].next = first_node;
    183       if(first_node != -1) nodes[first_node].prev = n;
     182      _nodes[n].next = first_node;
     183      if(first_node != -1) _nodes[first_node].prev = n;
    184184      first_node = n;
    185       nodes[n].prev = -1;
    186 
    187       nodes[n].first_in = nodes[n].first_out = -1;
     185      _nodes[n].prev = -1;
     186
     187      _nodes[n].first_in = _nodes[n].first_out = -1;
    188188
    189189      return Node(n);
    190190    }
     
    193193      int n;
    194194
    195195      if (first_free_arc == -1) {
    196         n = arcs.size();
    197         arcs.push_back(ArcT());
     196        n = _arcs.size();
     197        _arcs.push_back(ArcT());
    198198      } else {
    199199        n = first_free_arc;
    200         first_free_arc = arcs[n].next_in;
     200        first_free_arc = _arcs[n].next_in;
    201201      }
    202202
    203       arcs[n].source = u.id;
    204       arcs[n].target = v.id;
    205 
    206       arcs[n].next_out = nodes[u.id].first_out;
    207       if(nodes[u.id].first_out != -1) {
    208         arcs[nodes[u.id].first_out].prev_out = n;
     203      _arcs[n].source = u.id;
     204      _arcs[n].target = v.id;
     205
     206      _arcs[n].next_out = _nodes[u.id].first_out;
     207      if(_nodes[u.id].first_out != -1) {
     208        _arcs[_nodes[u.id].first_out].prev_out = n;
    209209      }
    210210
    211       arcs[n].next_in = nodes[v.id].first_in;
    212       if(nodes[v.id].first_in != -1) {
    213         arcs[nodes[v.id].first_in].prev_in = n;
     211      _arcs[n].next_in = _nodes[v.id].first_in;
     212      if(_nodes[v.id].first_in != -1) {
     213        _arcs[_nodes[v.id].first_in].prev_in = n;
    214214      }
    215215
    216       arcs[n].prev_in = arcs[n].prev_out = -1;
    217 
    218       nodes[u.id].first_out = nodes[v.id].first_in = n;
     216      _arcs[n].prev_in = _arcs[n].prev_out = -1;
     217
     218      _nodes[u.id].first_out = _nodes[v.id].first_in = n;
    219219
    220220      return Arc(n);
    221221    }
     
    223223    void erase(const Node& node) {
    224224      int n = node.id;
    225225
    226       if(nodes[n].next != -1) {
    227         nodes[nodes[n].next].prev = nodes[n].prev;
     226      if(_nodes[n].next != -1) {
     227        _nodes[_nodes[n].next].prev = _nodes[n].prev;
    228228      }
    229229
    230       if(nodes[n].prev != -1) {
    231         nodes[nodes[n].prev].next = nodes[n].next;
     230      if(_nodes[n].prev != -1) {
     231        _nodes[_nodes[n].prev].next = _nodes[n].next;
    232232      } else {
    233         first_node = nodes[n].next;
     233        first_node = _nodes[n].next;
    234234      }
    235235
    236       nodes[n].next = first_free_node;
     236      _nodes[n].next = first_free_node;
    237237      first_free_node = n;
    238       nodes[n].prev = -2;
     238      _nodes[n].prev = -2;
    239239
    240240    }
    241241
    242242    void erase(const Arc& arc) {
    243243      int n = arc.id;
    244244
    245       if(arcs[n].next_in!=-1) {
    246         arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
     245      if(_arcs[n].next_in!=-1) {
     246        _arcs[_arcs[n].next_in].prev_in = _arcs[n].prev_in;
    247247      }
    248248
    249       if(arcs[n].prev_in!=-1) {
    250         arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
     249      if(_arcs[n].prev_in!=-1) {
     250        _arcs[_arcs[n].prev_in].next_in = _arcs[n].next_in;
    251251      } else {
    252         nodes[arcs[n].target].first_in = arcs[n].next_in;
     252        _nodes[_arcs[n].target].first_in = _arcs[n].next_in;
    253253      }
    254254
    255255
    256       if(arcs[n].next_out!=-1) {
    257         arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
     256      if(_arcs[n].next_out!=-1) {
     257        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
    258258      }
    259259
    260       if(arcs[n].prev_out!=-1) {
    261         arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
     260      if(_arcs[n].prev_out!=-1) {
     261        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
    262262      } else {
    263         nodes[arcs[n].source].first_out = arcs[n].next_out;
     263        _nodes[_arcs[n].source].first_out = _arcs[n].next_out;
    264264      }
    265265
    266       arcs[n].next_in = first_free_arc;
     266      _arcs[n].next_in = first_free_arc;
    267267      first_free_arc = n;
    268       arcs[n].prev_in = -2;
     268      _arcs[n].prev_in = -2;
    269269    }
    270270
    271271    void clear() {
    272       arcs.clear();
    273       nodes.clear();
     272      _arcs.clear();
     273      _nodes.clear();
    274274      first_node = first_free_node = first_free_arc = -1;
    275275    }
    276276
    277277  protected:
    278278    void changeTarget(Arc e, Node n)
    279279    {
    280       if(arcs[e.id].next_in != -1)
    281         arcs[arcs[e.id].next_in].prev_in = arcs[e.id].prev_in;
    282       if(arcs[e.id].prev_in != -1)
    283         arcs[arcs[e.id].prev_in].next_in = arcs[e.id].next_in;
    284       else nodes[arcs[e.id].target].first_in = arcs[e.id].next_in;
    285       if (nodes[n.id].first_in != -1) {
    286         arcs[nodes[n.id].first_in].prev_in = e.id;
     280      if(_arcs[e.id].next_in != -1)
     281        _arcs[_arcs[e.id].next_in].prev_in = _arcs[e.id].prev_in;
     282      if(_arcs[e.id].prev_in != -1)
     283        _arcs[_arcs[e.id].prev_in].next_in = _arcs[e.id].next_in;
     284      else _nodes[_arcs[e.id].target].first_in = _arcs[e.id].next_in;
     285      if (_nodes[n.id].first_in != -1) {
     286        _arcs[_nodes[n.id].first_in].prev_in = e.id;
    287287      }
    288       arcs[e.id].target = n.id;
    289       arcs[e.id].prev_in = -1;
    290       arcs[e.id].next_in = nodes[n.id].first_in;
    291       nodes[n.id].first_in = e.id;
     288      _arcs[e.id].target = n.id;
     289      _arcs[e.id].prev_in = -1;
     290      _arcs[e.id].next_in = _nodes[n.id].first_in;
     291      _nodes[n.id].first_in = e.id;
    292292    }
    293293    void changeSource(Arc e, Node n)
    294294    {
    295       if(arcs[e.id].next_out != -1)
    296         arcs[arcs[e.id].next_out].prev_out = arcs[e.id].prev_out;
    297       if(arcs[e.id].prev_out != -1)
    298         arcs[arcs[e.id].prev_out].next_out = arcs[e.id].next_out;
    299       else nodes[arcs[e.id].source].first_out = arcs[e.id].next_out;
    300       if (nodes[n.id].first_out != -1) {
    301         arcs[nodes[n.id].first_out].prev_out = e.id;
     295      if(_arcs[e.id].next_out != -1)
     296        _arcs[_arcs[e.id].next_out].prev_out = _arcs[e.id].prev_out;
     297      if(_arcs[e.id].prev_out != -1)
     298        _arcs[_arcs[e.id].prev_out].next_out = _arcs[e.id].next_out;
     299      else _nodes[_arcs[e.id].source].first_out = _arcs[e.id].next_out;
     300      if (_nodes[n.id].first_out != -1) {
     301        _arcs[_nodes[n.id].first_out].prev_out = e.id;
    302302      }
    303       arcs[e.id].source = n.id;
    304       arcs[e.id].prev_out = -1;
    305       arcs[e.id].next_out = nodes[n.id].first_out;
    306       nodes[n.id].first_out = e.id;
     303      _arcs[e.id].source = n.id;
     304      _arcs[e.id].prev_out = -1;
     305      _arcs[e.id].next_out = _nodes[n.id].first_out;
     306      _nodes[n.id].first_out = e.id;
    307307    }
    308308
    309309  };
     
    486486    ///Snapshot feature.
    487487    Node split(Node n, bool connect = true) {
    488488      Node b = addNode();
    489       nodes[b.id].first_out=nodes[n.id].first_out;
    490       nodes[n.id].first_out=-1;
    491       for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
    492         arcs[i].source=b.id;
     489      _nodes[b.id].first_out=_nodes[n.id].first_out;
     490      _nodes[n.id].first_out=-1;
     491      for(int i=_nodes[b.id].first_out; i!=-1; i=_arcs[i].next_out) {
     492        _arcs[i].source=b.id;
    493493      }
    494494      if (connect) addArc(n,b);
    495495      return b;
     
    532532    /// then it is worth reserving space for this amount before starting
    533533    /// to build the digraph.
    534534    /// \sa reserveArc()
    535     void reserveNode(int n) { nodes.reserve(n); };
     535    void reserveNode(int n) { _nodes.reserve(n); };
    536536
    537537    /// Reserve memory for arcs.
    538538
     
    542542    /// then it is worth reserving space for this amount before starting
    543543    /// to build the digraph.
    544544    /// \sa reserveNode()
    545     void reserveArc(int m) { arcs.reserve(m); };
     545    void reserveArc(int m) { _arcs.reserve(m); };
    546546
    547547    /// \brief Class to make a snapshot of the digraph and restore
    548548    /// it later.
     
    803803      int prev_out, next_out;
    804804    };
    805805
    806     std::vector<NodeT> nodes;
     806    std::vector<NodeT> _nodes;
    807807
    808808    int first_node;
    809809
    810810    int first_free_node;
    811811
    812     std::vector<ArcT> arcs;
     812    std::vector<ArcT> _arcs;
    813813
    814814    int first_free_arc;
    815815
     
    867867    };
    868868
    869869    ListGraphBase()
    870       : nodes(), first_node(-1),
    871         first_free_node(-1), arcs(), first_free_arc(-1) {}
    872 
    873 
    874     int maxNodeId() const { return nodes.size()-1; }
    875     int maxEdgeId() const { return arcs.size() / 2 - 1; }
    876     int maxArcId() const { return arcs.size()-1; }
    877 
    878     Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
    879     Node target(Arc e) const { return Node(arcs[e.id].target); }
    880 
    881     Node u(Edge e) const { return Node(arcs[2 * e.id].target); }
    882     Node v(Edge e) const { return Node(arcs[2 * e.id + 1].target); }
     870      : _nodes(), first_node(-1),
     871        first_free_node(-1), _arcs(), first_free_arc(-1) {}
     872
     873
     874    int maxNodeId() const { return _nodes.size()-1; }
     875    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
     876    int maxArcId() const { return _arcs.size()-1; }
     877
     878    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
     879    Node target(Arc e) const { return Node(_arcs[e.id].target); }
     880
     881    Node u(Edge e) const { return Node(_arcs[2 * e.id].target); }
     882    Node v(Edge e) const { return Node(_arcs[2 * e.id + 1].target); }
    883883
    884884    static bool direction(Arc e) {
    885885      return (e.id & 1) == 1;
     
    894894    }
    895895
    896896    void next(Node& node) const {
    897       node.id = nodes[node.id].next;
     897      node.id = _nodes[node.id].next;
    898898    }
    899899
    900900    void first(Arc& e) const {
    901901      int n = first_node;
    902       while (n != -1 && nodes[n].first_out == -1) {
    903         n = nodes[n].next;
     902      while (n != -1 && _nodes[n].first_out == -1) {
     903        n = _nodes[n].next;
    904904      }
    905       e.id = (n == -1) ? -1 : nodes[n].first_out;
     905      e.id = (n == -1) ? -1 : _nodes[n].first_out;
    906906    }
    907907
    908908    void next(Arc& e) const {
    909       if (arcs[e.id].next_out != -1) {
    910         e.id = arcs[e.id].next_out;
     909      if (_arcs[e.id].next_out != -1) {
     910        e.id = _arcs[e.id].next_out;
    911911      } else {
    912         int n = nodes[arcs[e.id ^ 1].target].next;
    913         while(n != -1 && nodes[n].first_out == -1) {
    914           n = nodes[n].next;
     912        int n = _nodes[_arcs[e.id ^ 1].target].next;
     913        while(n != -1 && _nodes[n].first_out == -1) {
     914          n = _nodes[n].next;
    915915        }
    916         e.id = (n == -1) ? -1 : nodes[n].first_out;
     916        e.id = (n == -1) ? -1 : _nodes[n].first_out;
    917917      }
    918918    }
    919919
    920920    void first(Edge& e) const {
    921921      int n = first_node;
    922922      while (n != -1) {
    923         e.id = nodes[n].first_out;
     923        e.id = _nodes[n].first_out;
    924924        while ((e.id & 1) != 1) {
    925           e.id = arcs[e.id].next_out;
     925          e.id = _arcs[e.id].next_out;
    926926        }
    927927        if (e.id != -1) {
    928928          e.id /= 2;
    929929          return;
    930930        }
    931         n = nodes[n].next;
     931        n = _nodes[n].next;
    932932      }
    933933      e.id = -1;
    934934    }
    935935
    936936    void next(Edge& e) const {
    937       int n = arcs[e.id * 2].target;
    938       e.id = arcs[(e.id * 2) | 1].next_out;
     937      int n = _arcs[e.id * 2].target;
     938      e.id = _arcs[(e.id * 2) | 1].next_out;
    939939      while ((e.id & 1) != 1) {
    940         e.id = arcs[e.id].next_out;
     940        e.id = _arcs[e.id].next_out;
    941941      }
    942942      if (e.id != -1) {
    943943        e.id /= 2;
    944944        return;
    945945      }
    946       n = nodes[n].next;
     946      n = _nodes[n].next;
    947947      while (n != -1) {
    948         e.id = nodes[n].first_out;
     948        e.id = _nodes[n].first_out;
    949949        while ((e.id & 1) != 1) {
    950           e.id = arcs[e.id].next_out;
     950          e.id = _arcs[e.id].next_out;
    951951        }
    952952        if (e.id != -1) {
    953953          e.id /= 2;
    954954          return;
    955955        }
    956         n = nodes[n].next;
     956        n = _nodes[n].next;
    957957      }
    958958      e.id = -1;
    959959    }
    960960
    961961    void firstOut(Arc &e, const Node& v) const {
    962       e.id = nodes[v.id].first_out;
     962      e.id = _nodes[v.id].first_out;
    963963    }
    964964    void nextOut(Arc &e) const {
    965       e.id = arcs[e.id].next_out;
     965      e.id = _arcs[e.id].next_out;
    966966    }
    967967
    968968    void firstIn(Arc &e, const Node& v) const {
    969       e.id = ((nodes[v.id].first_out) ^ 1);
     969      e.id = ((_nodes[v.id].first_out) ^ 1);
    970970      if (e.id == -2) e.id = -1;
    971971    }
    972972    void nextIn(Arc &e) const {
    973       e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
     973      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
    974974      if (e.id == -2) e.id = -1;
    975975    }
    976976
    977977    void firstInc(Edge &e, bool& d, const Node& v) const {
    978       int a = nodes[v.id].first_out;
     978      int a = _nodes[v.id].first_out;
    979979      if (a != -1 ) {
    980980        e.id = a / 2;
    981981        d = ((a & 1) == 1);
     
    985985      }
    986986    }
    987987    void nextInc(Edge &e, bool& d) const {
    988       int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
     988      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
    989989      if (a != -1 ) {
    990990        e.id = a / 2;
    991991        d = ((a & 1) == 1);
     
    10041004    static Edge edgeFromId(int id) { return Edge(id);}
    10051005
    10061006    bool valid(Node n) const {
    1007       return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
    1008         nodes[n.id].prev != -2;
     1007      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
     1008        _nodes[n.id].prev != -2;
    10091009    }
    10101010
    10111011    bool valid(Arc a) const {
    1012       return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
    1013         arcs[a.id].prev_out != -2;
     1012      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
     1013        _arcs[a.id].prev_out != -2;
    10141014    }
    10151015
    10161016    bool valid(Edge e) const {
    1017       return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
    1018         arcs[2 * e.id].prev_out != -2;
     1017      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
     1018        _arcs[2 * e.id].prev_out != -2;
    10191019    }
    10201020
    10211021    Node addNode() {
    10221022      int n;
    10231023
    10241024      if(first_free_node==-1) {
    1025         n = nodes.size();
    1026         nodes.push_back(NodeT());
     1025        n = _nodes.size();
     1026        _nodes.push_back(NodeT());
    10271027      } else {
    10281028        n = first_free_node;
    1029         first_free_node = nodes[n].next;
     1029        first_free_node = _nodes[n].next;
    10301030      }
    10311031
    1032       nodes[n].next = first_node;
    1033       if (first_node != -1) nodes[first_node].prev = n;
     1032      _nodes[n].next = first_node;
     1033      if (first_node != -1) _nodes[first_node].prev = n;
    10341034      first_node = n;
    1035       nodes[n].prev = -1;
    1036 
    1037       nodes[n].first_out = -1;
     1035      _nodes[n].prev = -1;
     1036
     1037      _nodes[n].first_out = -1;
    10381038
    10391039      return Node(n);
    10401040    }
     
    10431043      int n;
    10441044
    10451045      if (first_free_arc == -1) {
    1046         n = arcs.size();
    1047         arcs.push_back(ArcT());
    1048         arcs.push_back(ArcT());
     1046        n = _arcs.size();
     1047        _arcs.push_back(ArcT());
     1048        _arcs.push_back(ArcT());
    10491049      } else {
    10501050        n = first_free_arc;
    1051         first_free_arc = arcs[n].next_out;
     1051        first_free_arc = _arcs[n].next_out;
    10521052      }
    10531053
    1054       arcs[n].target = u.id;
    1055       arcs[n | 1].target = v.id;
    1056 
    1057       arcs[n].next_out = nodes[v.id].first_out;
    1058       if (nodes[v.id].first_out != -1) {
    1059         arcs[nodes[v.id].first_out].prev_out = n;
     1054      _arcs[n].target = u.id;
     1055      _arcs[n | 1].target = v.id;
     1056
     1057      _arcs[n].next_out = _nodes[v.id].first_out;
     1058      if (_nodes[v.id].first_out != -1) {
     1059        _arcs[_nodes[v.id].first_out].prev_out = n;
    10601060      }
    1061       arcs[n].prev_out = -1;
    1062       nodes[v.id].first_out = n;
    1063 
    1064       arcs[n | 1].next_out = nodes[u.id].first_out;
    1065       if (nodes[u.id].first_out != -1) {
    1066         arcs[nodes[u.id].first_out].prev_out = (n | 1);
     1061      _arcs[n].prev_out = -1;
     1062      _nodes[v.id].first_out = n;
     1063
     1064      _arcs[n | 1].next_out = _nodes[u.id].first_out;
     1065      if (_nodes[u.id].first_out != -1) {
     1066        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
    10671067      }
    1068       arcs[n | 1].prev_out = -1;
    1069       nodes[u.id].first_out = (n | 1);
     1068      _arcs[n | 1].prev_out = -1;
     1069      _nodes[u.id].first_out = (n | 1);
    10701070
    10711071      return Edge(n / 2);
    10721072    }
     
    10741074    void erase(const Node& node) {
    10751075      int n = node.id;
    10761076
    1077       if(nodes[n].next != -1) {
    1078         nodes[nodes[n].next].prev = nodes[n].prev;
     1077      if(_nodes[n].next != -1) {
     1078        _nodes[_nodes[n].next].prev = _nodes[n].prev;
    10791079      }
    10801080
    1081       if(nodes[n].prev != -1) {
    1082         nodes[nodes[n].prev].next = nodes[n].next;
     1081      if(_nodes[n].prev != -1) {
     1082        _nodes[_nodes[n].prev].next = _nodes[n].next;
    10831083      } else {
    1084         first_node = nodes[n].next;
     1084        first_node = _nodes[n].next;
    10851085      }
    10861086
    1087       nodes[n].next = first_free_node;
     1087      _nodes[n].next = first_free_node;
    10881088      first_free_node = n;
    1089       nodes[n].prev = -2;
     1089      _nodes[n].prev = -2;
    10901090    }
    10911091
    10921092    void erase(const Edge& edge) {
    10931093      int n = edge.id * 2;
    10941094
    1095       if (arcs[n].next_out != -1) {
    1096         arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
     1095      if (_arcs[n].next_out != -1) {
     1096        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
    10971097      }
    10981098
    1099       if (arcs[n].prev_out != -1) {
    1100         arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
     1099      if (_arcs[n].prev_out != -1) {
     1100        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
    11011101      } else {
    1102         nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
     1102        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
    11031103      }
    11041104
    1105       if (arcs[n | 1].next_out != -1) {
    1106         arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
     1105      if (_arcs[n | 1].next_out != -1) {
     1106        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
    11071107      }
    11081108
    1109       if (arcs[n | 1].prev_out != -1) {
    1110         arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
     1109      if (_arcs[n | 1].prev_out != -1) {
     1110        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
    11111111      } else {
    1112         nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
     1112        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
    11131113      }
    11141114
    1115       arcs[n].next_out = first_free_arc;
     1115      _arcs[n].next_out = first_free_arc;
    11161116      first_free_arc = n;
    1117       arcs[n].prev_out = -2;
    1118       arcs[n | 1].prev_out = -2;
     1117      _arcs[n].prev_out = -2;
     1118      _arcs[n | 1].prev_out = -2;
    11191119
    11201120    }
    11211121
    11221122    void clear() {
    1123       arcs.clear();
    1124       nodes.clear();
     1123      _arcs.clear();
     1124      _nodes.clear();
    11251125      first_node = first_free_node = first_free_arc = -1;
    11261126    }
    11271127
    11281128  protected:
    11291129
    11301130    void changeV(Edge e, Node n) {
    1131       if(arcs[2 * e.id].next_out != -1) {
    1132         arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
     1131      if(_arcs[2 * e.id].next_out != -1) {
     1132        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
    11331133      }
    1134       if(arcs[2 * e.id].prev_out != -1) {
    1135         arcs[arcs[2 * e.id].prev_out].next_out =
    1136           arcs[2 * e.id].next_out;
     1134      if(_arcs[2 * e.id].prev_out != -1) {
     1135        _arcs[_arcs[2 * e.id].prev_out].next_out =
     1136          _arcs[2 * e.id].next_out;
    11371137      } else {
    1138         nodes[arcs[(2 * e.id) | 1].target].first_out =
    1139           arcs[2 * e.id].next_out;
     1138        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
     1139          _arcs[2 * e.id].next_out;
    11401140      }
    11411141
    1142       if (nodes[n.id].first_out != -1) {
    1143         arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
     1142      if (_nodes[n.id].first_out != -1) {
     1143        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
    11441144      }
    1145       arcs[(2 * e.id) | 1].target = n.id;
    1146       arcs[2 * e.id].prev_out = -1;
    1147       arcs[2 * e.id].next_out = nodes[n.id].first_out;
    1148       nodes[n.id].first_out = 2 * e.id;
     1145      _arcs[(2 * e.id) | 1].target = n.id;
     1146      _arcs[2 * e.id].prev_out = -1;
     1147      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
     1148      _nodes[n.id].first_out = 2 * e.id;
    11491149    }
    11501150
    11511151    void changeU(Edge e, Node n) {
    1152       if(arcs[(2 * e.id) | 1].next_out != -1) {
    1153         arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
    1154           arcs[(2 * e.id) | 1].prev_out;
     1152      if(_arcs[(2 * e.id) | 1].next_out != -1) {
     1153        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
     1154          _arcs[(2 * e.id) | 1].prev_out;
    11551155      }
    1156       if(arcs[(2 * e.id) | 1].prev_out != -1) {
    1157         arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
    1158           arcs[(2 * e.id) | 1].next_out;
     1156      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
     1157        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
     1158          _arcs[(2 * e.id) | 1].next_out;
    11591159      } else {
    1160         nodes[arcs[2 * e.id].target].first_out =
    1161           arcs[(2 * e.id) | 1].next_out;
     1160        _nodes[_arcs[2 * e.id].target].first_out =
     1161          _arcs[(2 * e.id) | 1].next_out;
    11621162      }
    11631163
    1164       if (nodes[n.id].first_out != -1) {
    1165         arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
     1164      if (_nodes[n.id].first_out != -1) {
     1165        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
    11661166      }
    1167       arcs[2 * e.id].target = n.id;
    1168       arcs[(2 * e.id) | 1].prev_out = -1;
    1169       arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
    1170       nodes[n.id].first_out = ((2 * e.id) | 1);
     1167      _arcs[2 * e.id].target = n.id;
     1168      _arcs[(2 * e.id) | 1].prev_out = -1;
     1169      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
     1170      _nodes[n.id].first_out = ((2 * e.id) | 1);
    11711171    }
    11721172
    11731173  };
     
    13441344    /// then it is worth reserving space for this amount before starting
    13451345    /// to build the graph.
    13461346    /// \sa reserveEdge()
    1347     void reserveNode(int n) { nodes.reserve(n); };
     1347    void reserveNode(int n) { _nodes.reserve(n); };
    13481348
    13491349    /// Reserve memory for edges.
    13501350
     
    13541354    /// then it is worth reserving space for this amount before starting
    13551355    /// to build the graph.
    13561356    /// \sa reserveNode()
    1357     void reserveEdge(int m) { arcs.reserve(2 * m); };
     1357    void reserveEdge(int m) { _arcs.reserve(2 * m); };
    13581358
    13591359    /// \brief Class to make a snapshot of the graph and restore
    13601360    /// it later.
     
    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/lp_base.h

    diff --git a/lemon/lp_base.h b/lemon/lp_base.h
    a b  
    3131#include<lemon/core.h>
    3232#include<lemon/bits/solver_bits.h>
    3333
     34#include<lemon/bits/stl_iterators.h>
     35
    3436///\file
    3537///\brief The interface of the LP solver interface.
    3638///\ingroup lp_group
     
    4547
    4648  protected:
    4749
    48     _solver_bits::VarIndex rows;
    49     _solver_bits::VarIndex cols;
     50    _solver_bits::VarIndex _rows;
     51    _solver_bits::VarIndex _cols;
    5052
    5153  public:
    5254
     
    166168      ///
    167169      ColIt(const LpBase &solver) : _solver(&solver)
    168170      {
    169         _solver->cols.firstItem(_id);
     171        _solver->_cols.firstItem(_id);
    170172      }
    171173      /// Invalid constructor \& conversion
    172174
     
    179181      ///
    180182      ColIt &operator++()
    181183      {
    182         _solver->cols.nextItem(_id);
     184        _solver->_cols.nextItem(_id);
    183185        return *this;
    184186      }
    185187    };
    186188
     189    /// \brief Gets the collection of the columns of the LP problem.
     190    ///
     191    /// This function can be used for iterating on
     192    /// the columns of the LP problem. It returns a wrapped ColIt, which looks
     193    /// like an STL container (by having begin() and end())
     194    /// which you can use in range-based for loops, STL algorithms, etc.
     195    /// For example you can write:
     196    ///\code
     197    /// for(auto c: lp.cols())
     198    ///   doSomething(c);
     199    LemonRangeWrapper1<ColIt, LpBase> cols() {
     200      return LemonRangeWrapper1<ColIt, LpBase>(*this);
     201    }
     202
     203
    187204    /// \brief Returns the ID of the column.
    188205    static int id(const Col& col) { return col._id; }
    189206    /// \brief Returns the column with the given ID.
     
    261278      ///
    262279      RowIt(const LpBase &solver) : _solver(&solver)
    263280      {
    264         _solver->rows.firstItem(_id);
     281        _solver->_rows.firstItem(_id);
    265282      }
    266283      /// Invalid constructor \& conversion
    267284
     
    274291      ///
    275292      RowIt &operator++()
    276293      {
    277         _solver->rows.nextItem(_id);
     294        _solver->_rows.nextItem(_id);
    278295        return *this;
    279296      }
    280297    };
     298   
     299    /// \brief Gets the collection of the rows of the LP problem.
     300    ///
     301    /// This function can be used for iterating on
     302    /// the rows of the LP problem. It returns a wrapped RowIt, which looks
     303    /// like an STL container (by having begin() and end())
     304    /// which you can use in range-based for loops, STL algorithms, etc.
     305    /// For example you can write:
     306    ///\code
     307    /// for(auto c: lp.rows())
     308    ///   doSomething(c);
     309    LemonRangeWrapper1<RowIt, LpBase> rows() {
     310      return LemonRangeWrapper1<RowIt, LpBase>(*this);
     311    }
     312   
    281313
    282314    /// \brief Returns the ID of the row.
    283315    static int id(const Row& row) { return row._id; }
     
    934966
    935967    //Abstract virtual functions
    936968
    937     virtual int _addColId(int col) { return cols.addIndex(col); }
    938     virtual int _addRowId(int row) { return rows.addIndex(row); }
     969    virtual int _addColId(int col) { return _cols.addIndex(col); }
     970    virtual int _addRowId(int row) { return _rows.addIndex(row); }
    939971
    940     virtual void _eraseColId(int col) { cols.eraseIndex(col); }
    941     virtual void _eraseRowId(int row) { rows.eraseIndex(row); }
     972    virtual void _eraseColId(int col) { _cols.eraseIndex(col); }
     973    virtual void _eraseRowId(int row) { _rows.eraseIndex(row); }
    942974
    943975    virtual int _addCol() = 0;
    944976    virtual int _addRow() = 0;
     
    10031035    //Constant component of the objective function
    10041036    Value obj_const_comp;
    10051037
    1006     LpBase() : rows(), cols(), obj_const_comp(0) {}
     1038    LpBase() : _rows(), _cols(), obj_const_comp(0) {}
    10071039
    10081040  public:
    10091041
     
    11151147    ///a better one.
    11161148    void col(Col c, const DualExpr &e) {
    11171149      e.simplify();
    1118       _setColCoeffs(cols(id(c)), ExprIterator(e.comps.begin(), rows),
    1119                     ExprIterator(e.comps.end(), rows));
     1150      _setColCoeffs(_cols(id(c)), ExprIterator(e.comps.begin(), _rows),
     1151                    ExprIterator(e.comps.end(), _rows));
    11201152    }
    11211153
    11221154    ///Get a column (i.e a dual constraint) of the LP
     
    11251157    ///\return the dual expression associated to the column
    11261158    DualExpr col(Col c) const {
    11271159      DualExpr e;
    1128       _getColCoeffs(cols(id(c)), InsertIterator(e.comps, rows));
     1160      _getColCoeffs(_cols(id(c)), InsertIterator(e.comps, _rows));
    11291161      return e;
    11301162    }
    11311163
     
    12121244    ///\param u is the upper bound (\ref INF means no bound)
    12131245    void row(Row r, Value l, const Expr &e, Value u) {
    12141246      e.simplify();
    1215       _setRowCoeffs(rows(id(r)), ExprIterator(e.comps.begin(), cols),
    1216                     ExprIterator(e.comps.end(), cols));
    1217       _setRowLowerBound(rows(id(r)),l - *e);
    1218       _setRowUpperBound(rows(id(r)),u - *e);
     1247      _setRowCoeffs(_rows(id(r)), ExprIterator(e.comps.begin(), _cols),
     1248                    ExprIterator(e.comps.end(), _cols));
     1249      _setRowLowerBound(_rows(id(r)),l - *e);
     1250      _setRowUpperBound(_rows(id(r)),u - *e);
    12191251    }
    12201252
    12211253    ///Set a row (i.e a constraint) of the LP
     
    12341266    ///\return the expression associated to the row
    12351267    Expr row(Row r) const {
    12361268      Expr e;
    1237       _getRowCoeffs(rows(id(r)), InsertIterator(e.comps, cols));
     1269      _getRowCoeffs(_rows(id(r)), InsertIterator(e.comps, _cols));
    12381270      return e;
    12391271    }
    12401272
     
    12471279    Row addRow(Value l,const Expr &e, Value u) {
    12481280      Row r;
    12491281      e.simplify();
    1250       r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
    1251                                 ExprIterator(e.comps.end(), cols), u - *e));
     1282      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), _cols),
     1283                                ExprIterator(e.comps.end(), _cols), u - *e));
    12521284      return r;
    12531285    }
    12541286
     
    12601292      Row r;
    12611293      c.expr().simplify();
    12621294      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
    1263                                 ExprIterator(c.expr().comps.begin(), cols),
    1264                                 ExprIterator(c.expr().comps.end(), cols),
     1295                                ExprIterator(c.expr().comps.begin(), _cols),
     1296                                ExprIterator(c.expr().comps.end(), _cols),
    12651297                                c.upperBounded()?c.upperBound()-*c.expr():INF));
    12661298      return r;
    12671299    }
     
    12691301
    12701302    ///\param c is the column to be deleted
    12711303    void erase(Col c) {
    1272       _eraseCol(cols(id(c)));
    1273       _eraseColId(cols(id(c)));
     1304      _eraseCol(_cols(id(c)));
     1305      _eraseColId(_cols(id(c)));
    12741306    }
    12751307    ///Erase a row (i.e a constraint) from the LP
    12761308
    12771309    ///\param r is the row to be deleted
    12781310    void erase(Row r) {
    1279       _eraseRow(rows(id(r)));
    1280       _eraseRowId(rows(id(r)));
     1311      _eraseRow(_rows(id(r)));
     1312      _eraseRowId(_rows(id(r)));
    12811313    }
    12821314
    12831315    /// Get the name of a column
     
    12861318    ///\return The name of the colunm
    12871319    std::string colName(Col c) const {
    12881320      std::string name;
    1289       _getColName(cols(id(c)), name);
     1321      _getColName(_cols(id(c)), name);
    12901322      return name;
    12911323    }
    12921324
     
    12951327    ///\param c is the coresponding column
    12961328    ///\param name The name to be given
    12971329    void colName(Col c, const std::string& name) {
    1298       _setColName(cols(id(c)), name);
     1330      _setColName(_cols(id(c)), name);
    12991331    }
    13001332
    13011333    /// Get the column by its name
     
    13041336    ///\return the proper column or \c INVALID
    13051337    Col colByName(const std::string& name) const {
    13061338      int k = _colByName(name);
    1307       return k != -1 ? Col(cols[k]) : Col(INVALID);
     1339      return k != -1 ? Col(_cols[k]) : Col(INVALID);
    13081340    }
    13091341
    13101342    /// Get the name of a row
     
    13131345    ///\return The name of the row
    13141346    std::string rowName(Row r) const {
    13151347      std::string name;
    1316       _getRowName(rows(id(r)), name);
     1348      _getRowName(_rows(id(r)), name);
    13171349      return name;
    13181350    }
    13191351
     
    13221354    ///\param r is the coresponding row
    13231355    ///\param name The name to be given
    13241356    void rowName(Row r, const std::string& name) {
    1325       _setRowName(rows(id(r)), name);
     1357      _setRowName(_rows(id(r)), name);
    13261358    }
    13271359
    13281360    /// Get the row by its name
     
    13311363    ///\return the proper row or \c INVALID
    13321364    Row rowByName(const std::string& name) const {
    13331365      int k = _rowByName(name);
    1334       return k != -1 ? Row(rows[k]) : Row(INVALID);
     1366      return k != -1 ? Row(_rows[k]) : Row(INVALID);
    13351367    }
    13361368
    13371369    /// Set an element of the coefficient matrix of the LP
     
    13401372    ///\param c is the column of the element to be modified
    13411373    ///\param val is the new value of the coefficient
    13421374    void coeff(Row r, Col c, Value val) {
    1343       _setCoeff(rows(id(r)),cols(id(c)), val);
     1375      _setCoeff(_rows(id(r)),_cols(id(c)), val);
    13441376    }
    13451377
    13461378    /// Get an element of the coefficient matrix of the LP
     
    13491381    ///\param c is the column of the element
    13501382    ///\return the corresponding coefficient
    13511383    Value coeff(Row r, Col c) const {
    1352       return _getCoeff(rows(id(r)),cols(id(c)));
     1384      return _getCoeff(_rows(id(r)),_cols(id(c)));
    13531385    }
    13541386
    13551387    /// Set the lower bound of a column (i.e a variable)
     
    13581390    /// extended number of type Value, i.e. a finite number of type
    13591391    /// Value or -\ref INF.
    13601392    void colLowerBound(Col c, Value value) {
    1361       _setColLowerBound(cols(id(c)),value);
     1393      _setColLowerBound(_cols(id(c)),value);
    13621394    }
    13631395
    13641396    /// Get the lower bound of a column (i.e a variable)
     
    13671399    /// (this might be -\ref INF as well).
    13681400    ///\return The lower bound for column \c c
    13691401    Value colLowerBound(Col c) const {
    1370       return _getColLowerBound(cols(id(c)));
     1402      return _getColLowerBound(_cols(id(c)));
    13711403    }
    13721404
    13731405    ///\brief Set the lower bound of  several columns
     
    14131445    /// extended number of type Value, i.e. a finite number of type
    14141446    /// Value or \ref INF.
    14151447    void colUpperBound(Col c, Value value) {
    1416       _setColUpperBound(cols(id(c)),value);
     1448      _setColUpperBound(_cols(id(c)),value);
    14171449    };
    14181450
    14191451    /// Get the upper bound of a column (i.e a variable)
     
    14221454    /// (this might be \ref INF as well).
    14231455    /// \return The upper bound for column \c c
    14241456    Value colUpperBound(Col c) const {
    1425       return _getColUpperBound(cols(id(c)));
     1457      return _getColUpperBound(_cols(id(c)));
    14261458    }
    14271459
    14281460    ///\brief Set the upper bound of  several columns
     
    14691501    /// extended number of type Value, i.e. a finite number of type
    14701502    /// Value, -\ref INF or \ref INF.
    14711503    void colBounds(Col c, Value lower, Value upper) {
    1472       _setColLowerBound(cols(id(c)),lower);
    1473       _setColUpperBound(cols(id(c)),upper);
     1504      _setColLowerBound(_cols(id(c)),lower);
     1505      _setColUpperBound(_cols(id(c)),upper);
    14741506    }
    14751507
    14761508    ///\brief Set the lower and the upper bound of several columns
     
    15151547    /// extended number of type Value, i.e. a finite number of type
    15161548    /// Value or -\ref INF.
    15171549    void rowLowerBound(Row r, Value value) {
    1518       _setRowLowerBound(rows(id(r)),value);
     1550      _setRowLowerBound(_rows(id(r)),value);
    15191551    }
    15201552
    15211553    /// Get the lower bound of a row (i.e a constraint)
     
    15241556    /// (this might be -\ref INF as well).
    15251557    ///\return The lower bound for row \c r
    15261558    Value rowLowerBound(Row r) const {
    1527       return _getRowLowerBound(rows(id(r)));
     1559      return _getRowLowerBound(_rows(id(r)));
    15281560    }
    15291561
    15301562    /// Set the upper bound of a row (i.e a constraint)
     
    15331565    /// extended number of type Value, i.e. a finite number of type
    15341566    /// Value or -\ref INF.
    15351567    void rowUpperBound(Row r, Value value) {
    1536       _setRowUpperBound(rows(id(r)),value);
     1568      _setRowUpperBound(_rows(id(r)),value);
    15371569    }
    15381570
    15391571    /// Get the upper bound of a row (i.e a constraint)
     
    15421574    /// (this might be -\ref INF as well).
    15431575    ///\return The upper bound for row \c r
    15441576    Value rowUpperBound(Row r) const {
    1545       return _getRowUpperBound(rows(id(r)));
     1577      return _getRowUpperBound(_rows(id(r)));
    15461578    }
    15471579
    15481580    ///Set an element of the objective function
    1549     void objCoeff(Col c, Value v) {_setObjCoeff(cols(id(c)),v); };
     1581    void objCoeff(Col c, Value v) {_setObjCoeff(_cols(id(c)),v); };
    15501582
    15511583    ///Get an element of the objective function
    1552     Value objCoeff(Col c) const { return _getObjCoeff(cols(id(c))); };
     1584    Value objCoeff(Col c) const { return _getObjCoeff(_cols(id(c))); };
    15531585
    15541586    ///Set the objective function
    15551587
    15561588    ///\param e is a linear expression of type \ref Expr.
    15571589    ///
    15581590    void obj(const Expr& e) {
    1559       _setObjCoeffs(ExprIterator(e.comps.begin(), cols),
    1560                     ExprIterator(e.comps.end(), cols));
     1591      _setObjCoeffs(ExprIterator(e.comps.begin(), _cols),
     1592                    ExprIterator(e.comps.end(), _cols));
    15611593      obj_const_comp = *e;
    15621594    }
    15631595
     
    15671599    ///Expr.
    15681600    Expr obj() const {
    15691601      Expr e;
    1570       _getObjCoeffs(InsertIterator(e.comps, cols));
     1602      _getObjCoeffs(InsertIterator(e.comps, _cols));
    15711603      *e = obj_const_comp;
    15721604      return e;
    15731605    }
     
    15861618    void min() { _setSense(MIN); }
    15871619
    15881620    ///Clear the problem
    1589     void clear() { _clear(); rows.clear(); cols.clear(); }
     1621    void clear() { _clear(); _rows.clear(); _cols.clear(); }
    15901622
    15911623    /// Set the message level of the solver
    15921624    void messageLevel(MessageLevel level) { _messageLevel(level); }
     
    19291961
    19301962    /// Return the primal value of the column.
    19311963    /// \pre The problem is solved.
    1932     Value primal(Col c) const { return _getPrimal(cols(id(c))); }
     1964    Value primal(Col c) const { return _getPrimal(_cols(id(c))); }
    19331965
    19341966    /// Return the primal value of the expression
    19351967
     
    19561988    /// \pre The problem is solved and the dual problem is infeasible.
    19571989    /// \note Some solvers does not provide primal ray calculation
    19581990    /// functions.
    1959     Value primalRay(Col c) const { return _getPrimalRay(cols(id(c))); }
     1991    Value primalRay(Col c) const { return _getPrimalRay(_cols(id(c))); }
    19601992
    19611993    /// Return the dual value of the row
    19621994
    19631995    /// Return the dual value of the row.
    19641996    /// \pre The problem is solved.
    1965     Value dual(Row r) const { return _getDual(rows(id(r))); }
     1997    Value dual(Row r) const { return _getDual(_rows(id(r))); }
    19661998
    19671999    /// Return the dual value of the dual expression
    19682000
     
    19902022    /// \pre The problem is solved and the primal problem is infeasible.
    19912023    /// \note Some solvers does not provide dual ray calculation
    19922024    /// functions.
    1993     Value dualRay(Row r) const { return _getDualRay(rows(id(r))); }
     2025    Value dualRay(Row r) const { return _getDualRay(_rows(id(r))); }
    19942026
    19952027    /// Return the basis status of the column
    19962028
    19972029    /// \see VarStatus
    1998     VarStatus colStatus(Col c) const { return _getColStatus(cols(id(c))); }
     2030    VarStatus colStatus(Col c) const { return _getColStatus(_cols(id(c))); }
    19992031
    20002032    /// Return the basis status of the row
    20012033
    20022034    /// \see VarStatus
    2003     VarStatus rowStatus(Row r) const { return _getRowStatus(rows(id(r))); }
     2035    VarStatus rowStatus(Row r) const { return _getRowStatus(_rows(id(r))); }
    20042036
    20052037    ///The value of the objective function
    20062038
     
    20802112    ///Sets the type of the given column to the given type.
    20812113    ///
    20822114    void colType(Col c, ColTypes col_type) {
    2083       _setColType(cols(id(c)),col_type);
     2115      _setColType(_cols(id(c)),col_type);
    20842116    }
    20852117
    20862118    ///Gives back the type of the column.
     
    20882120    ///Gives back the type of the column.
    20892121    ///
    20902122    ColTypes colType(Col c) const {
    2091       return _getColType(cols(id(c)));
     2123      return _getColType(_cols(id(c)));
    20922124    }
    20932125    ///@}
    20942126
     
    21052137
    21062138    ///  Return the value of the row in the solution.
    21072139    /// \pre The problem is solved.
    2108     Value sol(Col c) const { return _getSol(cols(id(c))); }
     2140    Value sol(Col c) const { return _getSol(_cols(id(c))); }
    21092141
    21102142    /// Return the value of the expression in the solution
    21112143
  • lemon/maps.h

    diff --git a/lemon/maps.h b/lemon/maps.h
    a b  
    2525#include <map>
    2626
    2727#include <lemon/core.h>
     28#include <lemon/bits/stl_iterators.h>
    2829
    2930///\file
    3031///\ingroup maps
     
    25812582      const IterableBoolMap* _map;
    25822583    };
    25832584
     2585    /// \brief STL style iterator for the keys mapped to \c true.
     2586    ///
     2587    /// This is an STL style wrapper for \ref TrueIt.
     2588    /// It can be used in range-based for loops, STL algorithms, etc.
     2589    LemonRangeWrapper1<TrueIt, IterableBoolMap>
     2590    trueKeys() {
     2591      return LemonRangeWrapper1<TrueIt, IterableBoolMap>(*this);
     2592    }
     2593
     2594
    25842595    /// \brief Iterator for the keys mapped to \c false.
    25852596    ///
    25862597    /// Iterator for the keys mapped to \c false. It works
     
    26202631      const IterableBoolMap* _map;
    26212632    };
    26222633
     2634    /// \brief STL style iterator for the keys mapped to \c false.
     2635    ///
     2636    /// This is an STL style wrapper for \ref FalseIt.
     2637    /// It can be used in range-based for loops, STL algorithms, etc.
     2638    LemonRangeWrapper1<FalseIt, IterableBoolMap>
     2639    falseKeys() {
     2640      return LemonRangeWrapper1<FalseIt, IterableBoolMap>(*this);
     2641    }
     2642
     2643
    26232644    /// \brief Iterator for the keys mapped to a given value.
    26242645    ///
    26252646    /// Iterator for the keys mapped to a given value. It works
     
    26642685      const IterableBoolMap* _map;
    26652686    };
    26662687
     2688    /// \brief STL style iterator for the keys mapped to a given value.
     2689    ///
     2690    /// This is an STL style wrapper for \ref ItemIt.
     2691    /// It can be used in range-based for loops, STL algorithms, etc.
     2692    LemonRangeWrapper2<ItemIt, IterableBoolMap, bool>
     2693    items(bool value) {
     2694      return LemonRangeWrapper2<ItemIt, IterableBoolMap, bool>(*this, value);
     2695    }
     2696
    26672697  protected:
    26682698
    26692699    virtual void add(const Key& key) {
     
    30053035      const IterableIntMap* _map;
    30063036    };
    30073037
     3038    /// \brief STL style iterator for the keys with the same value.
     3039    ///
     3040    /// This is an STL style wrapper for \ref ItemIt.
     3041    /// It can be used in range-based for loops, STL algorithms, etc.
     3042    LemonRangeWrapper2<ItemIt, IterableIntMap, int>
     3043    items(int value) {
     3044      return LemonRangeWrapper2<ItemIt, IterableIntMap, int>(*this, value);
     3045    }
     3046
     3047
    30083048  protected:
    30093049
    30103050    virtual void erase(const Key& key) {
     
    32483288      const IterableValueMap* _map;
    32493289    };
    32503290
     3291    /// \brief STL style iterator for the keys with the same value.
     3292    ///
     3293    /// This is an STL style wrapper for \ref ItemIt.
     3294    /// It can be used in range-based for loops, STL algorithms, etc.
     3295    LemonRangeWrapper2<ItemIt, IterableValueMap, V>
     3296    items(const V& value) {
     3297      return LemonRangeWrapper2<ItemIt, IterableValueMap, V>(*this, value);
     3298    }
     3299
     3300
    32513301  protected:
    32523302
    32533303    virtual void add(const Key& key) {
  • lemon/path.h

    diff --git a/lemon/path.h b/lemon/path.h
    a b  
    3030#include <lemon/error.h>
    3131#include <lemon/core.h>
    3232#include <lemon/concepts/path.h>
     33#include <lemon/bits/stl_iterators.h>
    3334
    3435namespace lemon {
    3536
     
    140141      int idx;
    141142    };
    142143
     144    /// \brief Gets the collection of the arcs of the path.
     145    ///
     146    /// This function can be used for iterating on the
     147    /// arcs of the path. It returns a wrapped
     148    /// ArcIt, which looks like an STL container
     149    /// (by having begin() and end()) which you can use in range-based
     150    /// for loops, STL algorithms, etc.
     151    /// For example you can write:
     152    ///\code
     153    /// for(auto a: p.arcs())
     154    ///   doSomething(a);
     155    ///\endcode
     156    LemonRangeWrapper1<ArcIt, Path> arcs() const {
     157      return LemonRangeWrapper1<ArcIt, Path>(*this);
     158    }
     159
     160
    143161    /// \brief Length of the path.
    144162    int length() const { return head.size() + tail.size(); }
    145163    /// \brief Return whether the path is empty.
     
    345363      int idx;
    346364    };
    347365
     366    /// \brief Gets the collection of the arcs of the path.
     367    ///
     368    /// This function can be used for iterating on the
     369    /// arcs of the path. It returns a wrapped
     370    /// ArcIt, which looks like an STL container
     371    /// (by having begin() and end()) which you can use in range-based
     372    /// for loops, STL algorithms, etc.
     373    /// For example you can write:
     374    ///\code
     375    /// for(auto a: p.arcs())
     376    ///   doSomething(a);
     377    ///\endcode
     378    LemonRangeWrapper1<ArcIt, SimplePath> arcs() const {
     379      return LemonRangeWrapper1<ArcIt, SimplePath>(*this);
     380    }
     381
     382
    348383    /// \brief Length of the path.
    349384    int length() const { return data.size(); }
    350385    /// \brief Return true if the path is empty.
     
    543578      Node *node;
    544579    };
    545580
     581    /// \brief Gets the collection of the arcs of the path.
     582    ///
     583    /// This function can be used for iterating on the
     584    /// arcs of the path. It returns a wrapped
     585    /// ArcIt, which looks like an STL container
     586    /// (by having begin() and end()) which you can use in range-based
     587    /// for loops, STL algorithms, etc.
     588    /// For example you can write:
     589    ///\code
     590    /// for(auto a: p.arcs())
     591    ///   doSomething(a);
     592    ///\endcode
     593    LemonRangeWrapper1<ArcIt, ListPath> arcs() const {
     594      return LemonRangeWrapper1<ArcIt, ListPath>(*this);
     595    }
     596
     597
    546598    /// \brief The n-th arc.
    547599    ///
    548600    /// This function looks for the n-th arc in O(n) time.
     
    795847    /// \brief Default constructor
    796848    ///
    797849    /// Default constructor
    798     StaticPath() : len(0), arcs(0) {}
     850    StaticPath() : len(0), _arcs(0) {}
    799851
    800852    /// \brief Copy constructor
    801853    ///
    802     StaticPath(const StaticPath& cpath) : arcs(0) {
     854    StaticPath(const StaticPath& cpath) : _arcs(0) {
    803855      pathCopy(cpath, *this);
    804856    }
    805857
     
    807859    ///
    808860    /// This path can be initialized from any other path type.
    809861    template <typename CPath>
    810     StaticPath(const CPath& cpath) : arcs(0) {
     862    StaticPath(const CPath& cpath) : _arcs(0) {
    811863      pathCopy(cpath, *this);
    812864    }
    813865
     
    815867    ///
    816868    /// Destructor of the path
    817869    ~StaticPath() {
    818       if (arcs) delete[] arcs;
     870      if (_arcs) delete[] _arcs;
    819871    }
    820872
    821873    /// \brief Copy assignment
     
    882934      const StaticPath *path;
    883935      int idx;
    884936    };
     937   
     938    /// \brief Gets the collection of the arcs of the path.
     939    ///
     940    /// This function can be used for iterating on the
     941    /// arcs of the path. It returns a wrapped
     942    /// ArcIt, which looks like an STL container
     943    /// (by having begin() and end()) which you can use in range-based
     944    /// for loops, STL algorithms, etc.
     945    /// For example you can write:
     946    ///\code
     947    /// for(auto a: p.arcs())
     948    ///   doSomething(a);
     949    ///\endcode
     950    LemonRangeWrapper1<ArcIt, StaticPath> arcs() const {
     951      return LemonRangeWrapper1<ArcIt, StaticPath>(*this);
     952    }
     953   
    885954
    886955    /// \brief The n-th arc.
    887956    ///
    888957    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
    889958    const Arc& nth(int n) const {
    890       return arcs[n];
     959      return _arcs[n];
    891960    }
    892961
    893962    /// \brief The arc iterator pointing to the n-th arc.
     
    904973    /// \brief Erase all arcs in the digraph.
    905974    void clear() {
    906975      len = 0;
    907       if (arcs) delete[] arcs;
    908       arcs = 0;
     976      if (_arcs) delete[] _arcs;
     977      _arcs = 0;
    909978    }
    910979
    911980    /// \brief The first arc of the path.
    912981    const Arc& front() const {
    913       return arcs[0];
     982      return _arcs[0];
    914983    }
    915984
    916985    /// \brief The last arc of the path.
    917986    const Arc& back() const {
    918       return arcs[len - 1];
     987      return _arcs[len - 1];
    919988    }
    920989
    921990
     
    924993    template <typename CPath>
    925994    void build(const CPath& path) {
    926995      len = path.length();
    927       arcs = new Arc[len];
     996      _arcs = new Arc[len];
    928997      int index = 0;
    929998      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
    930         arcs[index] = it;
     999        _arcs[index] = it;
    9311000        ++index;
    9321001      }
    9331002    }
     
    9351004    template <typename CPath>
    9361005    void buildRev(const CPath& path) {
    9371006      len = path.length();
    938       arcs = new Arc[len];
     1007      _arcs = new Arc[len];
    9391008      int index = len;
    9401009      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
    9411010        --index;
    942         arcs[index] = it;
     1011        _arcs[index] = it;
    9431012      }
    9441013    }
    9451014
    9461015  private:
    9471016    int len;
    948     Arc* arcs;
     1017    Arc* _arcs;
    9491018  };
    9501019
    9511020  ///////////////////////////////////////////////////////////////////////
     
    11571226
    11581227  };
    11591228
     1229  /// \brief Gets the collection of the nodes of the path.
     1230  ///
     1231  /// This function can be used for iterating on the
     1232  /// nodes of the path. It returns a wrapped
     1233  /// PathNodeIt, which looks like an STL container
     1234  /// (by having begin() and end()) which you can use in range-based
     1235  /// for loops, STL algorithms, etc.
     1236  /// For example you can write:
     1237  ///\code
     1238  /// for(auto u: pathNodes(g,p))
     1239  ///   doSomething(u);
     1240  ///\endcode
     1241  template<typename Path>
     1242  LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>
     1243      pathNodes(const typename Path::Digraph &g, const Path &p) {
     1244    return
     1245        LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>(g,p);
     1246  }
     1247
    11601248  ///@}
    11611249
    11621250} // namespace lemon
  • lemon/smart_graph.h

    diff --git a/lemon/smart_graph.h b/lemon/smart_graph.h
    a b  
    4747      ArcT() {}
    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:
    5454
     
    5959
    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(); }
     69    int nodeNum() const { return _nodes.size(); }
     70    int arcNum() const { return _arcs.size(); }
    7171
    72     int maxNodeId() const { return nodes.size()-1; }
    73     int maxArcId() const { return arcs.size()-1; }
     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);
    9393    }
    9494
    9595    void clear() {
    96       arcs.clear();
    97       nodes.clear();
     96      _arcs.clear();
     97      _nodes.clear();
    9898    }
    9999
    100     Node source(Arc a) const { return Node(arcs[a._id].source); }
    101     Node target(Arc a) const { return Node(arcs[a._id].target); }
     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; }
    104104    static int id(Arc a) { return a._id; }
     
    107107    static Arc arcFromId(int id) { return Arc(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
    116116    class Node {
     
    145145    };
    146146
    147147    void first(Node& node) const {
    148       node._id = nodes.size() - 1;
     148      node._id = _nodes.size() - 1;
    149149    }
    150150
    151151    static void next(Node& node) {
     
    153153    }
    154154
    155155    void first(Arc& arc) const {
    156       arc._id = arcs.size() - 1;
     156      arc._id = _arcs.size() - 1;
    157157    }
    158158
    159159    static void next(Arc& arc) {
     
    161161    }
    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
    179179  };
     
    266266    Node split(Node n, bool connect = true)
    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);
    275275      return b;
     
    291291    /// then it is worth reserving space for this amount before starting
    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.
    297297
     
    301301    /// then it is worth reserving space for this amount before starting
    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:
    307307
     
    311311
    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();
     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();
    320320      }
    321       while(s.node_num<nodes.size()) {
    322         Node node = nodeFromId(nodes.size()-1);
     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    }
    327327
     
    362362      ///This constructor immediately makes a snapshot of the given digraph.
    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
    369369      ///Make a snapshot.
     
    373373      ///call, the previous snapshot gets lost.
    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
    380380      ///Undo the changes until a snapshot.
     
    402402      int next_out;
    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:
    409409
     
    465465
    466466
    467467    SmartGraphBase()
    468       : nodes(), arcs() {}
     468      : _nodes(), _arcs() {}
    469469
    470470    typedef True NodeNumTag;
    471471    typedef True EdgeNumTag;
    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(); }
     474    int nodeNum() const { return _nodes.size(); }
     475    int edgeNum() const { return _arcs.size() / 2; }
     476    int arcNum() const { return _arcs.size(); }
    477477
    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; }
     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; }
    481481
    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); }
     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); }
    484484
    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); }
     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) {
    489489      return (e._id & 1) == 1;
     
    494494    }
    495495
    496496    void first(Node& node) const {
    497       node._id = nodes.size() - 1;
     497      node._id = _nodes.size() - 1;
    498498    }
    499499
    500500    static void next(Node& node) {
     
    502502    }
    503503
    504504    void first(Arc& arc) const {
    505       arc._id = arcs.size() - 1;
     505      arc._id = _arcs.size() - 1;
    506506    }
    507507
    508508    static void next(Arc& arc) {
     
    510510    }
    511511
    512512    void first(Edge& arc) const {
    513       arc._id = arcs.size() / 2 - 1;
     513      arc._id = _arcs.size() / 2 - 1;
    514514    }
    515515
    516516    static void next(Edge& arc) {
     
    518518    }
    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;
    540540        d = ((de & 1) == 1);
     
    544544      }
    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;
    550550        d = ((de & 1) == 1);
     
    563563    static Edge edgeFromId(int id) { return Edge(id);}
    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);
    581581    }
    582582
    583583    Edge addEdge(Node u, Node v) {
    584       int n = arcs.size();
    585       arcs.push_back(ArcT());
    586       arcs.push_back(ArcT());
     584      int n = _arcs.size();
     585      _arcs.push_back(ArcT());
     586      _arcs.push_back(ArcT());
    587587
    588       arcs[n].target = u._id;
    589       arcs[n | 1].target = v._id;
     588      _arcs[n].target = u._id;
     589      _arcs[n | 1].target = v._id;
    590590
    591       arcs[n].next_out = nodes[v._id].first_out;
    592       nodes[v._id].first_out = n;
     591      _arcs[n].next_out = _nodes[v._id].first_out;
     592      _nodes[v._id].first_out = n;
    593593
    594       arcs[n | 1].next_out = nodes[u._id].first_out;
    595       nodes[u._id].first_out = (n | 1);
     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);
    598598    }
    599599
    600600    void clear() {
    601       arcs.clear();
    602       nodes.clear();
     601      _arcs.clear();
     602      _nodes.clear();
    603603    }
    604604
    605605  };
     
    701701    /// then it is worth reserving space for this amount before starting
    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.
    707707
     
    711711    /// then it is worth reserving space for this amount before starting
    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:
    717717
     
    722722    void saveSnapshot(Snapshot &s)
    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);
    735735        std::vector<Arc> dir;
    736736        dir.push_back(arcFromId(n));
    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();
     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();
    743743      }
    744       while(s.node_num<nodes.size()) {
    745         int n=nodes.size()-1;
     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    }
    751751
     
    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
  • lemon/soplex.cc

    diff --git a/lemon/soplex.cc b/lemon/soplex.cc
    a b  
    3737  }
    3838
    3939  SoplexLp::SoplexLp(const SoplexLp& lp) {
    40     rows = lp.rows;
    41     cols = lp.cols;
     40    _rows = lp._rows;
     41    _cols = lp._cols;
    4242
    4343    soplex = new soplex::SoPlex;
    4444    (*static_cast<soplex::SPxLP*>(soplex)) = *(lp.soplex);
     
    122122  }
    123123
    124124  void SoplexLp::_eraseColId(int i) {
    125     cols.eraseIndex(i);
    126     cols.relocateIndex(i, cols.maxIndex());
     125    _cols.eraseIndex(i);
     126    _cols.relocateIndex(i, _cols.maxIndex());
    127127  }
    128128  void SoplexLp::_eraseRowId(int i) {
    129     rows.eraseIndex(i);
    130     rows.relocateIndex(i, rows.maxIndex());
     129    _rows.eraseIndex(i);
     130    _rows.relocateIndex(i, _rows.maxIndex());
    131131  }
    132132
    133133  void SoplexLp::_getColName(int c, std::string &name) const {
     
    432432    _col_names_ref.clear();
    433433    _row_names.clear();
    434434    _row_names_ref.clear();
    435     cols.clear();
    436     rows.clear();
     435    _cols.clear();
     436    _rows.clear();
    437437    _clear_temporals();
    438438  }
    439439
  • CMakeLists.txt

    # HG changeset patch
    # User Alpar Juttner <alpar@cs.elte.hu>
    # Date 1428993580 -7200
    #      Tue Apr 14 08:39:40 2015 +0200
    # Node ID 4add05447ca00f659a054e88a7e0842a66f8b041
    # Parent  0759d974de816af3492dff5e02de2d361ad27841
    Tests and bugfixes for the STL style iterators (#325)
    
    diff --git a/CMakeLists.txt b/CMakeLists.txt
    a b  
    264264
    265265
    266266INCLUDE(CheckCXXCompilerFlag)
    267 CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX11FLAG)
    268 IF(CXX11FLAG)
     267CHECK_CXX_COMPILER_FLAG("-std=c++11" LEMON_CXX11)
     268IF(LEMON_CXX11)
    269269  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
    270270ENDIF()
    271271
  • lemon/bellman_ford.h

    diff --git a/lemon/bellman_ford.h b/lemon/bellman_ford.h
    a b  
    701701    /// like an STL container (by having begin() and end())
    702702    /// which you can use in range-based for loops, STL algorithms, etc.
    703703    LemonRangeWrapper1<ActiveIt, BellmanFord>
    704         activeNodes(const BellmanFord& algorithm) const {
    705       return LemonRangeWrapper1<ActiveIt, BellmanFord>(algorithm);
     704    activeNodes() const {
     705      return LemonRangeWrapper1<ActiveIt, BellmanFord>(*this);
    706706    }
    707707
    708708
  • lemon/bits/edge_set_extender.h

    diff --git a/lemon/bits/edge_set_extender.h b/lemon/bits/edge_set_extender.h
    a b  
    113113
    114114    };
    115115
     116    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
     117      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
     118    }
    116119
    117120    class ArcIt : public Arc {
    118121      const Digraph* digraph;
     
    136139
    137140    };
    138141
     142    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
     143      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
     144    }
    139145
    140146    class OutArcIt : public Arc {
    141147      const Digraph* digraph;
     
    160166
    161167    };
    162168
     169    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
     170      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
     171    }
    163172
    164173    class InArcIt : public Arc {
    165174      const Digraph* digraph;
     
    184193
    185194    };
    186195
     196    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
     197      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
     198    }
     199
    187200    // \brief Base node of the iterator
    188201    //
    189202    // Returns the base node (ie. the source in this case) of the iterator
     
    372385
    373386    };
    374387
     388    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
     389      return LemonRangeWrapper1<NodeIt, Graph>(*this);
     390    }
    375391
    376392    class ArcIt : public Arc {
    377393      const Graph* graph;
     
    395411
    396412    };
    397413
     414    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
     415      return LemonRangeWrapper1<ArcIt, Graph>(*this);
     416    }
    398417
    399418    class OutArcIt : public Arc {
    400419      const Graph* graph;
     
    419438
    420439    };
    421440
     441    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
     442      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
     443    }
    422444
    423445    class InArcIt : public Arc {
    424446      const Graph* graph;
     
    443465
    444466    };
    445467
     468    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
     469      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
     470    }
    446471
    447472    class EdgeIt : public Parent::Edge {
    448473      const Graph* graph;
     
    466491
    467492    };
    468493
     494    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
     495      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
     496    }
     497
    469498    class IncEdgeIt : public Parent::Edge {
    470499      friend class EdgeSetExtender;
    471500      const Graph* graph;
     
    491520      }
    492521    };
    493522
     523    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
     524      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
     525    }
     526
    494527    // \brief Base node of the iterator
    495528    //
    496529    // Returns the base node (ie. the source in this case) of the iterator
  • lemon/bits/graph_adaptor_extender.h

    diff --git a/lemon/bits/graph_adaptor_extender.h b/lemon/bits/graph_adaptor_extender.h
    a b  
    8585
    8686    };
    8787
    88     LemonRangeWrapper1<NodeIt, Adaptor> nodes() {
     88    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
    8989      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
    9090    }
    9191
     
    111111
    112112    };
    113113
    114     LemonRangeWrapper1<ArcIt, Adaptor> arcs() {
     114    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
    115115      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
    116116    }
    117117
     
    269269
    270270    };
    271271
    272     LemonRangeWrapper1<NodeIt, Adaptor> nodes() {
     272    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
    273273      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
    274274    }
    275275
     
    296296
    297297    };
    298298
    299     LemonRangeWrapper1<ArcIt, Adaptor> arcs() {
     299    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
    300300      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
    301301    }
    302302
     
    378378
    379379    };
    380380
    381     LemonRangeWrapper1<EdgeIt, Adaptor> edges() {
     381    LemonRangeWrapper1<EdgeIt, Adaptor> edges() const {
    382382      return LemonRangeWrapper1<EdgeIt, Adaptor>(*this);
    383383    }
    384384
  • lemon/config.h.in

    diff --git a/lemon/config.h.in b/lemon/config.h.in
    a b  
    11#define LEMON_VERSION "@PROJECT_VERSION@"
    22#cmakedefine LEMON_HAVE_LONG_LONG 1
    33
     4#cmakedefine LEMON_CXX11 1
     5
    46#cmakedefine LEMON_HAVE_LP 1
    57#cmakedefine LEMON_HAVE_MIP 1
    68#cmakedefine LEMON_HAVE_GLPK 1
  • lemon/list_graph.h

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    12091209    ///
    12101210    ListGraph() {}
    12111211
    1212     typedef Parent::OutArcIt IncEdgeIt;
     1212    typedef Parent::IncEdgeIt IncEdgeIt;
    12131213
    12141214    /// \brief Add a new node to the graph.
    12151215    ///
     
    21362136    ///
    21372137    ListBpGraph() {}
    21382138
    2139     typedef Parent::OutArcIt IncEdgeIt;
     2139    typedef Parent::IncEdgeIt IncEdgeIt;
    21402140
    21412141    /// \brief Add a new red node to the graph.
    21422142    ///
  • test/bellman_ford_test.cc

    diff --git a/test/bellman_ford_test.cc b/test/bellman_ford_test.cc
    a b  
    101101    pp = const_bf_test.negativeCycle();
    102102
    103103    for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
     104    for (auto n: const_bf_test.activeNodes()) { ::lemon::ignore_unused_variable_warning(n); }
     105    for (Digraph::Node n: const_bf_test.activeNodes()) {
     106      ::lemon::ignore_unused_variable_warning(n);
     107    }
    104108  }
    105109  {
    106110    BF::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
  • test/graph_test.h

    diff --git a/test/graph_test.h b/test/graph_test.h
    a b  
    3838    }
    3939    check(n==INVALID,"Wrong Node list linking.");
    4040    check(countNodes(G)==cnt,"Wrong Node number.");
     41
     42#ifdef LEMON_CXX11
     43    {
     44      typename Graph::NodeIt n(G);
     45      for(auto u: G.nodes())
     46        {
     47          check(n==u,"Wrong STL Node iterator.");
     48          ++n;
     49        }
     50      check(n==INVALID,"Wrong STL Node iterator.");
     51    }
     52    {
     53      typename Graph::NodeIt n(G);
     54      for(typename Graph::Node u: G.nodes())
     55        {
     56          check(n==u,"Wrong STL Node iterator.");
     57          ++n;
     58        }
     59      check(n==INVALID,"Wrong STL Node iterator.");
     60    }
     61#endif
    4162  }
    4263
    4364  template<class Graph>
     
    5677    }
    5778    check(n==INVALID,"Wrong red Node list linking.");
    5879    check(countRedNodes(G)==cnt,"Wrong red Node number.");
     80#ifdef LEMON_CXX11
     81    {
     82      typename Graph::RedNodeIt n(G);
     83      for(auto u: G.redNodes())
     84        {
     85          check(n==u,"Wrong STL RedNode iterator.");
     86          ++n;
     87        }
     88      check(n==INVALID,"Wrong STL RedNode iterator.");
     89    }
     90    {
     91      typename Graph::RedNodeIt n(G);
     92      for(typename Graph::RedNode u: G.redNodes())
     93        {
     94          check(n==u,"Wrong STL RedNode iterator.");
     95          ++n;
     96        }
     97      check(n==INVALID,"Wrong STL RedNode iterator.");
     98    }
     99#endif
    59100  }
    60101
    61102  template<class Graph>
     
    74115    }
    75116    check(n==INVALID,"Wrong blue Node list linking.");
    76117    check(countBlueNodes(G)==cnt,"Wrong blue Node number.");
     118#ifdef LEMON_CXX11
     119    {
     120      typename Graph::BlueNodeIt n(G);
     121      for(auto u: G.blueNodes())
     122        {
     123          check(n==u,"Wrong STL BlueNode iterator.");
     124          ++n;
     125        }
     126      check(n==INVALID,"Wrong STL BlueNode iterator.");
     127    }
     128    {
     129      typename Graph::BlueNodeIt n(G);
     130      for(typename Graph::BlueNode u: G.blueNodes())
     131        {
     132          check(n==u,"Wrong STL BlueNode iterator.");
     133          ++n;
     134        }
     135      check(n==INVALID,"Wrong STL BlueNode iterator.");
     136    }
     137#endif
     138
    77139  }
    78140
    79141  template<class Graph>
     
    90152    }
    91153    check(e==INVALID,"Wrong Arc list linking.");
    92154    check(countArcs(G)==cnt,"Wrong Arc number.");
     155#ifdef LEMON_CXX11
     156    {
     157      typename Graph::ArcIt a(G);
     158      for(auto e: G.arcs())
     159        {
     160          check(a==e,"Wrong STL Arc iterator.");
     161          ++a;
     162        }
     163      check(a==INVALID,"Wrong STL Arc iterator.");
     164    }
     165    {
     166      typename Graph::ArcIt a(G);
     167      for(typename Graph::Arc e: G.arcs())
     168        {
     169          check(a==e,"Wrong STL Arc iterator.");
     170          ++a;
     171        }
     172      check(a==INVALID,"Wrong STL Arc iterator.");
     173    }
     174#endif
     175
    93176  }
    94177
    95178  template<class Graph>
     
    105188    }
    106189    check(e==INVALID,"Wrong OutArc list linking.");
    107190    check(countOutArcs(G,n)==cnt,"Wrong OutArc number.");
     191#ifdef LEMON_CXX11
     192    {
     193      typename Graph::OutArcIt a(G,n);
     194      for(auto e: G.outArcs(n))
     195        {
     196          check(a==e,"Wrong STL OutArc iterator.");
     197          ++a;
     198        }
     199      check(a==INVALID,"Wrong STL OutArc iterator.");
     200    }
     201    {
     202      typename Graph::OutArcIt a(G,n);
     203      for(typename Graph::Arc e: G.outArcs(n))
     204        {
     205          check(a==e,"Wrong STL OutArc iterator.");
     206          ++a;
     207        }
     208      check(a==INVALID,"Wrong STL OutArc iterator.");
     209    }
     210#endif
     211
    108212  }
    109213
    110214  template<class Graph>
     
    120224    }
    121225    check(e==INVALID,"Wrong InArc list linking.");
    122226    check(countInArcs(G,n)==cnt,"Wrong InArc number.");
     227#ifdef LEMON_CXX11
     228    {
     229      typename Graph::InArcIt a(G,n);
     230      for(auto e: G.inArcs(n))
     231        {
     232          check(a==e,"Wrong STL InArc iterator.");
     233          ++a;
     234        }
     235      check(a==INVALID,"Wrong STL InArc iterator.");
     236    }
     237    {
     238      typename Graph::InArcIt a(G,n);
     239      for(typename Graph::Arc e: G.inArcs(n))
     240        {
     241          check(a==e,"Wrong STL InArc iterator.");
     242          ++a;
     243        }
     244      check(a==INVALID,"Wrong STL InArc iterator.");
     245    }
     246#endif
    123247  }
    124248
    125249  template<class Graph>
     
    134258    }
    135259    check(e==INVALID,"Wrong Edge list linking.");
    136260    check(countEdges(G)==cnt,"Wrong Edge number.");
     261#ifdef LEMON_CXX11
     262    {
     263      typename Graph::EdgeIt a(G);
     264      for(auto e: G.edges())
     265        {
     266          check(a==e,"Wrong STL Edge iterator.");
     267          ++a;
     268        }
     269      check(a==INVALID,"Wrong STL Edge iterator.");
     270    }
     271    {
     272      typename Graph::EdgeIt a(G);
     273      for(typename Graph::Edge e: G.edges())
     274        {
     275          check(a==e,"Wrong STL Edge iterator.");
     276          ++a;
     277        }
     278      check(a==INVALID,"Wrong STL Edge iterator.");
     279    }
     280#endif
     281
    137282  }
    138283
    139284  template<class Graph>
     
    150295    }
    151296    check(e==INVALID,"Wrong IncEdge list linking.");
    152297    check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");
     298#ifdef LEMON_CXX11
     299    {
     300      typename Graph::IncEdgeIt a(G,n);
     301      for(auto e: G.incEdges(n))
     302        {
     303          check(a==e,"Wrong STL IncEdge iterator.");
     304          ++a;
     305        }
     306      check(a==INVALID,"Wrong STL IncEdge iterator.");
     307    }
     308    {
     309      typename Graph::IncEdgeIt a(G,n);
     310      for(typename Graph::Edge e: G.incEdges(n))
     311        {
     312          check(a==e,"Wrong STL IncEdge iterator.");
     313          ++a;
     314        }
     315      check(a==INVALID,"Wrong STL IncEdge iterator.");
     316    }
     317#endif
     318
    153319  }
    154320
    155321  template <class Graph>
  • test/lp_test.cc

    diff --git a/test/lp_test.cc b/test/lp_test.cc
    a b  
    2020#include <lemon/lp_skeleton.h>
    2121#include "test_tools.h"
    2222#include <lemon/tolerance.h>
    23 
     23#include <lemon/concept_check.h>
    2424#include <lemon/config.h>
    2525
    2626#ifdef LEMON_HAVE_GLPK
     
    4747int countCols(LpBase & lp) {
    4848  int count=0;
    4949  for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
     50#ifdef LEMON_CXX11
     51  int cnt = 0;
     52  for(auto c: lp.cols()) { cnt++; ::lemon::ignore_unused_variable_warning(c); }
     53  check(count == cnt, "Wrong STL iterator");
     54#endif
    5055  return count;
    5156}
    5257
    5358int countRows(LpBase & lp) {
    5459  int count=0;
    5560  for (LpBase::RowIt r(lp); r!=INVALID; ++r) ++count;
     61#ifdef LEMON_CXX11
     62  int cnt = 0;
     63  for(auto r: lp.rows()) { cnt++; ::lemon::ignore_unused_variable_warning(r); }
     64  check(count == cnt, "Wrong STL iterator");
     65#endif
    5666  return count;
    5767}
    5868
  • test/maps_test.cc

    diff --git a/test/maps_test.cc b/test/maps_test.cc
    a b  
    730730    }
    731731    check(n == 3, "Wrong number");
    732732    check(map1.falseNum() == 3, "Wrong number");
     733
     734#ifdef LEMON_CXX11
     735    {
     736      int c = 0;
     737      for(auto v: map1.items(false)) { c++; ::lemon::ignore_unused_variable_warning(v); }
     738      check(c == map1.falseNum(), "Wrong number");
     739    }
     740    {
     741      int c = 0;
     742      for(auto v: map1.items(true)) { c++; ::lemon::ignore_unused_variable_warning(v); }
     743      check(c == map1.trueNum(), "Wrong number");
     744    }
     745    {
     746      int c = 0;
     747      for(auto v: map1.falseKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
     748      check(c == map1.falseNum(), "Wrong number");
     749    }
     750    {
     751      int c = 0;
     752      for(auto v: map1.trueKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
     753      check(c == map1.trueNum(), "Wrong number");
     754    }
     755#endif
     756
    733757  }
    734758
    735759  // Iterable int map
     
    780804      ++n;
    781805    }
    782806    check(n == num, "Wrong number");
     807#ifdef LEMON_CXX11
     808    {
     809      int c = 0;
     810      for(auto v: map1.items(0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
     811      check(c == (num + 1) / 2, "Wrong number");
     812      for(auto v: map1.items(1)) { c++; ::lemon::ignore_unused_variable_warning(v); }
     813      check(c == num, "Wrong number");
     814    }
     815#endif
    783816
    784817  }
    785818
     
    839872    }
    840873    check(n == num, "Wrong number");
    841874
     875#ifdef LEMON_CXX11
     876    {
     877      int c = 0;
     878      for(auto v: map1.items(0.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
     879      check(c == (num + 1) / 2, "Wrong number");
     880      for(auto v: map1.items(1.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
     881      check(c == num, "Wrong number");
     882    }
     883#endif
     884
    842885  }
    843886
    844887  // Graph map utilities:
  • lemon/bits/path_dump.h

    # HG changeset patch
    # User Alpar Juttner <alpar@cs.elte.hu>
    # Date 1429003747 -7200
    #      Tue Apr 14 11:29:07 2015 +0200
    # Node ID 72af84645ac2813057d8328e1eaef630c252ca48
    # Parent  4add05447ca00f659a054e88a7e0842a66f8b041
    Clang -std=c++11 related fixes (#325)
    
    diff --git a/lemon/bits/path_dump.h b/lemon/bits/path_dump.h
    a b  
    6161        if (path->predMap[current] == INVALID) current = INVALID;
    6262      }
    6363
    64       operator const typename Digraph::Arc() const {
     64      operator typename Digraph::Arc() const {
    6565        return path->predMap[current];
    6666      }
    6767
  • lemon/bits/stl_iterators.h

    diff --git a/lemon/bits/stl_iterators.h b/lemon/bits/stl_iterators.h
    a b  
    8686  public:
    8787    LemonRangeWrapper2(const P1 &p1, const P2 &p2) : _p1(p1), _p2(p2) {}
    8888    It begin() const {
    89       return It(LIT(_p1, _p2));
     89      LIT lit(_p1,_p2);
     90      It it(lit);
     91      return it;
    9092    }
    9193    It end() const {
    9294      return It(lemon::INVALID);
  • lemon/maps.h

    diff --git a/lemon/maps.h b/lemon/maps.h
    a b  
    26582658      /// keys mapped to the given value.
    26592659      /// \param map The IterableBoolMap.
    26602660      /// \param value The value.
    2661       ItemIt(const IterableBoolMap& map, bool value)
    2662         : Parent(value ?
    2663                  (map._sep > 0 ?
    2664                   map._array[map._sep - 1] : INVALID) :
    2665                  (map._sep < int(map._array.size()) ?
    2666                   map._array.back() : INVALID)), _map(&map) {}
     2661      ItemIt(const IterableBoolMap& map, bool)
     2662        // : Parent(value ?
     2663        //          (map._sep > 0 ?
     2664        //           map._array[map._sep - 1] : INVALID) :
     2665        //          (map._sep < int(map._array.size()) ?
     2666        //           map._array.back() : INVALID)), _map(&map) {}
     2667        : _map(&map)
     2668      {
     2669        // if(value)
     2670        //   if(map._sep > 0)
     2671        //     Parent(*this) = map._array[map._sep - 1];
     2672        //   else Parent(*this) = INVALID;
     2673        // else if(map._sep < int(map._array.size()))
     2674        //   Parent(*this) = map._array.back();
     2675        // else
     2676          Parent(*this) = INVALID;
     2677      }
    26672678
    26682679      /// \brief Invalid constructor \& conversion.
    26692680      ///
  • lemon/random.h

    diff --git a/lemon/random.h b/lemon/random.h
    a b  
    249249
    250250        current = state + length;
    251251
    252         register Word *curr = state + length - 1;
    253         register long num;
     252        Word *curr = state + length - 1;
     253        long num;
    254254
    255255        num = length - shift;
    256256        while (num--) {