COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changeset 2386:81b47fc5c444 in lemon-0.x


Ignore:
Timestamp:
03/02/07 19:04:28 (17 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3217
Message:

Hard Warning checking

  • based on the remark of the ZIB user
  • we do not use -Winline
Files:
68 edited

Legend:

Unmodified
Added
Removed

  • benchmark/bench_tools.h

    r1956 r2386  
    8181};
    8282
    83 inline void PrintTime(char *ID,lemon::Timer &T)
     83inline void PrintTime(const char *ID, lemon::Timer &T)
    8484{
    8585  lemon::TimeStamp S(T);

  • benchmark/hcube.cc

    r1956 r2386  
    7979  for(int i=0;i<5;i++) {
    8080    Primes P;
    81     for(int i=0;i<dim*(1<<dim);i++) P();
     81    for(int j=0;j<dim*(1<<dim);j++) P();
    8282   
    8383    //  for(EdgeIt e(G);G.valid(e);G.next(e)) map[e]=P();

  • benchmark/swap_bipartite_bench.cc

    r2242 r2386  
    4343      vector<LGraph::Node> lbNodes; 
    4444     
    45       for (int i = 0; i < n; ++i) {
     45      for (int j = 0; j < n; ++j) {
    4646        Node node = graph.addANode();
    4747        aNodes.push_back(node);
    … …  
    4949        laNodes.push_back(lnode);
    5050      }
    51       for (int i = 0; i < m; ++i) {
     51      for (int j = 0; j < m; ++j) {
    5252        Node node = graph.addBNode();
    5353        bNodes.push_back(node);
    … …  
    5555        lbNodes.push_back(lnode);
    5656      }
    57       for (int i = 0; i < e; ++i) {
     57      for (int j = 0; j < e; ++j) {
    5858        int a,b;
    5959        Node aNode = aNodes[a=rnd[n]];

  • configure.ac

    r2315 r2386  
    1818
    1919if test x"$lx_cmdline_cxxflags_set" != x"set" -a "$GXX" = yes; then
    20   CXXFLAGS="$CXXFLAGS -Wall -W"
     20  CXXFLAGS="$CXXFLAGS -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -Woverloaded-virtual -Wshadow -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas"
    2121fi
    2222

  • demo/descriptor_map_demo.cc

    r2242 r2386  
    6363  Value operator[](const Key& key) const {
    6464    double angle = descriptor[key] * 2 * M_PI
    65       / (double)descriptor.inverse().size();
     65      / double(descriptor.inverse().size());
    6666    double x = std::cos(angle) * radius + center.x;
    6767    double y = std::sin(angle) * radius + center.y;
    … …  
    104104  // The inversemap cannot works without its DescriptorMap because
    105105  // it holds reference to it.
    106   const int EDGE = (int)(NODE * std::log(double(NODE)));
     106  const int EDGE = int(NODE * std::log(double(NODE)));
    107107  for (int i = 0; i < EDGE; ++i) {
    108108    int si = rnd[NODE];

  • demo/simann_maxcut_demo.cc

    r2242 r2386  
    117117  simann.run();
    118118 
    119   Entity* be = (Entity *) simann.getBestEntity();
     119  Entity* be = static_cast<Entity*>(simann.getBestEntity());
    120120  std::cout << be->sum << std::endl;
    121121  for (NodeIt n(g); n != INVALID; ++n)

  • lemon/bellman_ford.h

    r2376 r2386  
    437437    /// paths.
    438438    bool processNextRound() {
    439       for (int i = 0; i < (int)_process.size(); ++i) {
     439      for (int i = 0; i < int(_process.size()); ++i) {
    440440        _mask->set(_process[i], false);
    441441      }
    442442      std::vector<Node> nextProcess;
    443443      std::vector<Value> values(_process.size());
    444       for (int i = 0; i < (int)_process.size(); ++i) {
     444      for (int i = 0; i < int(_process.size()); ++i) {
    445445        values[i] = (*_dist)[_process[i]];
    446446      }
    447       for (int i = 0; i < (int)_process.size(); ++i) {
     447      for (int i = 0; i < int(_process.size()); ++i) {
    448448        for (OutEdgeIt it(*graph, _process[i]); it != INVALID; ++it) {
    449449          Node target = graph->target(it);
    … …  
    473473    /// \return %True when the algorithm have not found more shorter paths.
    474474    bool processNextWeakRound() {
    475       for (int i = 0; i < (int)_process.size(); ++i) {
     475      for (int i = 0; i < int(_process.size()); ++i) {
    476476        _mask->set(_process[i], false);
    477477      }
    478478      std::vector<Node> nextProcess;
    479       for (int i = 0; i < (int)_process.size(); ++i) {
     479      for (int i = 0; i < int(_process.size()); ++i) {
    480480        for (OutEdgeIt it(*graph, _process[i]); it != INVALID; ++it) {
    481481          Node target = graph->target(it);
    … …  
    646646
    647647      bool operator==(const ActiveIt& it) const {
    648         return (Node)(*this) == (Node)it;
     648        return static_cast<Node>(*this) == static_cast<Node>(it);
    649649      }
    650650      bool operator!=(const ActiveIt& it) const {
    651         return (Node)(*this) != (Node)it;
     651        return static_cast<Node>(*this) != static_cast<Node>(it);
    652652      }
    653653      bool operator<(const ActiveIt& it) const {
    654         return (Node)(*this) < (Node)it;
     654        return static_cast<Node>(*this) < static_cast<Node>(it);
    655655      }
    656656     
    … …  
    866866                          const _LengthMap& length,
    867867                          Node source = INVALID) :
    868       _graph((void *)&graph), _length((void *)&length), _pred(0),
    869       _dist(0), _source(source) {}
     868      _graph(reinterpret_cast<void*>(const_cast<_Graph*>(&graph))),
     869      _length(reinterpret_cast<void*>(const_cast<_LengthMap*>(&length))),
     870      _pred(0), _dist(0), _source(source) {}
    870871
    871872  };
    … …  
    924925    /// These parameters will be the default values for the traits class.
    925926    BellmanFordWizard(const Graph& graph, const LengthMap& length,
    926                       Node source = INVALID)
    927       : _Traits(graph, length, source) {}
     927                      Node src = INVALID)
     928      : _Traits(graph, length, src) {}
    928929
    929930    /// \brief Copy constructor
    … …  
    939940      if(Base::_source == INVALID) throw UninitializedParameter();
    940941      BellmanFord<Graph,LengthMap,_Traits>
    941         bf(*(Graph*)Base::_graph, *(LengthMap*)Base::_length);
    942       if (Base::_pred) bf.predMap(*(PredMap*)Base::_pred);
    943       if (Base::_dist) bf.distMap(*(DistMap*)Base::_dist);
     942        bf(*reinterpret_cast<const Graph*>(Base::_graph),
     943           *reinterpret_cast<const LengthMap*>(Base::_length));
     944      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     945      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
    944946      bf.run(Base::_source);
    945947    }
    … …  
    949951    /// Runs BellmanFord algorithm from the given node.
    950952    /// \param source is the given source.
    951     void run(Node source) {
    952       Base::_source = source;
     953    void run(Node src) {
     954      Base::_source = src;
    953955      run();
    954956    }
    … …  
    970972    BellmanFordWizard<DefPredMapBase<T> > predMap(const T &t)
    971973    {
    972       Base::_pred=(void *)&t;
     974      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    973975      return BellmanFordWizard<DefPredMapBase<T> >(*this);
    974976    }
    … …  
    989991    template<class T>
    990992    BellmanFordWizard<DefDistMapBase<T> > distMap(const T &t) {
    991       Base::_dist=(void *)&t;
     993      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
    992994      return BellmanFordWizard<DefDistMapBase<T> >(*this);
    993995    }
    … …  
    10141016    /// Sets the source node, from which the BellmanFord algorithm runs.
    10151017    /// \param source is the source node.
    1016     BellmanFordWizard<_Traits>& source(Node source) {
    1017       Base::_source = source;
     1018    BellmanFordWizard<_Traits>& source(Node src) {
     1019      Base::_source = src;
    10181020      return *this;
    10191021    }

  • lemon/bfs.h

    r2376 r2386  
    489489    ///
    490490    ///\param target The target node.
    491     ///\retval reached Indicates that the target node is reached.
     491    ///\retval reach Indicates that the target node is reached.
    492492    ///\return The processed node.
    493493    ///
    494494    ///\warning The queue must not be empty!
    495     Node processNextNode(Node target, bool& reached)
     495    Node processNextNode(Node target, bool& reach)
    496496    {
    497497      if(_queue_tail==_queue_next_dist) {
    … …  
    508508          _pred->set(m,e);
    509509          _dist->set(m,_curr_dist);
    510           reached = reached || (target == m);
     510          reach = reach || (target == m);
    511511        }
    512512      return n;
    … …  
    522522    ///
    523523    ///\param nm The nodemaps of possible targets.
    524     ///\retval reached Indicates that one of the target nodes is reached.
     524    ///\retval reach Indicates that one of the target nodes is reached.
    525525    ///\return The processed node.
    526526    ///
    527527    ///\warning The queue must not be empty!
    528528    template<class NM>
    529     Node processNextNode(const NM& nm, bool& reached)
     529    Node processNextNode(const NM& nm, bool& reach)
    530530    {
    531531      if(_queue_tail==_queue_next_dist) {
    … …  
    542542          _pred->set(m,e);
    543543          _dist->set(m,_curr_dist);
    544           reached = reached || nm[m];
     544          reached = reach || nm[m];
    545545        }
    546546      return n;
    … …  
    605605    void start(Node dest)
    606606    {
    607       bool reached = false;
    608       while ( !emptyQueue() && !reached) processNextNode(dest, reached);
     607      bool reach = false;
     608      while ( !emptyQueue() && !reach) processNextNode(dest, reach);
    609609    }
    610610   
    … …  
    623623    void start(const NM &nm)
    624624    {
    625       bool reached = false;
    626       while ( !emptyQueue() && !reached) processNextNode(nm, reached);
     625      bool reach = false;
     626      while ( !emptyQueue() && !reach) processNextNode(nm, reach);
    627627    }
    628628   
    … …  
    883883    /// \param s is the initial value of  \ref _source
    884884    BfsWizardBase(const GR &g, Node s=INVALID) :
    885       _g((void *)&g), _reached(0), _processed(0), _pred(0),
    886       _dist(0), _source(s) {}
     885      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
     886      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
    887887
    888888  };
    … …  
    958958    {
    959959      if(Base::_source==INVALID) throw UninitializedParameter();
    960       Bfs<Graph,TR> alg(*(Graph*)Base::_g);
     960      Bfs<Graph,TR> alg(*reinterpret_cast<const Graph*>(Base::_g));
    961961      if(Base::_reached)
    962         alg.reachedMap(*(ReachedMap*)Base::_reached);
    963       if(Base::_processed) alg.processedMap(*(ProcessedMap*)Base::_processed);
    964       if(Base::_pred) alg.predMap(*(PredMap*)Base::_pred);
    965       if(Base::_dist) alg.distMap(*(DistMap*)Base::_dist);
     962        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
     963      if(Base::_processed)
     964        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     965      if(Base::_pred)
     966        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     967      if(Base::_dist)
     968        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
    966969      alg.run(Base::_source);
    967970    }
    … …  
    993996    BfsWizard<DefPredMapBase<T> > predMap(const T &t)
    994997    {
    995       Base::_pred=(void *)&t;
     998      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    996999      return BfsWizard<DefPredMapBase<T> >(*this);
    9971000    }
    … …  
    10141017    BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
    10151018    {
    1016       Base::_pred=(void *)&t;
     1019      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    10171020      return BfsWizard<DefReachedMapBase<T> >(*this);
    10181021    }
    … …  
    10351038    BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
    10361039    {
    1037       Base::_pred=(void *)&t;
     1040      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    10381041      return BfsWizard<DefProcessedMapBase<T> >(*this);
    10391042    }
    … …  
    10561059    BfsWizard<DefDistMapBase<T> > distMap(const T &t)
    10571060    {
    1058       Base::_dist=(void *)&t;
     1061      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
    10591062      return BfsWizard<DefDistMapBase<T> >(*this);
    10601063    }
    … …  
    14051408    ///
    14061409    /// \param target The target node.
    1407     /// \retval reached Indicates that the target node is reached.
     1410    /// \retval reach Indicates that the target node is reached.
    14081411    /// \return The processed node.
    14091412    ///
    14101413    /// \warning The queue must not be empty!
    1411     Node processNextNode(Node target, bool& reached) {
     1414    Node processNextNode(Node target, bool& reach) {
    14121415      Node n = _list[++_list_front];
    14131416      _visitor->process(n);
    … …  
    14201423          _reached->set(m, true);
    14211424          _list[++_list_back] = m;
    1422           reached = reached || (target == m);
     1425          reach = reach || (target == m);
    14231426        } else {
    14241427          _visitor->examine(e);
    … …  
    14421445    /// \warning The queue must not be empty!
    14431446    template <typename NM>
    1444     Node processNextNode(const NM& nm, bool& reached) {
     1447    Node processNextNode(const NM& nm, bool& reach) {
    14451448      Node n = _list[++_list_front];
    14461449      _visitor->process(n);
    … …  
    14531456          _reached->set(m, true);
    14541457          _list[++_list_back] = m;
    1455           reached = reached || nm[m];
     1458          reach = reach || nm[m];
    14561459        } else {
    14571460          _visitor->examine(e);
    … …  
    15001503    /// with addSource() before using this function.
    15011504    void start(Node dest) {
    1502       bool reached = false;
    1503       while (!emptyQueue() && !reached) {
    1504         processNextNode(dest, reached);
     1505      bool reach = false;
     1506      while (!emptyQueue() && !reach) {
     1507        processNextNode(dest, reach);
    15051508      }
    15061509    }
    … …  
    15181521    template <typename NM>
    15191522    void start(const NM &nm) {
    1520       bool reached = false;
    1521       while (!emptyQueue() && !reached) {
    1522         processNextNode(nm, reached);
     1523      bool reach = false;
     1524      while (!emptyQueue() && !reach) {
     1525        processNextNode(nm, reach);
    15231526      }
    15241527    }

  • lemon/bipartite_matching.h

    r2352 r2386  
    116116    /// It initalizes the data structures with an initial matching.
    117117    template <typename MatchingMap>
    118     void matchingInit(const MatchingMap& matching) {
     118    void matchingInit(const MatchingMap& mm) {
    119119      for (ANodeIt it(*graph); it != INVALID; ++it) {
    120120        anode_matching[it] = INVALID;
    … …  
    125125      matching_size = 0;
    126126      for (UEdgeIt it(*graph); it != INVALID; ++it) {
    127         if (matching[it]) {
     127        if (mm[it]) {
    128128          ++matching_size;
    129129          anode_matching[graph->aNode(it)] = it;
    … …  
    138138    /// \return %True when the given map contains really a matching.
    139139    template <typename MatchingMap>
    140     void checkedMatchingInit(const MatchingMap& matching) {
     140    void checkedMatchingInit(const MatchingMap& mm) {
    141141      for (ANodeIt it(*graph); it != INVALID; ++it) {
    142142        anode_matching[it] = INVALID;
    … …  
    147147      matching_size = 0;
    148148      for (UEdgeIt it(*graph); it != INVALID; ++it) {
    149         if (matching[it]) {
     149        if (mm[it]) {
    150150          ++matching_size;
    151151          if (anode_matching[graph->aNode(it)] != INVALID) {
    … …  
    188188      while (!success && !queue.empty()) {
    189189        std::vector<Node> newqueue;
    190         for (int i = 0; i < (int)queue.size(); ++i) {
     190        for (int i = 0; i < int(queue.size()); ++i) {
    191191          Node anode = queue[i];
    192192          for (IncEdgeIt jt(*graph, anode); jt != INVALID; ++jt) {
    … …  
    214214        typename Graph::template ANodeMap<bool> aused(*graph, false);
    215215       
    216         for (int i = 0; i < (int)bqueue.size(); ++i) {
     216        for (int i = 0; i < int(bqueue.size()); ++i) {
    217217          Node bnode = bqueue[i];
    218218
    … …  
    280280      while (!queue.empty()) {
    281281        std::vector<Node> newqueue;
    282         for (int i = 0; i < (int)queue.size(); ++i) {
     282        for (int i = 0; i < int(queue.size()); ++i) {
    283283          Node anode = queue[i];
    284284          for (IncEdgeIt jt(*graph, anode); jt != INVALID; ++jt) {
    … …  
    364364      while (!queue.empty()) {
    365365        std::vector<Node> newqueue;
    366         for (int i = 0; i < (int)queue.size(); ++i) {
     366        for (int i = 0; i < int(queue.size()); ++i) {
    367367          Node anode = queue[i];
    368368          for (IncEdgeIt jt(*graph, anode); jt != INVALID; ++jt) {
    … …  
    404404    /// \return The number of the matching edges.
    405405    template <typename MatchingMap>
    406     int quickMatching(MatchingMap& matching) const {
     406    int quickMatching(MatchingMap& mm) const {
    407407      for (ANodeIt it(*graph); it != INVALID; ++it) {
    408408        if (anode_matching[it] != INVALID) {
    409           matching[anode_matching[it]] = true;
     409          mm[anode_matching[it]] = true;
    410410        }
    411411      }
    … …  
    418418    /// \return The number of the matching edges.
    419419    template <typename MatchingMap>
    420     int matching(MatchingMap& matching) const {
     420    int matching(MatchingMap& mm) const {
    421421      for (UEdgeIt it(*graph); it != INVALID; ++it) {
    422         matching[it] = it == anode_matching[graph->aNode(it)];
     422        mm[it] = it == anode_matching[graph->aNode(it)];
    423423      }
    424424      return matching_size;
    … …  
    684684    /// automatically allocated map, of course.
    685685    /// \return \c (*this)
    686     MaxWeightedBipartiteMatching& heap(Heap& heap, HeapCrossRef &crossRef) {
     686    MaxWeightedBipartiteMatching& heap(Heap& hp, HeapCrossRef &cr) {
    687687      if(local_heap_cross_ref) {
    688688        delete _heap_cross_ref;
    689689        local_heap_cross_ref = false;
    690690      }
    691       _heap_cross_ref = &crossRef;
     691      _heap_cross_ref = &cr;
    692692      if(local_heap) {
    693693        delete _heap;
    694694        local_heap = false;
    695695      }
    696       _heap = &heap;
     696      _heap = &hp;
    697697      return *this;
    698698    }
    … …  
    890890    /// for each edges.
    891891    template <typename PotentialMap>
    892     void potential(PotentialMap& potential) const {
    893       for (ANodeIt it(*graph); it != INVALID; ++it) {
    894         potential[it] = anode_potential[it];
     892    void potential(PotentialMap& pt) const {
     893      for (ANodeIt it(*graph); it != INVALID; ++it) {
     894        pt[it] = anode_potential[it];
    895895      }
    896896      for (BNodeIt it(*graph); it != INVALID; ++it) {
    897         potential[it] = bnode_potential[it];
     897        pt[it] = bnode_potential[it];
    898898      }
    899899    }
    … …  
    905905    /// \return The number of the matching edges.
    906906    template <typename MatchingMap>
    907     int quickMatching(MatchingMap& matching) const {
     907    int quickMatching(MatchingMap& mm) const {
    908908      for (ANodeIt it(*graph); it != INVALID; ++it) {
    909909        if (anode_matching[it] != INVALID) {
    910           matching[anode_matching[it]] = true;
     910          mm[anode_matching[it]] = true;
    911911        }
    912912      }
    … …  
    919919    /// \return The number of the matching edges.
    920920    template <typename MatchingMap>
    921     int matching(MatchingMap& matching) const {
     921    int matching(MatchingMap& mm) const {
    922922      for (UEdgeIt it(*graph); it != INVALID; ++it) {
    923         matching[it] = it == anode_matching[graph->aNode(it)];
     923        mm[it] = it == anode_matching[graph->aNode(it)];
    924924      }
    925925      return matching_size;
    … …  
    12551255    /// automatically allocated map, of course.
    12561256    /// \return \c (*this)
    1257     MinCostMaxBipartiteMatching& heap(Heap& heap, HeapCrossRef &crossRef) {
     1257    MinCostMaxBipartiteMatching& heap(Heap& hp, HeapCrossRef &cr) {
    12581258      if(local_heap_cross_ref) {
    12591259        delete _heap_cross_ref;
    12601260        local_heap_cross_ref = false;
    12611261      }
    1262       _heap_cross_ref = &crossRef;
     1262      _heap_cross_ref = &cr;
    12631263      if(local_heap) {
    12641264        delete _heap;
    12651265        local_heap = false;
    12661266      }
    1267       _heap = &heap;
     1267      _heap = &hp;
    12681268      return *this;
    12691269    }
    … …  
    14431443    /// for each edges.
    14441444    template <typename PotentialMap>
    1445     void potential(PotentialMap& potential) const {
    1446       for (ANodeIt it(*graph); it != INVALID; ++it) {
    1447         potential[it] = anode_potential[it];
     1445    void potential(PotentialMap& pt) const {
     1446      for (ANodeIt it(*graph); it != INVALID; ++it) {
     1447        pt[it] = anode_potential[it];
    14481448      }
    14491449      for (BNodeIt it(*graph); it != INVALID; ++it) {
    1450         potential[it] = bnode_potential[it];
     1450        pt[it] = bnode_potential[it];
    14511451      }
    14521452    }
    … …  
    14581458    /// \return The number of the matching edges.
    14591459    template <typename MatchingMap>
    1460     int quickMatching(MatchingMap& matching) const {
     1460    int quickMatching(MatchingMap& mm) const {
    14611461      for (ANodeIt it(*graph); it != INVALID; ++it) {
    14621462        if (anode_matching[it] != INVALID) {
    1463           matching[anode_matching[it]] = true;
     1463          mm[anode_matching[it]] = true;
    14641464        }
    14651465      }
    … …  
    14721472    /// \return The number of the matching edges.
    14731473    template <typename MatchingMap>
    1474     int matching(MatchingMap& matching) const {
     1474    int matching(MatchingMap& mm) const {
    14751475      for (UEdgeIt it(*graph); it != INVALID; ++it) {
    1476         matching[it] = it == anode_matching[graph->aNode(it)];
     1476        mm[it] = it == anode_matching[graph->aNode(it)];
    14771477      }
    14781478      return matching_size;

  • lemon/bits/alteration_notifier.h

    r2384 r2386  
    149149      ///
    150150      /// Constructor which attach the observer into notifier.
    151       ObserverBase(AlterationNotifier& notifier) {
    152         attach(notifier);
     151      ObserverBase(AlterationNotifier& nf) {
     152        attach(nf);
    153153      }
    154154
    … …  
    159159      ObserverBase(const ObserverBase& copy) {
    160160        if (copy.attached()) {
    161           attach(*copy._notifier());
     161          attach(*copy.notifier());
    162162        }
    163163      }
    … …  
    174174      /// This member attaches the observer into an AlterationNotifier.
    175175      ///
    176       void attach(AlterationNotifier& notifier) {
    177         notifier.attach(*this);
     176      void attach(AlterationNotifier& nf) {
     177        nf.attach(*this);
    178178      }
    179179     

  • lemon/bits/array_map.h

    r2384 r2386  
    8282      Parent::attach(graph.notifier(Item()));
    8383      allocate_memory();
    84       Notifier* notifier = Parent::notifier();
    85       Item it;
    86       for (notifier->first(it); it != INVALID; notifier->next(it)) {
    87         int id = notifier->id(it);;
     84      Notifier* nf = Parent::notifier();
     85      Item it;
     86      for (nf->first(it); it != INVALID; nf->next(it)) {
     87        int id = nf->id(it);;
    8888        allocator.construct(&(values[id]), Value());
    8989      }                                                         
    … …  
    9696      Parent::attach(graph.notifier(Item()));
    9797      allocate_memory();
    98       Notifier* notifier = Parent::notifier();
    99       Item it;
    100       for (notifier->first(it); it != INVALID; notifier->next(it)) {
    101         int id = notifier->id(it);;
     98      Notifier* nf = Parent::notifier();
     99      Item it;
     100      for (nf->first(it); it != INVALID; nf->next(it)) {
     101        int id = nf->id(it);;
    102102        allocator.construct(&(values[id]), value);
    103103      }                                                         
    … …  
    114114      if (capacity == 0) return;
    115115      values = allocator.allocate(capacity);
    116       Notifier* notifier = Parent::notifier();
    117       Item it;
    118       for (notifier->first(it); it != INVALID; notifier->next(it)) {
    119         int id = notifier->id(it);;
     116      Notifier* nf = Parent::notifier();
     117      Item it;
     118      for (nf->first(it); it != INVALID; nf->next(it)) {
     119        int id = nf->id(it);;
    120120        allocator.construct(&(values[id]), copy.values[id]);
    121121      }
    … …  
    143143    ArrayMap& operator=(const CMap& cmap) {
    144144      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
    145       const typename Parent::Notifier* notifier = Parent::notifier();
    146       Item it;
    147       for (notifier->first(it); it != INVALID; notifier->next(it)) {
     145      const typename Parent::Notifier* nf = Parent::notifier();
     146      Item it;
     147      for (nf->first(it); it != INVALID; nf->next(it)) {
    148148        set(it, cmap[it]);
    149149      }
    … …  
    202202    /// and it overrides the add() member function of the observer base.     
    203203    virtual void add(const Key& key) {
    204       Notifier* notifier = Parent::notifier();
    205       int id = notifier->id(key);
     204      Notifier* nf = Parent::notifier();
     205      int id = nf->id(key);
    206206      if (id >= capacity) {
    207207        int new_capacity = (capacity == 0 ? 1 : capacity);
    … …  
    211211        Value* new_values = allocator.allocate(new_capacity);
    212212        Item it;
    213         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    214           int jd = notifier->id(it);;
     213        for (nf->first(it); it != INVALID; nf->next(it)) {
     214          int jd = nf->id(it);;
    215215          if (id != jd) {
    216216            allocator.construct(&(new_values[jd]), values[jd]);
    … …  
    230230    /// and it overrides the add() member function of the observer base.     
    231231    virtual void add(const std::vector<Key>& keys) {
    232       Notifier* notifier = Parent::notifier();
     232      Notifier* nf = Parent::notifier();
    233233      int max_id = -1;
    234       for (int i = 0; i < (int)keys.size(); ++i) {
    235         int id = notifier->id(keys[i]);
     234      for (int i = 0; i < int(keys.size()); ++i) {
     235        int id = nf->id(keys[i]);
    236236        if (id > max_id) {
    237237          max_id = id;
    … …  
    245245        Value* new_values = allocator.allocate(new_capacity);
    246246        Item it;
    247         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    248           int id = notifier->id(it);
     247        for (nf->first(it); it != INVALID; nf->next(it)) {
     248          int id = nf->id(it);
    249249          bool found = false;
    250           for (int i = 0; i < (int)keys.size(); ++i) {
    251             int jd = notifier->id(keys[i]);
     250          for (int i = 0; i < int(keys.size()); ++i) {
     251            int jd = nf->id(keys[i]);
    252252            if (id == jd) {
    253253              found = true;
    … …  
    263263        capacity = new_capacity;
    264264      }
    265       for (int i = 0; i < (int)keys.size(); ++i) {
    266         int id = notifier->id(keys[i]);
     265      for (int i = 0; i < int(keys.size()); ++i) {
     266        int id = nf->id(keys[i]);
    267267        allocator.construct(&(values[id]), Value());
    268268      }
    … …  
    283283    /// and it overrides the erase() member function of the observer base.     
    284284    virtual void erase(const std::vector<Key>& keys) {
    285       for (int i = 0; i < (int)keys.size(); ++i) {
     285      for (int i = 0; i < int(keys.size()); ++i) {
    286286        int id = Parent::notifier()->id(keys[i]);
    287287        allocator.destroy(&(values[id]));
    … …  
    294294    /// and it overrides the build() member function of the observer base.
    295295    virtual void build() {
    296       Notifier* notifier = Parent::notifier();
     296      Notifier* nf = Parent::notifier();
    297297      allocate_memory();
    298298      Item it;
    299       for (notifier->first(it); it != INVALID; notifier->next(it)) {
    300         int id = notifier->id(it);;
     299      for (nf->first(it); it != INVALID; nf->next(it)) {
     300        int id = nf->id(it);;
    301301        allocator.construct(&(values[id]), Value());
    302302      }                                                         
    … …  
    308308    /// and it overrides the clear() member function of the observer base.     
    309309    virtual void clear() {     
    310       Notifier* notifier = Parent::notifier();
     310      Notifier* nf = Parent::notifier();
    311311      if (capacity != 0) {
    312312        Item it;
    313         for (notifier->first(it); it != INVALID; notifier->next(it)) {
    314           int id = notifier->id(it);
     313        for (nf->first(it); it != INVALID; nf->next(it)) {
     314          int id = nf->id(it);
    315315          allocator.destroy(&(values[id]));
    316316        }                                                               

  • lemon/bits/base_extender.h

    r2260 r2386  
    194194    }
    195195
    196     Node nodeFromId(int id) const {
    197       return Parent::nodeFromId(id);
    198     }
    199 
    200     Edge edgeFromId(int id) const {
    201       return direct(Parent::edgeFromId(id >> 1), bool(id & 1));
    202     }
    203 
    204     UEdge uEdgeFromId(int id) const {
    205       return Parent::edgeFromId(id);
     196    Node nodeFromId(int ix) const {
     197      return Parent::nodeFromId(ix);
     198    }
     199
     200    Edge edgeFromId(int ix) const {
     201      return direct(Parent::edgeFromId(ix >> 1), bool(ix & 1));
     202    }
     203
     204    UEdge uEdgeFromId(int ix) const {
     205      return Parent::edgeFromId(ix);
    206206    }
    207207
    … …  
    239239    }
    240240
    241     Edge findEdge(Node source, Node target, Edge prev = INVALID) const {
    242       if (prev == INVALID) {
    243         UEdge edge = Parent::findEdge(source, target);
     241    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
     242      if (p == INVALID) {
     243        UEdge edge = Parent::findEdge(s, t);
    244244        if (edge != INVALID) return direct(edge, true);
    245         edge = Parent::findEdge(target, source);
     245        edge = Parent::findEdge(t, s);
    246246        if (edge != INVALID) return direct(edge, false);
    247       } else if (direction(prev)) {
    248         UEdge edge = Parent::findEdge(source, target, prev);
     247      } else if (direction(p)) {
     248        UEdge edge = Parent::findEdge(s, t, p);
    249249        if (edge != INVALID) return direct(edge, true);
    250         edge = Parent::findEdge(target, source);
     250        edge = Parent::findEdge(t, s);
    251251        if (edge != INVALID) return direct(edge, false);       
    252252      } else {
    253         UEdge edge = Parent::findEdge(target, source, prev);
     253        UEdge edge = Parent::findEdge(t, s, p);
    254254        if (edge != INVALID) return direct(edge, false);             
    255255      }
    … …  
    257257    }
    258258
    259     UEdge findUEdge(Node source, Node target, UEdge prev = INVALID) const {
    260       if (source != target) {
    261         if (prev == INVALID) {
    262           UEdge edge = Parent::findEdge(source, target);
     259    UEdge findUEdge(Node s, Node t, UEdge p = INVALID) const {
     260      if (s != t) {
     261        if (p == INVALID) {
     262          UEdge edge = Parent::findEdge(s, t);
    263263          if (edge != INVALID) return edge;
    264           edge = Parent::findEdge(target, source);
     264          edge = Parent::findEdge(t, s);
    265265          if (edge != INVALID) return edge;
    266         } else if (Parent::source(prev) == source) {
    267           UEdge edge = Parent::findEdge(source, target, prev);
     266        } else if (Parent::s(p) == s) {
     267          UEdge edge = Parent::findEdge(s, t, p);
    268268          if (edge != INVALID) return edge;
    269           edge = Parent::findEdge(target, source);
     269          edge = Parent::findEdge(t, s);
    270270          if (edge != INVALID) return edge;     
    271271        } else {
    272           UEdge edge = Parent::findEdge(target, source, prev);
     272          UEdge edge = Parent::findEdge(t, s, p);
    273273          if (edge != INVALID) return edge;           
    274274        }
    275275      } else {
    276         return Parent::findEdge(source, target, prev);
     276        return Parent::findEdge(s, t, p);
    277277      }
    278278      return INVALID;
    … …  
    358358    }
    359359
    360     void firstInc(UEdge& edge, bool& direction, const Node& node) const {
     360    void firstInc(UEdge& edge, bool& dir, const Node& node) const {
    361361      if (Parent::aNode(node)) {
    362362        Parent::firstFromANode(edge, node);
    363         direction = true;
     363        dir = true;
    364364      } else {
    365365        Parent::firstFromBNode(edge, node);
    366         direction = static_cast<UEdge&>(edge) == INVALID;
    367       }
    368     }
    369     void nextInc(UEdge& edge, bool& direction) const {
    370       if (direction) {
     366        dir = static_cast<UEdge&>(edge) == INVALID;
     367      }
     368    }
     369    void nextInc(UEdge& edge, bool& dir) const {
     370      if (dir) {
    371371        Parent::nextFromANode(edge);
    372372      } else {
    373373        Parent::nextFromBNode(edge);
    374         if (edge == INVALID) direction = true;
     374        if (edge == INVALID) dir = true;
    375375      }
    376376    }
    … …  
    458458        (edge.forward ? 0 : 1);
    459459    }
    460     Edge edgeFromId(int id) const {
    461       return Edge(Parent::fromUEdgeId(id >> 1), (id & 1) == 0);
     460    Edge edgeFromId(int ix) const {
     461      return Edge(Parent::fromUEdgeId(ix >> 1), (ix & 1) == 0);
    462462    }
    463463    int maxEdgeId() const {
    … …  
    469469    }
    470470
    471     Edge direct(const UEdge& edge, bool direction) const {
    472       return Edge(edge, direction);
     471    Edge direct(const UEdge& edge, bool dir) const {
     472      return Edge(edge, dir);
    473473    }
    474474

  • lemon/bits/debug_map.h

    r2384 r2386  
    166166        }
    167167      }
    168       for (int i = 0; i < (int)flag.size(); ++i) {
     168      for (int i = 0; i < int(flag.size()); ++i) {
    169169        LEMON_ASSERT(!flag[i], MapError());
    170170      }
    … …  
    236236    virtual void add(const Key& key) {
    237237      int id = Parent::notifier()->id(key);
    238       if (id >= (int)container.size()) {
     238      if (id >= int(container.size())) {
    239239        container.resize(id + 1);
    240240        flag.resize(id + 1, false);
    … …  
    247247        Item it;
    248248        for (notifier->first(it); it != INVALID; notifier->next(it)) {
    249           int id = Parent::notifier()->id(it);
    250           fl[id] = true;
     249          int jd = Parent::notifier()->id(it);
     250          fl[jd] = true;
    251251        }
    252252        LEMON_ASSERT(fl == flag, MapError());
    … …  
    260260    virtual void add(const std::vector<Key>& keys) {
    261261      int max = container.size() - 1;
    262       for (int i = 0; i < (int)keys.size(); ++i) {
     262      for (int i = 0; i < int(keys.size()); ++i) {
    263263        int id = Parent::notifier()->id(keys[i]);
    264264        if (id >= max) {
    … …  
    268268      container.resize(max + 1);
    269269      flag.resize(max + 1, false);
    270       for (int i = 0; i < (int)keys.size(); ++i) {
     270      for (int i = 0; i < int(keys.size()); ++i) {
    271271        LEMON_ASSERT(!flag[Parent::notifier()->id(keys[i])], MapError());
    272272        flag[Parent::notifier()->id(keys[i])] = true;
    … …  
    319319        LEMON_ASSERT(fl == flag, MapError());
    320320      }
    321       for (int i = 0; i < (int)keys.size(); ++i) {
     321      for (int i = 0; i < int(keys.size()); ++i) {
    322322        container[Parent::notifier()->id(keys[i])] = Value();
    323323        LEMON_ASSERT(flag[Parent::notifier()->id(keys[i])], MapError());
    … …  
    332332    virtual void build() {
    333333      if (strictCheck) {
    334         for (int i = 0; i < (int)flag.size(); ++i) {
     334        for (int i = 0; i < int(flag.size()); ++i) {
    335335          LEMON_ASSERT(flag[i], MapError());
    336336        }
    … …  
    363363      }
    364364      if (strictCheck) {
    365         for (int i = 0; i < (int)flag.size(); ++i) {
     365        for (int i = 0; i < int(flag.size()); ++i) {
    366366          LEMON_ASSERT(!flag[i], MapError());
    367367        }

  • lemon/bits/edge_set_extender.h

    r2384 r2386  
    190190    /// Returns the base node (ie. the source in this case) of the iterator
    191191    Node baseNode(const OutEdgeIt &e) const {
    192       return Parent::source((Edge)e);
     192      return Parent::source(static_cast<const Edge&>(e));
    193193    }
    194194    /// \brief Running node of the iterator
    … …  
    197197    /// iterator
    198198    Node runningNode(const OutEdgeIt &e) const {
    199       return Parent::target((Edge)e);
     199      return Parent::target(static_cast<const Edge&>(e));
    200200    }
    201201
    … …  
    204204    /// Returns the base node (ie. the target in this case) of the iterator
    205205    Node baseNode(const InEdgeIt &e) const {
    206       return Parent::target((Edge)e);
     206      return Parent::target(static_cast<const Edge&>(e));
    207207    }
    208208    /// \brief Running node of the iterator
    … …  
    211211    /// iterator
    212212    Node runningNode(const InEdgeIt &e) const {
    213       return Parent::source((Edge)e);
     213      return Parent::source(static_cast<const Edge&>(e));
    214214    }
    215215
    … …  
    497497    /// Returns the base node (ie. the source in this case) of the iterator
    498498    Node baseNode(const OutEdgeIt &e) const {
    499       return Parent::source((Edge)e);
     499      return Parent::source(static_cast<const Edge&>(e));
    500500    }
    501501    /// \brief Running node of the iterator
    … …  
    504504    /// iterator
    505505    Node runningNode(const OutEdgeIt &e) const {
    506       return Parent::target((Edge)e);
     506      return Parent::target(static_cast<const Edge&>(e));
    507507    }
    508508
    … …  
    511511    /// Returns the base node (ie. the target in this case) of the iterator
    512512    Node baseNode(const InEdgeIt &e) const {
    513       return Parent::target((Edge)e);
     513      return Parent::target(static_cast<const Edge&>(e));
    514514    }
    515515    /// \brief Running node of the iterator
    … …  
    518518    /// iterator
    519519    Node runningNode(const InEdgeIt &e) const {
    520       return Parent::source((Edge)e);
     520      return Parent::source(static_cast<const Edge&>(e));
    521521    }
    522522

  • lemon/bits/graph_adaptor_extender.h

    r2231 r2386  
    400400    /// Returns the base node (ie. the source in this case) of the iterator
    401401    Node baseNode(const OutEdgeIt &e) const {
    402       return Parent::source((Edge)e);
     402      return Parent::source(static_cast<const Edge&>(e));
    403403    }
    404404    /// \brief Running node of the iterator
    … …  
    407407    /// iterator
    408408    Node runningNode(const OutEdgeIt &e) const {
    409       return Parent::target((Edge)e);
     409      return Parent::target(static_cast<const Edge&>(e));
    410410    }
    411411
    … …  
    414414    /// Returns the base node (ie. the target in this case) of the iterator
    415415    Node baseNode(const InEdgeIt &e) const {
    416       return Parent::target((Edge)e);
     416      return Parent::target(static_cast<const Edge&>(e));
    417417    }
    418418    /// \brief Running node of the iterator
    … …  
    421421    /// iterator
    422422    Node runningNode(const InEdgeIt &e) const {
    423       return Parent::source((Edge)e);
     423      return Parent::source(static_cast<const Edge&>(e));
    424424    }
    425425
    … …  
    652652    /// Returns the base node (ie. the source in this case) of the iterator
    653653    Node baseNode(const OutEdgeIt &e) const {
    654       return Parent::source((Edge&)e);
     654      return Parent::source(static_cast<const Edge&>(e));
    655655    }
    656656    /// \brief Running node of the iterator
    … …  
    659659    /// iterator
    660660    Node runningNode(const OutEdgeIt &e) const {
    661       return Parent::target((Edge&)e);
     661      return Parent::target(static_cast<const Edge&>(e));
    662662    }
    663663 
    … …  
    666666    /// Returns the base node (ie. the target in this case) of the iterator
    667667    Node baseNode(const InEdgeIt &e) const {
    668       return Parent::target((Edge&)e);
     668      return Parent::target(static_cast<const Edge&>(e));
    669669    }
    670670    /// \brief Running node of the iterator
    … …  
    673673    /// iterator
    674674    Node runningNode(const InEdgeIt &e) const {
    675       return Parent::source((Edge&)e);
     675      return Parent::source(static_cast<const Edge&>(e));
    676676    }
    677677 

  • lemon/bits/graph_extender.h

    r2384 r2386  
    557557    /// Returns the base node (ie. the source in this case) of the iterator
    558558    Node baseNode(const OutEdgeIt &e) const {
    559       return Parent::source((Edge)e);
     559      return Parent::source(static_cast<const Edge&>(e));
    560560    }
    561561    /// \brief Running node of the iterator
    … …  
    564564    /// iterator
    565565    Node runningNode(const OutEdgeIt &e) const {
    566       return Parent::target((Edge)e);
     566      return Parent::target(static_cast<const Edge&>(e));
    567567    }
    568568
    … …  
    571571    /// Returns the base node (ie. the target in this case) of the iterator
    572572    Node baseNode(const InEdgeIt &e) const {
    573       return Parent::target((Edge)e);
     573      return Parent::target(static_cast<const Edge&>(e));
    574574    }
    575575    /// \brief Running node of the iterator
    … …  
    578578    /// iterator
    579579    Node runningNode(const InEdgeIt &e) const {
    580       return Parent::source((Edge)e);
     580      return Parent::source(static_cast<const Edge&>(e));
    581581    }
    582582
    … …  
    680680      UEdge uedge = Parent::addEdge(from, to);
    681681      notifier(UEdge()).add(uedge);
    682       std::vector<Edge> edges;
    683       edges.push_back(Parent::direct(uedge, true));
    684       edges.push_back(Parent::direct(uedge, false));     
    685       notifier(Edge()).add(edges);
     682      std::vector<Edge> ev;
     683      ev.push_back(Parent::direct(uedge, true));
     684      ev.push_back(Parent::direct(uedge, false));     
     685      notifier(Edge()).add(ev);
    686686      return uedge;
    687687    }
    … …  
    722722
    723723    void erase(const UEdge& uedge) {
    724       std::vector<Edge> edges;
    725       edges.push_back(Parent::direct(uedge, true));
    726       edges.push_back(Parent::direct(uedge, false));     
    727       notifier(Edge()).erase(edges);
     724      std::vector<Edge> ev;
     725      ev.push_back(Parent::direct(uedge, true));
     726      ev.push_back(Parent::direct(uedge, false));     
     727      notifier(Edge()).erase(ev);
    728728      notifier(UEdge()).erase(uedge);
    729729      Parent::erase(uedge);
    … …  
    10081008    /// Returns the base node (ie. the source in this case) of the iterator
    10091009    Node baseNode(const OutEdgeIt &e) const {
    1010       return Parent::source((Edge&)e);
     1010      return Parent::source(static_cast<const Edge&>(e));
    10111011    }
    10121012    /// \brief Running node of the iterator
    … …  
    10151015    /// iterator
    10161016    Node runningNode(const OutEdgeIt &e) const {
    1017       return Parent::target((Edge&)e);
     1017      return Parent::target(static_cast<const Edge&>(e));
    10181018    }
    10191019 
    … …  
    10221022    /// Returns the base node (ie. the target in this case) of the iterator
    10231023    Node baseNode(const InEdgeIt &e) const {
    1024       return Parent::target((Edge&)e);
     1024      return Parent::target(static_cast<const Edge&>(e));
    10251025    }
    10261026    /// \brief Running node of the iterator
    … …  
    10291029    /// iterator
    10301030    Node runningNode(const InEdgeIt &e) const {
    1031       return Parent::source((Edge&)e);
     1031      return Parent::source(static_cast<const Edge&>(e));
    10321032    }
    10331033 
    … …  
    12961296    }
    12971297 
    1298     UEdge addEdge(const Node& source, const Node& target) {
    1299       UEdge uedge = Parent::addEdge(source, target);
     1298    UEdge addEdge(const Node& s, const Node& t) {
     1299      UEdge uedge = Parent::addEdge(s, t);
    13001300      notifier(UEdge()).add(uedge);
    13011301   
    1302       std::vector<Edge> edges;
    1303       edges.push_back(Parent::direct(uedge, true));
    1304       edges.push_back(Parent::direct(uedge, false));
    1305       notifier(Edge()).add(edges);
     1302      std::vector<Edge> ev;
     1303      ev.push_back(Parent::direct(uedge, true));
     1304      ev.push_back(Parent::direct(uedge, false));
     1305      notifier(Edge()).add(ev);
    13061306   
    13071307      return uedge;
    … …  
    13521352   
    13531353    void erase(const UEdge& uedge) {
    1354       std::vector<Edge> edges;
    1355       edges.push_back(Parent::direct(uedge, true));
    1356       edges.push_back(Parent::direct(uedge, false));
    1357       notifier(Edge()).erase(edges);
     1354      std::vector<Edge> ev;
     1355      ev.push_back(Parent::direct(uedge, true));
     1356      ev.push_back(Parent::direct(uedge, false));
     1357      notifier(Edge()).erase(ev);
    13581358      notifier(UEdge()).erase(uedge);
    13591359      Parent::erase(uedge);

  • lemon/bits/item_reader.h

    r2254 r2386  
    595595          if (!(is >> temp))
    596596            throw DataFormatError("DefaultReader<char> format error");
    597           value = (char)temp;
     597          value = static_cast<char>(temp);
    598598          break;
    599599        }

  • lemon/bits/item_writer.h

    r2255 r2386  
    156156      if (escaped) {
    157157        std::ostringstream ls;
    158         for (int i = 0; i < (int)value.size(); ++i) {
     158        for (int i = 0; i < int(value.size()); ++i) {
    159159          writeEscape(ls, value[i]);
    160160        }
    … …  
    205205      default:
    206206        if (c < 0x20) {
    207           os << '\\' << std::oct << (int)c;
     207          os << '\\' << std::oct << static_cast<int>(c);
    208208        } else {
    209209          os << c;

  • lemon/bits/lp_id.h

    r2363 r2386  
    7878          impl.index[xn] = impl.first_free;
    7979          impl.first_free = xn;
    80           for(int i = fn + 1; i < (int)impl.cross.size(); ++i) {
     80          for(int i = fn + 1; i < int(impl.cross.size()); ++i) {
    8181            impl.cross[i - 1] = impl.cross[i];
    8282            impl.index[impl.cross[i]]--;
    … …  
    9090      void firstFloating(int& fn) const {
    9191        fn = impl.first_index;
    92         if (fn == (int)impl.cross.size()) fn = -1;
     92        if (fn == int(impl.cross.size())) fn = -1;
    9393      }
    9494
    9595      void nextFloating(int& fn) const {
    9696        ++fn;
    97         if (fn == (int)impl.cross.size()) fn = -1;
     97        if (fn == int(impl.cross.size())) fn = -1;
    9898      }
    9999

  • lemon/bits/utility.h

    r2177 r2386  
    7070
    7171
    72   class InvalidType {
    73   private:
    74     InvalidType();
     72  struct InvalidType {
    7573  };
    7674

  • lemon/bits/variant.h

    r2292 r2386  
    7474    /// This constructor initalizes to the given value of the \c First
    7575    /// type.
    76     BiVariant(const First& first) {
     76    BiVariant(const First& f) {
    7777      flag = true;
    78       new(reinterpret_cast<First*>(data)) First(first);
     78      new(reinterpret_cast<First*>(data)) First(f);
    7979    }
    8080
    … …  
    8383    /// This constructor initalizes to the given value of the \c
    8484    /// Second type.
    85     BiVariant(const Second& second) {
     85    BiVariant(const Second& s) {
    8686      flag = false;
    87       new(reinterpret_cast<Second*>(data)) Second(second);
     87      new(reinterpret_cast<Second*>(data)) Second(s);
    8888    }
    8989
    … …  
    122122    /// This function sets the variant to the given value of the \c
    123123    /// First type.
    124     BiVariant& setFirst(const First& first) {
     124    BiVariant& setFirst(const First& f) {
    125125      destroy();
    126126      flag = true;
    127       new(reinterpret_cast<First*>(data)) First(first);   
     127      new(reinterpret_cast<First*>(data)) First(f);   
    128128      return *this;
    129129    }
    … …  
    144144    /// This function sets the variant to the given value of the \c
    145145    /// Second type.
    146     BiVariant& setSecond(const Second& second) {
     146    BiVariant& setSecond(const Second& s) {
    147147      destroy();
    148148      flag = false;
    149       new(reinterpret_cast<Second*>(data)) Second(second);   
     149      new(reinterpret_cast<Second*>(data)) Second(s);   
    150150      return *this;
    151151    }
    152152
    153153    /// \brief Operator form of the \c setFirst()
    154     BiVariant& operator=(const First& first) {
    155       return setFirst(first);
     154    BiVariant& operator=(const First& f) {
     155      return setFirst(f);
    156156    }
    157157
    158158    /// \brief Operator form of the \c setSecond()
    159     BiVariant& operator=(const Second& second) {
    160       return setSecond(second);
     159    BiVariant& operator=(const Second& s) {
     160      return setSecond(s);
    161161    }
    162162

  • lemon/bits/vector_map.h

    r2384 r2386  
    135135    VectorMap& operator=(const CMap& cmap) {
    136136      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
    137       const typename Parent::Notifier* notifier = Parent::notifier();
     137      const typename Parent::Notifier* nf = Parent::notifier();
    138138      Item it;
    139       for (notifier->first(it); it != INVALID; notifier->next(it)) {
     139      for (nf->first(it); it != INVALID; nf->next(it)) {
    140140        set(it, cmap[it]);
    141141      }
    … …  
    177177    virtual void add(const Key& key) {
    178178      int id = Parent::notifier()->id(key);
    179       if (id >= (int)container.size()) {
     179      if (id >= int(container.size())) {
    180180        container.resize(id + 1);
    181181      }
    … …  
    188188    virtual void add(const std::vector<Key>& keys) {
    189189      int max = container.size() - 1;
    190       for (int i = 0; i < (int)keys.size(); ++i) {
     190      for (int i = 0; i < int(keys.size()); ++i) {
    191191        int id = Parent::notifier()->id(keys[i]);
    192192        if (id >= max) {
    … …  
    210210    /// and it overrides the erase() member function of the observer base.     
    211211    virtual void erase(const std::vector<Key>& keys) {
    212       for (int i = 0; i < (int)keys.size(); ++i) {
     212      for (int i = 0; i < int(keys.size()); ++i) {
    213213        container[Parent::notifier()->id(keys[i])] = Value();
    214214      }

  • lemon/bpugraph_adaptor.h

    r2384 r2386  
    128128
    129129    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
    130     Edge findEdge(const Node& source, const Node& target,
     130    Edge findEdge(const Node& u, const Node& v,
    131131                  const Edge& prev = INVALID) {
    132       return graph->findEdge(source, target, prev);
    133     }
    134     UEdge findUEdge(const Node& source, const Node& target,
     132      return graph->findEdge(u, v, prev);
     133    }
     134    UEdge findUEdge(const Node& u, const Node& v,
    135135                    const UEdge& prev = INVALID) {
    136       return graph->findUEdge(source, target, prev);
     136      return graph->findUEdge(u, v, prev);
    137137    }
    138138 
    139139    Node addANode() const { return graph->addANode(); }
    140140    Node addBNode() const { return graph->addBNode(); }
    141     UEdge addEdge(const Node& source, const Node& target) const {
    142       return graph->addEdge(source, target);
     141    UEdge addEdge(const Node& u, const Node& v) const {
     142      return graph->addEdge(u, v);
    143143    }
    144144
    … …  
    157157    int id(const UEdge& e) const { return graph->id(e); }
    158158
    159     Node fromNodeId(int id) const { return graph->fromNodeId(id); }
    160     ANode nodeFromANodeId(int id) const { return graph->nodeFromANodeId(id); }
    161     BNode nodeFromBNodeId(int id) const { return graph->nodeFromBNodeId(id); }
    162     Edge fromEdgeId(int id) const { return graph->fromEdgeId(id); }
    163     UEdge fromUEdgeId(int id) const { return graph->fromUEdgeId(id); }
     159    Node fromNodeId(int ix) const { return graph->fromNodeId(ix); }
     160    ANode nodeFromANodeId(int ix) const { return graph->nodeFromANodeId(ix); }
     161    BNode nodeFromBNodeId(int ix) const { return graph->nodeFromBNodeId(ix); }
     162    Edge fromEdgeId(int ix) const { return graph->fromEdgeId(ix); }
     163    UEdge fromUEdgeId(int ix) const { return graph->fromUEdgeId(ix); }
    164164
    165165    int maxNodeId() const { return graph->maxNodeId(); }
    … …  
    362362    int id(const BNode& v) const { return Parent::id(v); }
    363363
    364     ANode nodeFromANodeId(int id) const { return Parent::nodeFromBNodeId(id); }
    365     BNode nodeFromBNodeId(int id) const { return Parent::nodeFromANodeId(id); }
     364    ANode nodeFromANodeId(int ix) const { return Parent::nodeFromBNodeId(ix); }
     365    BNode nodeFromBNodeId(int ix) const { return Parent::nodeFromANodeId(ix); }
    366366
    367367    int maxANodeId() const { return Parent::maxBNodeId(); }

  • lemon/bucket_heap.h

    r2263 r2386  
    101101
    102102    void relocate_last(int idx) {
    103       if (idx + 1 < (int)data.size()) {
     103      if (idx + 1 < int(data.size())) {
    104104        data[idx] = data.back();
    105105        if (data[idx].prev != -1) {
    … …  
    128128
    129129    void lace(int idx) {
    130       if ((int)first.size() <= data[idx].value) {
     130      if (int(first.size()) <= data[idx].value) {
    131131        first.resize(data[idx].value + 1, -1);
    132132      }
    … …  
    355355
    356356    void relocate_last(int idx) {
    357       if (idx + 1 != (int)data.size()) {
     357      if (idx + 1 != int(data.size())) {
    358358        data[idx] = data.back();
    359359        if (data[idx].prev != -1) {
    … …  
    382382
    383383    void lace(int idx) {
    384       if ((int)first.size() <= data[idx].value) {
     384      if (int(first.size()) <= data[idx].value) {
    385385        first.resize(data[idx].value + 1, -1);
    386386      }
    … …  
    608608      }
    609609      index[i] = idx;
    610       if (p >= (int)first.size()) first.resize(p + 1, -1);
     610      if (p >= int(first.size())) first.resize(p + 1, -1);
    611611      data[idx].next = first[p];
    612612      first[p] = idx;
    … …  
    751751      }
    752752      index[i] = idx;
    753       if (p >= (int)first.size()) first.resize(p + 1, -1);
     753      if (p >= int(first.size())) first.resize(p + 1, -1);
    754754      data[idx].next = first[p];
    755755      first[p] = idx;

  • lemon/csp.h

    r2377 r2386  
    8989    ///\e
    9090    ///
    91     ConstrainedShortestPath(Graph &g, CM &cost, DM &delay)
    92       : _g(g), _cost(cost), _delay(delay),
    93         _co_map(cost,delay), _dij(_g,_co_map) {}
     91    ConstrainedShortestPath(Graph &g, CM &ct, DM &dl)
     92      : _g(g), _cost(ct), _delay(dl),
     93        _co_map(ct,dl), _dij(_g,_co_map) {}
    9494   
    9595

  • lemon/dfs.h

    r2376 r2386  
    859859    /// \param s is the initial value of  \ref _source
    860860    DfsWizardBase(const GR &g, Node s=INVALID) :
    861       _g((void *)&g), _reached(0), _processed(0), _pred(0),
    862       _dist(0), _source(s) {}
     861      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
     862      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
    863863
    864864  };
    … …  
    934934    {
    935935      if(Base::_source==INVALID) throw UninitializedParameter();
    936       Dfs<Graph,TR> alg(*(Graph*)Base::_g);
    937       if(Base::_reached) alg.reachedMap(*(ReachedMap*)Base::_reached);
    938       if(Base::_processed) alg.processedMap(*(ProcessedMap*)Base::_processed);
    939       if(Base::_pred) alg.predMap(*(PredMap*)Base::_pred);
    940       if(Base::_dist) alg.distMap(*(DistMap*)Base::_dist);
     936      Dfs<Graph,TR> alg(*reinterpret_cast<const Graph*>(Base::_g));
     937      if(Base::_reached)
     938        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
     939      if(Base::_processed)
     940        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     941      if(Base::_pred)
     942        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     943      if(Base::_dist)
     944        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
    941945      alg.run(Base::_source);
    942946    }
    … …  
    968972    DfsWizard<DefPredMapBase<T> > predMap(const T &t)
    969973    {
    970       Base::_pred=(void *)&t;
     974      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    971975      return DfsWizard<DefPredMapBase<T> >(*this);
    972976    }
    … …  
    989993    DfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
    990994    {
    991       Base::_pred=(void *)&t;
     995      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    992996      return DfsWizard<DefReachedMapBase<T> >(*this);
    993997    }
    … …  
    10101014    DfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
    10111015    {
    1012       Base::_pred=(void *)&t;
     1016      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    10131017      return DfsWizard<DefProcessedMapBase<T> >(*this);
    10141018    }
    … …  
    10301034    DfsWizard<DefDistMapBase<T> > distMap(const T &t)
    10311035    {
    1032       Base::_dist=(void *)&t;
     1036      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
    10331037      return DfsWizard<DefDistMapBase<T> >(*this);
    10341038    }

  • lemon/dijkstra.h

    r2376 r2386  
    488488    ///automatically allocated heap and cross reference, of course.
    489489    ///\return <tt> (*this) </tt>
    490     Dijkstra &heap(Heap& heap, HeapCrossRef &crossRef)
     490    Dijkstra &heap(Heap& hp, HeapCrossRef &cr)
    491491    {
    492492      if(local_heap_cross_ref) {
    … …  
    494494        local_heap_cross_ref=false;
    495495      }
    496       _heap_cross_ref = &crossRef;
     496      _heap_cross_ref = &cr;
    497497      if(local_heap) {
    498498        delete _heap;
    499499        local_heap=false;
    500500      }
    501       _heap = &heap;
     501      _heap = &hp;
    502502      return *this;
    503503    }
    … …  
    963963    /// \param s is the initial value of  \ref _source
    964964    DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
    965       _g((void *)&g), _length((void *)&l), _pred(0),
    966       _dist(0), _source(s) {}
     965      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
     966      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
     967      _pred(0), _dist(0), _source(s) {}
    967968
    968969  };
    … …  
    10381039      if(Base::_source==INVALID) throw UninitializedParameter();
    10391040      Dijkstra<Graph,LengthMap,TR>
    1040         dij(*(Graph*)Base::_g,*(LengthMap*)Base::_length);
    1041       if(Base::_pred) dij.predMap(*(PredMap*)Base::_pred);
    1042       if(Base::_dist) dij.distMap(*(DistMap*)Base::_dist);
     1041        dij(*reinterpret_cast<const Graph*>(Base::_g),
     1042            *reinterpret_cast<const LengthMap*>(Base::_length));
     1043      if(Base::_pred) dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     1044      if(Base::_dist) dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
    10431045      dij.run(Base::_source);
    10441046    }
    … …  
    10701072    DijkstraWizard<DefPredMapBase<T> > predMap(const T &t)
    10711073    {
    1072       Base::_pred=(void *)&t;
     1074      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    10731075      return DijkstraWizard<DefPredMapBase<T> >(*this);
    10741076    }
    … …  
    10901092    DijkstraWizard<DefDistMapBase<T> > distMap(const T &t)
    10911093    {
    1092       Base::_dist=(void *)&t;
     1094      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
    10931095      return DijkstraWizard<DefDistMapBase<T> >(*this);
    10941096    }

  • lemon/edge_set.h

    r2384 r2386  
    8787    ListEdgeSetBase() : first_edge(-1), first_free_edge(-1) {}
    8888
    89     Edge addEdge(const Node& source, const Node& target) {
     89    Edge addEdge(const Node& u, const Node& v) {
    9090      int n;
    9191      if (first_free_edge == -1) {
    … …  
    9696        first_free_edge = edges[first_free_edge].next_in;
    9797      }
    98       edges[n].next_in = (*nodes)[target].first_in;
    99       if ((*nodes)[target].first_in != -1) {
    100         edges[(*nodes)[target].first_in].prev_in = n;
    101       }
    102       (*nodes)[target].first_in = n;
    103       edges[n].next_out = (*nodes)[source].first_out;
    104       if ((*nodes)[source].first_out != -1) {
    105         edges[(*nodes)[source].first_out].prev_out = n;
    106       }
    107       (*nodes)[source].first_out = n;
    108       edges[n].source = source;
    109       edges[n].target = target;
     98      edges[n].next_in = (*nodes)[v].first_in;
     99      if ((*nodes)[v].first_in != -1) {
     100        edges[(*nodes)[v].first_in].prev_in = n;
     101      }
     102      (*nodes)[v].first_in = n;
     103      edges[n].next_out = (*nodes)[u].first_out;
     104      if ((*nodes)[u].first_out != -1) {
     105        edges[(*nodes)[u].first_out].prev_out = n;
     106      }
     107      (*nodes)[u].first_out = n;
     108      edges[n].source = u;
     109      edges[n].target = v;
    110110      return Edge(n);
    111111    }
    … …  
    189189    int id(const Edge& edge) const { return edge.id; }
    190190
    191     Node nodeFromId(int id) const { return graph->nodeFromId(id); }
    192     Edge edgeFromId(int id) const { return Edge(id); }
     191    Node nodeFromId(int ix) const { return graph->nodeFromId(ix); }
     192    Edge edgeFromId(int ix) const { return Edge(ix); }
    193193
    194194    int maxNodeId() const { return graph->maxNodeId(); };
    … …  
    294294      }
    295295      virtual void erase(const std::vector<Node>& nodes) {
    296         for (int i = 0; i < (int)nodes.size(); ++i) {
     296        for (int i = 0; i < int(nodes.size()); ++i) {
    297297          _edgeset.eraseNode(nodes[i]);
    298298        }
    … …  
    383383      }
    384384      virtual void erase(const std::vector<Node>& nodes) {
    385         for (int i = 0; i < (int)nodes.size(); ++i) {
     385        for (int i = 0; i < int(nodes.size()); ++i) {
    386386          _edgeset.eraseNode(nodes[i]);
    387387        }
    … …  
    461461    SmartEdgeSetBase() {}
    462462
    463     Edge addEdge(const Node& source, const Node& target) {
     463    Edge addEdge(const Node& u, const Node& v) {
    464464      int n = edges.size();
    465465      edges.push_back(EdgeT());
    466       edges[n].next_in = (*nodes)[target].first_in;
    467       (*nodes)[target].first_in = n;
    468       edges[n].next_out = (*nodes)[source].first_out;
    469       (*nodes)[source].first_out = n;
    470       edges[n].source = source;
    471       edges[n].target = target;
     466      edges[n].next_in = (*nodes)[v].first_in;
     467      (*nodes)[v].first_in = n;
     468      edges[n].next_out = (*nodes)[u].first_out;
     469      (*nodes)[u].first_out = n;
     470      edges[n].source = u;
     471      edges[n].target = v;
    472472      return Edge(n);
    473473    }
    … …  
    517517    int id(const Edge& edge) const { return edge.id; }
    518518
    519     Node nodeFromId(int id) const { return graph->nodeFromId(id); }
    520     Edge edgeFromId(int id) const { return Edge(id); }
     519    Node nodeFromId(int ix) const { return graph->nodeFromId(ix); }
     520    Edge edgeFromId(int ix) const { return Edge(ix); }
    521521
    522522    int maxNodeId() const { return graph->maxNodeId(); };
    … …  
    627627      virtual void erase(const std::vector<Node>& nodes) {
    628628        try {
    629           for (int i = 0; i < (int)nodes.size(); ++i) {
     629          for (int i = 0; i < int(nodes.size()); ++i) {
    630630            _edgeset.eraseNode(nodes[i]);
    631631          }
    … …  
    732732      virtual void erase(const std::vector<Node>& nodes) {
    733733        try {
    734           for (int i = 0; i < (int)nodes.size(); ++i) {
     734          for (int i = 0; i < int(nodes.size()); ++i) {
    735735            _edgeset.eraseNode(nodes[i]);
    736736          }

  • lemon/error.h

    r2175 r2386  
    127127
    128128    ///\e
    129     ErrorMessage(const char *message) throw() {
     129    ErrorMessage(const char *msg) throw() {
    130130      init();
    131       *this << message;
    132     }
    133 
    134     ///\e
    135     ErrorMessage(const std::string &message) throw() {
     131      *this << msg;
     132    }
     133
     134    ///\e
     135    ErrorMessage(const std::string &msg) throw() {
    136136      init();
    137       *this << message;
     137      *this << msg;
    138138    }
    139139
    … …  
    267267
    268268    ///\e
    269     void line(int line) { _line = line; }
    270     ///\e
    271     void message(const std::string& message) { _message.set(message); }
    272     ///\e
    273     void file(const std::string &file) { _file.set(file); }
     269    void line(int ln) { _line = ln; }
     270    ///\e
     271    void message(const std::string& msg) { _message.set(msg); }
     272    ///\e
     273    void file(const std::string &fl) { _file.set(fl); }
    274274 
    275275    ///\e
    … …  
    330330
    331331    ///\e
    332     explicit FileOpenError(const std::string& file)
    333       : _file(file) {}
    334 
    335 
    336     ///\e
    337     void file(const std::string &file) { _file.set(file); }
     332    explicit FileOpenError(const std::string& fl)
     333      : _file(fl) {}
     334
     335
     336    ///\e
     337    void file(const std::string &fl) { _file.set(fl); }
    338338 
    339339    /// \brief Returns the filename.
    … …  
    383383
    384384     ///\e
    385     void message(const std::string& message) { _message.set(message); }
    386     ///\e
    387     void file(const std::string &file) { _file.set(file); }
     385    void message(const std::string& msg) { _message.set(msg); }
     386    ///\e
     387    void file(const std::string &fl) { _file.set(fl); }
    388388 
    389389     ///\e

  • lemon/full_graph.h

    r2384 r2386  
    5757    typedef True EdgeNumTag;
    5858
    59     Node operator()(int index) const { return Node(index); }
     59    Node operator()(int ix) const { return Node(ix); }
    6060    int index(const Node& node) const { return node.id; }
    6161
    … …  
    130130    }
    131131
    132     void first(Edge& edge) const {
    133       edge.id = _edgeNum-1;
    134     }
    135 
    136     static void next(Edge& edge) {
    137       --edge.id;
    138     }
    139 
    140     void firstOut(Edge& edge, const Node& node) const {
    141       edge.id = _edgeNum + node.id - _nodeNum;
    142     }
    143 
    144     void nextOut(Edge& edge) const {
    145       edge.id -= _nodeNum;
    146       if (edge.id < 0) edge.id = -1;
    147     }
    148 
    149     void firstIn(Edge& edge, const Node& node) const {
    150       edge.id = node.id * _nodeNum;
     132    void first(Edge& e) const {
     133      e.id = _edgeNum-1;
     134    }
     135
     136    static void next(Edge& e) {
     137      --e.id;
     138    }
     139
     140    void firstOut(Edge& e, const Node& n) const {
     141      e.id = _edgeNum + n.id - _nodeNum;
     142    }
     143
     144    void nextOut(Edge& e) const {
     145      e.id -= _nodeNum;
     146      if (e.id < 0) e.id = -1;
     147    }
     148
     149    void firstIn(Edge& e, const Node& n) const {
     150      e.id = n.id * _nodeNum;
    151151    }
    152152   
    153     void nextIn(Edge& edge) const {
    154       ++edge.id;
    155       if (edge.id % _nodeNum == 0) edge.id = -1;
     153    void nextIn(Edge& e) const {
     154      ++e.id;
     155      if (e.id % _nodeNum == 0) e.id = -1;
    156156    }
    157157
    … …  
    208208    /// by the range from 0 to \e nodeNum()-1 and the index of
    209209    /// the node can accessed by the \e index() member.
    210     Node operator()(int index) const { return Parent::operator()(index); }
     210    Node operator()(int ix) const { return Parent::operator()(ix); }
    211211
    212212    /// \brief Returns the index of the node.
    … …  
    251251
    252252
    253     Node operator()(int index) const { return Node(index); }
     253    Node operator()(int ix) const { return Node(ix); }
    254254    int index(const Node& node) const { return node.id; }
    255255
    … …  
    272272    Node source(Edge e) const {
    273273      /// \todo we may do it faster
    274       return Node(((int)sqrt((double)(1 + 8 * e.id)) + 1) / 2);
     274      return Node((int(sqrt(double(1 + 8 * e.id)) + 1)) / 2);
    275275    }
    276276
    277277    Node target(Edge e) const {
    278       int source = ((int)sqrt((double)(1 + 8 * e.id)) + 1) / 2;;
    279       return Node(e.id - (source) * (source - 1) / 2);
     278      int s = (int(sqrt(double(1 + 8 * e.id)) + 1)) / 2;
     279      return Node(e.id - s * (s - 1) / 2);
    280280    }
    281281
    … …  
    323323    };
    324324
    325     void first(Node& node) const {
    326       node.id = _nodeNum - 1;
    327     }
    328 
    329     static void next(Node& node) {
    330       --node.id;
    331     }
    332 
    333     void first(Edge& edge) const {
    334       edge.id = _edgeNum - 1;
    335     }
    336 
    337     static void next(Edge& edge) {
    338       --edge.id;
    339     }
    340 
    341     void firstOut(Edge& edge, const Node& node) const {     
    342       int src = node.id;
     325    void first(Node& n) const {
     326      n.id = _nodeNum - 1;
     327    }
     328
     329    static void next(Node& n) {
     330      --n.id;
     331    }
     332
     333    void first(Edge& e) const {
     334      e.id = _edgeNum - 1;
     335    }
     336
     337    static void next(Edge& e) {
     338      --e.id;
     339    }
     340
     341    void firstOut(Edge& e, const Node& n) const {     
     342      int src = n.id;
    343343      int trg = 0;
    344       edge.id = (trg < src ? src * (src - 1) / 2 + trg : -1);
     344      e.id = (trg < src ? src * (src - 1) / 2 + trg : -1);
    345345    }
    346346
    347347    /// \todo with specialized iterators we can make faster iterating
    348     void nextOut(Edge& edge) const {
    349       int src = source(edge).id;
    350       int trg = target(edge).id;
     348    void nextOut(Edge& e) const {
     349      int src = source(e).id;
     350      int trg = target(e).id;
    351351      ++trg;
    352       edge.id = (trg < src ? src * (src - 1) / 2 + trg : -1);
    353     }
    354 
    355     void firstIn(Edge& edge, const Node& node) const {
    356       int src = node.id + 1;
    357       int trg = node.id;
    358       edge.id = (src < _nodeNum ? src * (src - 1) / 2 + trg : -1);
     352      e.id = (trg < src ? src * (src - 1) / 2 + trg : -1);
     353    }
     354
     355    void firstIn(Edge& e, const Node& n) const {
     356      int src = n.id + 1;
     357      int trg = n.id;
     358      e.id = (src < _nodeNum ? src * (src - 1) / 2 + trg : -1);
    359359    }
    360360   
    361     void nextIn(Edge& edge) const {
    362       int src = source(edge).id;
    363       int trg = target(edge).id;
     361    void nextIn(Edge& e) const {
     362      int src = source(e).id;
     363      int trg = target(e).id;
    364364      ++src;
    365       edge.id = (src < _nodeNum ? src * (src - 1) / 2 + trg : -1);
     365      e.id = (src < _nodeNum ? src * (src - 1) / 2 + trg : -1);
    366366    }
    367367
    … …  
    422422    /// by the range from 0 to \e nodeNum()-1 and the index of
    423423    /// the node can accessed by the \e index() member.
    424     Node operator()(int index) const { return Parent::operator()(index); }
     424    Node operator()(int ix) const { return Parent::operator()(ix); }
    425425
    426426    /// \brief Returns the index of the node.
    … …  
    479479    FullBpUGraphBase() {}
    480480
    481     void construct(int aNodeNum, int bNodeNum) {
    482       _aNodeNum = aNodeNum;
    483       _bNodeNum = bNodeNum;
    484       _edgeNum = aNodeNum * bNodeNum;
     481    void construct(int ann, int bnn) {
     482      _aNodeNum = ann;
     483      _bNodeNum = bnn;
     484      _edgeNum = ann * bnn;
    485485    }
    486486
    … …  
    522522    };
    523523
    524     Node aNode(int index) const { return Node(index << 1); }
    525     Node bNode(int index) const { return Node((index << 1) + 1); }
     524    Node aNode(int ix) const { return Node(ix << 1); }
     525    Node bNode(int ix) const { return Node((ix << 1) + 1); }
    526526
    527527    int aNodeIndex(const Node& node) const { return node.id >> 1; }
    … …  
    696696    }
    697697
    698     FullBpUGraph(int aNodeNum, int bNodeNum) {
    699       Parent::construct(aNodeNum, bNodeNum);
     698    FullBpUGraph(int ann, int bnn) {
     699      Parent::construct(ann, bnn);
    700700    }
    701701
    … …  
    738738    /// by the range from 0 to \e aNodeNum()-1 and the index of
    739739    /// the node can accessed by the \e aNodeIndex() member.
    740     Node aNode(int index) const { return Parent::aNode(index); }
     740    Node aNode(int ix) const { return Parent::aNode(ix); }
    741741
    742742    /// \brief Returns the B-node with the given index.
    … …  
    746746    /// by the range from 0 to \e bNodeNum()-1 and the index of
    747747    /// the node can accessed by the \e bNodeIndex() member.
    748     Node bNode(int index) const { return Parent::bNode(index); }
     748    Node bNode(int ix) const { return Parent::bNode(ix); }
    749749
    750750    /// \brief Returns the index of the A-node.

  • lemon/graph_adaptor.h

    r2384 r2386  
    9494
    9595    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
    96     Edge findEdge(const Node& source, const Node& target,
     96    Edge findEdge(const Node& u, const Node& v,
    9797                  const Edge& prev = INVALID) {
    98       return graph->findEdge(source, target, prev);
     98      return graph->findEdge(u, v, prev);
    9999    }
    100100 
    … …  
    103103    }
    104104
    105     Edge addEdge(const Node& source, const Node& target) const {
    106       return Edge(graph->addEdge(source, target));
     105    Edge addEdge(const Node& u, const Node& v) const {
     106      return Edge(graph->addEdge(u, v));
    107107    }
    108108
    … …  
    115115    int id(const Edge& e) const { return graph->id(e); }
    116116
    117     Node fromNodeId(int id) const {
    118       return graph->fromNodeId(id);
    119     }
    120 
    121     Edge fromEdgeId(int id) const {
    122       return graph->fromEdgeId(id);
     117    Node fromNodeId(int ix) const {
     118      return graph->fromNodeId(ix);
     119    }
     120
     121    Edge fromEdgeId(int ix) const {
     122      return graph->fromEdgeId(ix);
    123123    }
    124124
    … …  
    244244
    245245    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
    246     Edge findEdge(const Node& source, const Node& target,
     246    Edge findEdge(const Node& u, const Node& v,
    247247                  const Edge& prev = INVALID) {
    248       return Parent::findEdge(target, source, prev);
     248      return Parent::findEdge(v, u, prev);
    249249    }
    250250
    … …  
    461461                             template NodeMap<_Value> > Parent;
    462462   
    463       NodeMap(const Graph& graph)
    464         : Parent(graph) {}
    465       NodeMap(const Graph& graph, const _Value& value)
    466         : Parent(graph, value) {}
     463      NodeMap(const Graph& g)
     464        : Parent(g) {}
     465      NodeMap(const Graph& g, const _Value& v)
     466        : Parent(g, v) {}
    467467   
    468468      NodeMap& operator=(const NodeMap& cmap) {
    … …  
    487487                             template EdgeMap<_Value> > Parent;
    488488   
    489       EdgeMap(const Graph& graph)
    490         : Parent(graph) {}
    491       EdgeMap(const Graph& graph, const _Value& value)
    492         : Parent(graph, value) {}
     489      EdgeMap(const Graph& g)
     490        : Parent(g) {}
     491      EdgeMap(const Graph& g, const _Value& v)
     492        : Parent(g, v) {}
    493493   
    494494      EdgeMap& operator=(const EdgeMap& cmap) {
    … …  
    634634                             template NodeMap<_Value> > Parent;
    635635   
    636       NodeMap(const Graph& graph)
    637         : Parent(graph) {}
    638       NodeMap(const Graph& graph, const _Value& value)
    639         : Parent(graph, value) {}
     636      NodeMap(const Graph& g)
     637        : Parent(g) {}
     638      NodeMap(const Graph& g, const _Value& v)
     639        : Parent(g, v) {}
    640640   
    641641      NodeMap& operator=(const NodeMap& cmap) {
    … …  
    660660                             template EdgeMap<_Value> > Parent;
    661661   
    662       EdgeMap(const Graph& graph)
    663         : Parent(graph) {}
    664       EdgeMap(const Graph& graph, const _Value& value)
    665         : Parent(graph, value) {}
     662      EdgeMap(const Graph& g)
     663        : Parent(g) {}
     664      EdgeMap(const Graph& g, const _Value& v)
     665        : Parent(g, v) {}
    666666   
    667667      EdgeMap& operator=(const EdgeMap& cmap) {
    … …  
    11061106      typedef SubMapExtender<Adaptor, EdgeMapBase<_Value> > Parent;
    11071107   
    1108       EdgeMap(const Graph& graph)
    1109         : Parent(graph) {}
    1110       EdgeMap(const Graph& graph, const _Value& value)
    1111         : Parent(graph, value) {}
     1108      EdgeMap(const Graph& g)
     1109        : Parent(g) {}
     1110      EdgeMap(const Graph& g, const _Value& v)
     1111        : Parent(g, v) {}
    11121112   
    11131113      EdgeMap& operator=(const EdgeMap& cmap) {
    … …  
    11811181      : Parent(), edge_notifier(*this), edge_notifier_proxy(*this) {}
    11821182
    1183     void setGraph(_Graph& graph) {
    1184       Parent::setGraph(graph);
    1185       edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
     1183    void setGraph(_Graph& g) {
     1184      Parent::setGraph(g);
     1185      edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
    11861186    }
    11871187
    … …  
    12211221      }
    12221222
    1223       void setNotifier(typename Graph::EdgeNotifier& notifier) {
    1224         Parent::attach(notifier);
     1223      void setNotifier(typename Graph::EdgeNotifier& nf) {
     1224        Parent::attach(nf);
    12251225      }
    12261226
    … …  
    12361236      virtual void add(const std::vector<GraphEdge>& ge) {
    12371237        std::vector<Edge> edges;
    1238         for (int i = 0; i < (int)ge.size(); ++i) {
     1238        for (int i = 0; i < int(ge.size()); ++i) {
    12391239          edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
    12401240          edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
    … …  
    12501250      virtual void erase(const std::vector<GraphEdge>& ge) {
    12511251        std::vector<Edge> edges;
    1252         for (int i = 0; i < (int)ge.size(); ++i) {
     1252        for (int i = 0; i < int(ge.size()); ++i) {
    12531253          edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
    12541254          edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
    … …  
    18221822    };
    18231823
    1824     void first(Node& node) const {
    1825       Parent::first(node);
    1826       node.in_node = true;
    1827     }
    1828 
    1829     void next(Node& node) const {
    1830       if (node.in_node) {
    1831         node.in_node = false;
     1824    void first(Node& n) const {
     1825      Parent::first(n);
     1826      n.in_node = true;
     1827    }
     1828
     1829    void next(Node& n) const {
     1830      if (n.in_node) {
     1831        n.in_node = false;
    18321832      } else {
    1833         node.in_node = true;
    1834         Parent::next(node);
    1835       }
    1836     }
    1837 
    1838     void first(Edge& edge) const {
    1839       edge.item.setSecond();
    1840       Parent::first(edge.item.second());
    1841       if (edge.item.second() == INVALID) {
    1842         edge.item.setFirst();
    1843         Parent::first(edge.item.first());
    1844       }
    1845     }
    1846 
    1847     void next(Edge& edge) const {
    1848       if (edge.item.secondState()) {
    1849         Parent::next(edge.item.second());
    1850         if (edge.item.second() == INVALID) {
    1851           edge.item.setFirst();
    1852           Parent::first(edge.item.first());
     1833        n.in_node = true;
     1834        Parent::next(n);
     1835      }
     1836    }
     1837
     1838    void first(Edge& e) const {
     1839      e.item.setSecond();
     1840      Parent::first(e.item.second());
     1841      if (e.item.second() == INVALID) {
     1842        e.item.setFirst();
     1843        Parent::first(e.item.first());
     1844      }
     1845    }
     1846
     1847    void next(Edge& e) const {
     1848      if (e.item.secondState()) {
     1849        Parent::next(e.item.second());
     1850        if (e.item.second() == INVALID) {
     1851          e.item.setFirst();
     1852          Parent::first(e.item.first());
    18531853        }
    18541854      } else {
    1855         Parent::next(edge.item.first());
     1855        Parent::next(e.item.first());
    18561856      }     
    18571857    }
    18581858
    1859     void firstOut(Edge& edge, const Node& node) const {
    1860       if (node.in_node) {
    1861         edge.item.setSecond(node);
     1859    void firstOut(Edge& e, const Node& n) const {
     1860      if (n.in_node) {
     1861        e.item.setSecond(n);
    18621862      } else {
    1863         edge.item.setFirst();
    1864         Parent::firstOut(edge.item.first(), node);
    1865       }
    1866     }
    1867 
    1868     void nextOut(Edge& edge) const {
    1869       if (!edge.item.firstState()) {
    1870         edge.item.setFirst(INVALID);
     1863        e.item.setFirst();
     1864        Parent::firstOut(e.item.first(), n);
     1865      }
     1866    }
     1867
     1868    void nextOut(Edge& e) const {
     1869      if (!e.item.firstState()) {
     1870        e.item.setFirst(INVALID);
    18711871      } else {
    1872         Parent::nextOut(edge.item.first());
     1872        Parent::nextOut(e.item.first());
    18731873      }     
    18741874    }
    18751875
    1876     void firstIn(Edge& edge, const Node& node) const {
    1877       if (!node.in_node) {
    1878         edge.item.setSecond(node);       
     1876    void firstIn(Edge& e, const Node& n) const {
     1877      if (!n.in_node) {
     1878        e.item.setSecond(n);       
    18791879      } else {
    1880         edge.item.setFirst();
    1881         Parent::firstIn(edge.item.first(), node);
    1882       }
    1883     }
    1884 
    1885     void nextIn(Edge& edge) const {
    1886       if (!edge.item.firstState()) {
    1887         edge.item.setFirst(INVALID);
     1880        e.item.setFirst();
     1881        Parent::firstIn(e.item.first(), n);
     1882      }
     1883    }
     1884
     1885    void nextIn(Edge& e) const {
     1886      if (!e.item.firstState()) {
     1887        e.item.setFirst(INVALID);
    18881888      } else {
    1889         Parent::nextIn(edge.item.first());
    1890       }
    1891     }
    1892 
    1893     Node source(const Edge& edge) const {
    1894       if (edge.item.firstState()) {
    1895         return Node(Parent::source(edge.item.first()), false);
     1889        Parent::nextIn(e.item.first());
     1890      }
     1891    }
     1892
     1893    Node source(const Edge& e) const {
     1894      if (e.item.firstState()) {
     1895        return Node(Parent::source(e.item.first()), false);
    18961896      } else {
    1897         return Node(edge.item.second(), true);
    1898       }
    1899     }
    1900 
    1901     Node target(const Edge& edge) const {
    1902       if (edge.item.firstState()) {
    1903         return Node(Parent::target(edge.item.first()), true);
     1897        return Node(e.item.second(), true);
     1898      }
     1899    }
     1900
     1901    Node target(const Edge& e) const {
     1902      if (e.item.firstState()) {
     1903        return Node(Parent::target(e.item.first()), true);
    19041904      } else {
    1905         return Node(edge.item.second(), false);
    1906       }
    1907     }
    1908 
    1909     int id(const Node& node) const {
    1910       return (Parent::id(node) << 1) | (node.in_node ? 0 : 1);
    1911     }
    1912     Node nodeFromId(int id) const {
    1913       return Node(Parent::nodeFromId(id >> 1), (id & 1) == 0);
     1905        return Node(e.item.second(), false);
     1906      }
     1907    }
     1908
     1909    int id(const Node& n) const {
     1910      return (Parent::id(n) << 1) | (n.in_node ? 0 : 1);
     1911    }
     1912    Node nodeFromId(int ix) const {
     1913      return Node(Parent::nodeFromId(ix >> 1), (ix & 1) == 0);
    19141914    }
    19151915    int maxNodeId() const {
    … …  
    19171917    }
    19181918
    1919     int id(const Edge& edge) const {
    1920       if (edge.item.firstState()) {
    1921         return Parent::id(edge.item.first()) << 1;
     1919    int id(const Edge& e) const {
     1920      if (e.item.firstState()) {
     1921        return Parent::id(e.item.first()) << 1;
    19221922      } else {
    1923         return (Parent::id(edge.item.second()) << 1) | 1;
    1924       }
    1925     }
    1926     Edge edgeFromId(int id) const {
    1927       if ((id & 1) == 0) {
    1928         return Edge(Parent::edgeFromId(id >> 1));
     1923        return (Parent::id(e.item.second()) << 1) | 1;
     1924      }
     1925    }
     1926    Edge edgeFromId(int ix) const {
     1927      if ((ix & 1) == 0) {
     1928        return Edge(Parent::edgeFromId(ix >> 1));
    19291929      } else {
    1930         return Edge(Parent::nodeFromId(id >> 1));
     1930        return Edge(Parent::nodeFromId(ix >> 1));
    19311931      }
    19321932    }
    … …  
    19391939    ///
    19401940    /// Returns true when the node is in-node.
    1941     static bool inNode(const Node& node) {
    1942       return node.in_node;
     1941    static bool inNode(const Node& n) {
     1942      return n.in_node;
    19431943    }
    19441944
    … …  
    19461946    ///
    19471947    /// Returns true when the node is out-node.
    1948     static bool outNode(const Node& node) {
    1949       return !node.in_node;
     1948    static bool outNode(const Node& n) {
     1949      return !n.in_node;
    19501950    }
    19511951
    … …  
    19531953    ///
    19541954    /// Returns true when the edge is edge in the original graph.
    1955     static bool origEdge(const Edge& edge) {
    1956       return edge.item.firstState();
     1955    static bool origEdge(const Edge& e) {
     1956      return e.item.firstState();
    19571957    }
    19581958
    … …  
    19601960    ///
    19611961    /// Returns true when the edge binds an in-node and an out-node.
    1962     static bool bindEdge(const Edge& edge) {
    1963       return edge.item.secondState();
     1962    static bool bindEdge(const Edge& e) {
     1963      return e.item.secondState();
    19641964    }
    19651965
    … …  
    19671967    ///
    19681968    /// Gives back the in-node created from the \c node.
    1969     static Node inNode(const GraphNode& node) {
    1970       return Node(node, true);
     1969    static Node inNode(const GraphNode& n) {
     1970      return Node(n, true);
    19711971    }
    19721972
    … …  
    19741974    ///
    19751975    /// Gives back the out-node created from the \c node.
    1976     static Node outNode(const GraphNode& node) {
    1977       return Node(node, false);
     1976    static Node outNode(const GraphNode& n) {
     1977      return Node(n, false);
    19781978    }
    19791979
    … …  
    19811981    ///
    19821982    /// Gives back the edge binds the two part of the node.
    1983     static Edge edge(const GraphNode& node) {
    1984       return Edge(node);
     1983    static Edge edge(const GraphNode& n) {
     1984      return Edge(n);
    19851985    }
    19861986
    … …  
    19881988    ///
    19891989    /// Gives back the edge of the original edge.
    1990     static Edge edge(const GraphEdge& edge) {
    1991       return Edge(edge);
     1990    static Edge edge(const GraphEdge& e) {
     1991      return Edge(e);
    19921992    }
    19931993
    … …  
    20062006    typedef True FindEdgeTag;
    20072007
    2008     Edge findEdge(const Node& source, const Node& target,
     2008    Edge findEdge(const Node& u, const Node& v,
    20092009                  const Edge& prev = INVALID) const {
    2010       if (inNode(source)) {
    2011         if (outNode(target)) {
    2012           if ((GraphNode&)source == (GraphNode&)target && prev == INVALID) {
    2013             return Edge(source);
     2010      if (inNode(u)) {
     2011        if (outNode(v)) {
     2012          if (static_cast<const GraphNode&>(u) ==
     2013              static_cast<const GraphNode&>(v) && prev == INVALID) {
     2014            return Edge(u);
    20142015          }
    20152016        }
    20162017      } else {
    2017         if (inNode(target)) {
    2018           return Edge(findEdge(*Parent::graph, source, target, prev));
     2018        if (inNode(v)) {
     2019          return Edge(findEdge(*Parent::graph, u, v, prev));
    20192020        }
    20202021      }
    … …  
    21922193      virtual void add(const std::vector<GraphNode>& gn) {
    21932194        std::vector<Node> nodes;
    2194         for (int i = 0; i < (int)gn.size(); ++i) {
     2195        for (int i = 0; i < int(gn.size()); ++i) {
    21952196          nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
    21962197          nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
    … …  
    22082209      virtual void erase(const std::vector<GraphNode>& gn) {
    22092210        std::vector<Node> nodes;
    2210         for (int i = 0; i < (int)gn.size(); ++i) {
     2211        for (int i = 0; i < int(gn.size()); ++i) {
    22112212          nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
    22122213          nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
    … …  
    22542255        node_notifier_proxy(*this), edge_notifier_proxy(*this) {}
    22552256   
    2256     void setGraph(_Graph& graph) {
    2257       Parent::setGraph(graph);
    2258       node_notifier_proxy.setNotifier(graph.notifier(GraphNode()));
    2259       edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
     2257    void setGraph(_Graph& g) {
     2258      Parent::setGraph(g);
     2259      node_notifier_proxy.setNotifier(g.notifier(GraphNode()));
     2260      edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
    22602261    }
    22612262
    … …  
    23082309        std::vector<Node> nodes;
    23092310        std::vector<Edge> edges;
    2310         for (int i = 0; i < (int)gn.size(); ++i) {
     2311        for (int i = 0; i < int(gn.size()); ++i) {
    23112312          edges.push_back(AdaptorBase::Parent::edge(gn[i]));
    23122313          nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
    … …  
    23262327        std::vector<Node> nodes;
    23272328        std::vector<Edge> edges;
    2328         for (int i = 0; i < (int)gn.size(); ++i) {
     2329        for (int i = 0; i < int(gn.size()); ++i) {
    23292330          edges.push_back(AdaptorBase::Parent::edge(gn[i]));
    23302331          nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
    … …  
    23362337      virtual void build() {
    23372338        std::vector<Edge> edges;
    2338         const typename Parent::Notifier* notifier = Parent::notifier();
     2339        const typename Parent::Notifier* nf = Parent::notifier();
    23392340        GraphNode it;
    2340         for (notifier->first(it); it != INVALID; notifier->next(it)) {
     2341        for (nf->first(it); it != INVALID; nf->next(it)) {
    23412342          edges.push_back(AdaptorBase::Parent::edge(it));
    23422343        }
    … …  
    23462347      virtual void clear() {
    23472348        std::vector<Edge> edges;
    2348         const typename Parent::Notifier* notifier = Parent::notifier();
     2349        const typename Parent::Notifier* nf = Parent::notifier();
    23492350        GraphNode it;
    2350         for (notifier->first(it); it != INVALID; notifier->next(it)) {
     2351        for (nf->first(it); it != INVALID; nf->next(it)) {
    23512352          edges.push_back(AdaptorBase::Parent::edge(it));
    23522353        }
    … …  
    23862387      virtual void add(const std::vector<GraphEdge>& ge) {
    23872388        std::vector<Edge> edges;
    2388         for (int i = 0; i < (int)ge.size(); ++i) {
     2389        for (int i = 0; i < int(ge.size()); ++i) {
    23892390          edges.push_back(AdaptorBase::edge(ge[i]));
    23902391        }
    … …  
    23962397      virtual void erase(const std::vector<GraphEdge>& ge) {
    23972398        std::vector<Edge> edges;
    2398         for (int i = 0; i < (int)ge.size(); ++i) {
     2399        for (int i = 0; i < int(ge.size()); ++i) {
    23992400          edges.push_back(AdaptorBase::edge(ge[i]));
    24002401        }
    … …  
    24032404      virtual void build() {
    24042405        std::vector<Edge> edges;
    2405         const typename Parent::Notifier* notifier = Parent::notifier();
     2406        const typename Parent::Notifier* nf = Parent::notifier();
    24062407        GraphEdge it;
    2407         for (notifier->first(it); it != INVALID; notifier->next(it)) {
     2408        for (nf->first(it); it != INVALID; nf->next(it)) {
    24082409          edges.push_back(AdaptorBase::Parent::edge(it));
    24092410        }
    … …  
    24122413      virtual void clear() {
    24132414        std::vector<Edge> edges;
    2414         const typename Parent::Notifier* notifier = Parent::notifier();
     2415        const typename Parent::Notifier* nf = Parent::notifier();
    24152416        GraphEdge it;
    2416         for (notifier->first(it); it != INVALID; notifier->next(it)) {
     2417        for (nf->first(it); it != INVALID; nf->next(it)) {
    24172418          edges.push_back(AdaptorBase::Parent::edge(it));
    24182419        }
    … …  
    25102511    ///
    25112512    /// Constructor of the adaptor.
    2512     SplitGraphAdaptor(_Graph& graph) {
    2513       Parent::setGraph(graph);
     2513    SplitGraphAdaptor(_Graph& g) {
     2514      Parent::setGraph(g);
    25142515    }
    25152516

  • lemon/graph_reader.h

    r2334 r2386  
    185185    ///
    186186    /// Give a new node map reading command to the reader.
    187     template <typename Reader, typename Map>
     187    template <typename ItemReader, typename Map>
    188188    GraphReader& readNodeMap(std::string name, Map& map,
    189                              const Reader& reader = Reader()) {
    190       nodeset_reader.readNodeMap(name, map, reader);
    191       return *this;
    192     }
    193 
    194     template <typename Reader, typename Map>
     189                             const ItemReader& ir = ItemReader()) {
     190      nodeset_reader.readNodeMap(name, map, ir);
     191      return *this;
     192    }
     193
     194    template <typename ItemReader, typename Map>
    195195    GraphReader& readNodeMap(std::string name, const Map& map,
    196                              const Reader& reader = Reader()) {
    197       nodeset_reader.readNodeMap(name, map, reader);
     196                             const ItemReader& ir = ItemReader()) {
     197      nodeset_reader.readNodeMap(name, map, ir);
    198198      return *this;
    199199    }
    … …  
    202202    ///
    203203    /// Give a new node map skipping command to the reader.
    204     template <typename Reader>
     204    template <typename ItemReader>
    205205    GraphReader& skipNodeMap(std::string name,
    206                              const Reader& reader = Reader()) {
    207       nodeset_reader.skipNodeMap(name, reader);
     206                             const ItemReader& ir = ItemReader()) {
     207      nodeset_reader.skipNodeMap(name, ir);
    208208      return *this;
    209209    }
    … …  
    228228    ///
    229229    /// Give a new edge map reading command to the reader.
    230     template <typename Reader, typename Map>
     230    template <typename ItemReader, typename Map>
    231231    GraphReader& readEdgeMap(std::string name, Map& map,
    232                              const Reader& reader = Reader()) {
    233       edgeset_reader.readEdgeMap(name, map, reader);
    234       return *this;
    235     }
    236 
    237     template <typename Reader, typename Map>
     232                             const ItemReader& ir = ItemReader()) {
     233      edgeset_reader.readEdgeMap(name, map, ir);
     234      return *this;
     235    }
     236
     237    template <typename ItemReader, typename Map>
    238238    GraphReader& readEdgeMap(std::string name, const Map& map,
    239                              const Reader& reader = Reader()) {
    240       edgeset_reader.readEdgeMap(name, map, reader);
     239                             const ItemReader& ir = ItemReader()) {
     240      edgeset_reader.readEdgeMap(name, map, ir);
    241241      return *this;
    242242    }
    … …  
    245245    ///
    246246    /// Give a new edge map skipping command to the reader.
    247     template <typename Reader>
     247    template <typename ItemReader>
    248248    GraphReader& skipEdgeMap(std::string name,
    249                              const Reader& reader = Reader()) {
    250       edgeset_reader.skipEdgeMap(name, reader);
     249                             const ItemReader& ir = ItemReader()) {
     250      edgeset_reader.skipEdgeMap(name, ir);
    251251      return *this;
    252252    }
    … …  
    280280    ///
    281281    ///  Give a new attribute reading command.
    282     template <typename Reader, typename Value>
     282    template <typename ItemReader, typename Value>
    283283    GraphReader& readAttribute(std::string name, Value& value,
    284                                const Reader& reader) {
    285       attribute_reader.readAttribute<Reader>(name, value, reader);
     284                               const ItemReader& ir = ItemReader()) {
     285      attribute_reader.readAttribute(name, value, ir);
    286286      return *this;
    287287    }
    … …  
    505505    ///
    506506    /// Give a new node map reading command to the reader.
    507     template <typename Reader, typename Map>
     507    template <typename ItemReader, typename Map>
    508508    UGraphReader& readNodeMap(std::string name, Map& map,
    509                                   const Reader& reader = Reader()) {
    510       nodeset_reader.readNodeMap(name, map, reader);
    511       return *this;
    512     }
    513 
    514     template <typename Reader, typename Map>
     509                              const ItemReader& ir = ItemReader()) {
     510      nodeset_reader.readNodeMap(name, map, ir);
     511      return *this;
     512    }
     513
     514    template <typename ItemReader, typename Map>
    515515    UGraphReader& readNodeMap(std::string name, const Map& map,
    516                                   const Reader& reader = Reader()) {
    517       nodeset_reader.readNodeMap(name, map, reader);
     516                              const ItemReader& ir = ItemReader()) {
     517      nodeset_reader.readNodeMap(name, map, ir);
    518518      return *this;
    519519    }
    … …  
    522522    ///
    523523    /// Give a new node map skipping command to the reader.
    524     template <typename Reader>
     524    template <typename ItemReader>
    525525    UGraphReader& skipNodeMap(std::string name,
    526                              const Reader& reader = Reader()) {
    527       nodeset_reader.skipNodeMap(name, reader);
     526                              const ItemReader& ir = ItemReader()) {
     527      nodeset_reader.skipNodeMap(name, ir);
    528528      return *this;
    529529    }
    … …  
    548548    ///
    549549    /// Give a new undirected edge map reading command to the reader.
    550     template <typename Reader, typename Map>
     550    template <typename ItemReader, typename Map>
    551551    UGraphReader& readUEdgeMap(std::string name, Map& map,
    552                                        const Reader& reader = Reader()) {
    553       u_edgeset_reader.readUEdgeMap(name, map, reader);
    554       return *this;
    555     }
    556 
    557     template <typename Reader, typename Map>
     552                               const ItemReader& ir = ItemReader()) {
     553      u_edgeset_reader.readUEdgeMap(name, map, ir);
     554      return *this;
     555    }
     556
     557    template <typename ItemReader, typename Map>
    558558    UGraphReader& readUEdgeMap(std::string name, const Map& map,
    559                                        const Reader& reader = Reader()) {
    560       u_edgeset_reader.readUEdgeMap(name, map, reader);
     559                               const ItemReader& ir = ItemReader()) {
     560      u_edgeset_reader.readUEdgeMap(name, map, ir);
    561561      return *this;
    562562    }
    … …  
    565565    ///
    566566    /// Give a new undirected edge map skipping command to the reader.
    567     template <typename Reader>
     567    template <typename ItemReader>
    568568    UGraphReader& skipUEdgeMap(std::string name,
    569                                        const Reader& reader = Reader()) {
    570       u_edgeset_reader.skipUMap(name, reader);
     569                                       const ItemReader& ir = ItemReader()) {
     570      u_edgeset_reader.skipUMap(name, ir);
    571571      return *this;
    572572    }
    … …  
    592592    ///
    593593    /// Give a new edge map reading command to the reader.
    594     template <typename Reader, typename Map>
     594    template <typename ItemReader, typename Map>
    595595    UGraphReader& readEdgeMap(std::string name, Map& map,
    596                                        const Reader& reader = Reader()) {
    597       u_edgeset_reader.readEdgeMap(name, map, reader);
    598       return *this;
    599     }
    600 
    601     template <typename Reader, typename Map>
     596                              const ItemReader& ir = ItemReader()) {
     597      u_edgeset_reader.readEdgeMap(name, map, ir);
     598      return *this;
     599    }
     600
     601    template <typename ItemReader, typename Map>
    602602    UGraphReader& readEdgeMap(std::string name, const Map& map,
    603                                        const Reader& reader = Reader()) {
    604       u_edgeset_reader.readEdgeMap(name, map, reader);
     603                              const ItemReader& ir = ItemReader()) {
     604      u_edgeset_reader.readEdgeMap(name, map, ir);
    605605      return *this;
    606606    }
    … …  
    609609    ///
    610610    /// Give a new edge map skipping command to the reader.
    611     template <typename Reader>
     611    template <typename ItemReader>
    612612    UGraphReader& skipEdgeMap(std::string name,
    613                                        const Reader& reader = Reader()) {
    614       u_edgeset_reader.skipEdgeMap(name, reader);
     613                              const ItemReader& ir = ItemReader()) {
     614      u_edgeset_reader.skipEdgeMap(name, ir);
    615615      return *this;
    616616    }
    … …  
    651651    ///
    652652    ///  Give a new attribute reading command.
    653     template <typename Reader, typename Value>
     653    template <typename ItemReader, typename Value>
    654654    UGraphReader& readAttribute(std::string name, Value& value,
    655                                const Reader& reader) {
    656       attribute_reader.readAttribute<Reader>(name, value, reader);
     655                               const ItemReader& ir = ItemReader()) {
     656      attribute_reader.readAttribute(name, value, ir);
    657657      return *this;
    658658    }

  • lemon/graph_to_eps.h

    r2379 r2386  
    950950              dim2::Bezier3 bez(s,mm,mm,t);
    951951              double t1=0,t2=1;
    952               for(int i=0;i<INTERPOL_PREC;++i)
     952              for(int ii=0;ii<INTERPOL_PREC;++ii)
    953953                if(isInsideNode(bez((t1+t2)/2)-t,rn,node_shape)) t2=(t1+t2)/2;
    954954                else t1=(t1+t2)/2;
    … …  
    957957              rn*=rn;
    958958              t2=(t1+t2)/2;t1=0;
    959               for(int i=0;i<INTERPOL_PREC;++i)
     959              for(int ii=0;ii<INTERPOL_PREC;++ii)
    960960                if((bez((t1+t2)/2)-apoint).normSquare()>rn) t1=(t1+t2)/2;
    961961                else t2=(t1+t2)/2;

  • lemon/graph_utils.h

    r2384 r2386  
    791791    /// Destructor of the GraphCopy
    792792    ~GraphCopy() {
    793       for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
     793      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
    794794        delete nodeMapCopies[i];
    795795      }
    796       for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
     796      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
    797797        delete edgeMapCopies[i];
    798798      }
    … …  
    837837    ///
    838838    /// Make a copy of the given node.
    839     GraphCopy& node(TNode& tnode, const Node& node) {
     839    GraphCopy& node(TNode& tnode, const Node& snode) {
    840840      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
    841                               NodeRefMap, TNode>(tnode, node));
     841                              NodeRefMap, TNode>(tnode, snode));
    842842      return *this;
    843843    }
    … …  
    880880    ///
    881881    /// Make a copy of the given edge.
    882     GraphCopy& edge(TEdge& tedge, const Edge& edge) {
     882    GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
    883883      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
    884                               EdgeRefMap, TEdge>(tedge, edge));
     884                              EdgeRefMap, TEdge>(tedge, sedge));
    885885      return *this;
    886886    }
    … …  
    894894      _graph_utils_bits::GraphCopySelector<Target>::
    895895        copy(target, source, nodeRefMap, edgeRefMap);
    896       for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
     896      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
    897897        nodeMapCopies[i]->copy(source, nodeRefMap);
    898898      }
    899       for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
     899      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
    900900        edgeMapCopies[i]->copy(source, edgeRefMap);
    901901      }     
    … …  
    968968
    969969      Value operator[](const Key& key) const {
    970         bool forward = (source.direction(key) ==
    971                         (node_ref[source.source((UEdge)key)] ==
    972                          target.source(uedge_ref[(UEdge)key])));
     970        bool forward =
     971          (source.direction(key) ==
     972           (node_ref[source.source(static_cast<const UEdge&>(key))] ==
     973            target.source(uedge_ref[static_cast<const UEdge&>(key)])));
    973974        return target.direct(uedge_ref[key], forward);
    974975      }
    … …  
    995996    /// Destructor of the GraphCopy
    996997    ~UGraphCopy() {
    997       for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
     998      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
    998999        delete nodeMapCopies[i];
    9991000      }
    1000       for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
     1001      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
    10011002        delete edgeMapCopies[i];
    10021003      }
    1003       for (int i = 0; i < (int)uEdgeMapCopies.size(); ++i) {
     1004      for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
    10041005        delete uEdgeMapCopies[i];
    10051006      }
    … …  
    10441045    ///
    10451046    /// Make a copy of the given node.
    1046     UGraphCopy& node(TNode& tnode, const Node& node) {
     1047    UGraphCopy& node(TNode& tnode, const Node& snode) {
    10471048      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
    1048                               NodeRefMap, TNode>(tnode, node));
     1049                              NodeRefMap, TNode>(tnode, snode));
    10491050      return *this;
    10501051    }
    … …  
    10871088    ///
    10881089    /// Make a copy of the given edge.
    1089     UGraphCopy& edge(TEdge& tedge, const Edge& edge) {
     1090    UGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
    10901091      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
    1091                               EdgeRefMap, TEdge>(tedge, edge));
     1092                              EdgeRefMap, TEdge>(tedge, sedge));
    10921093      return *this;
    10931094    }
    … …  
    11301131    ///
    11311132    /// Make a copy of the given undirected edge.
    1132     UGraphCopy& uEdge(TUEdge& tuedge, const UEdge& uedge) {
     1133    UGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
    11331134      uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge,
    1134                                UEdgeRefMap, TUEdge>(tuedge, uedge));
     1135                               UEdgeRefMap, TUEdge>(tuedge, suedge));
    11351136      return *this;
    11361137    }
    … …  
    11451146      _graph_utils_bits::UGraphCopySelector<Target>::
    11461147        copy(target, source, nodeRefMap, uEdgeRefMap);
    1147       for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
     1148      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
    11481149        nodeMapCopies[i]->copy(source, nodeRefMap);
    11491150      }
    1150       for (int i = 0; i < (int)uEdgeMapCopies.size(); ++i) {
     1151      for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
    11511152        uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
    11521153      }
    1153       for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
     1154      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
    11541155        edgeMapCopies[i]->copy(source, edgeRefMap);
    11551156      }
    … …  
    12461247
    12471248      Value operator[](const Key& key) const {
    1248         bool forward = (source.direction(key) ==
    1249                         (node_ref[source.source((UEdge)key)] ==
    1250                          target.source(uedge_ref[(UEdge)key])));
     1249        bool forward =
     1250          (source.direction(key) ==
     1251           (node_ref[source.source(static_cast<const UEdge&>(key))] ==
     1252            target.source(uedge_ref[static_cast<const UEdge&>(key)])));
    12511253        return target.direct(uedge_ref[key], forward);
    12521254      }
    … …  
    12721274    /// Destructor of the GraphCopy
    12731275    ~BpUGraphCopy() {
    1274       for (int i = 0; i < (int)aNodeMapCopies.size(); ++i) {
     1276      for (int i = 0; i < int(aNodeMapCopies.size()); ++i) {
    12751277        delete aNodeMapCopies[i];
    12761278      }
    1277       for (int i = 0; i < (int)bNodeMapCopies.size(); ++i) {
     1279      for (int i = 0; i < int(bNodeMapCopies.size()); ++i) {
    12781280        delete bNodeMapCopies[i];
    12791281      }
    1280       for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
     1282      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
    12811283        delete nodeMapCopies[i];
    12821284      }
    1283       for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
     1285      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
    12841286        delete edgeMapCopies[i];
    12851287      }
    1286       for (int i = 0; i < (int)uEdgeMapCopies.size(); ++i) {
     1288      for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
    12871289        delete uEdgeMapCopies[i];
    12881290      }
    … …  
    13941396    ///
    13951397    /// Make a copy of the given node.
    1396     BpUGraphCopy& node(TNode& tnode, const Node& node) {
     1398    BpUGraphCopy& node(TNode& tnode, const Node& snode) {
    13971399      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
    1398                               NodeRefMap, TNode>(tnode, node));
     1400                              NodeRefMap, TNode>(tnode, snode));
    13991401      return *this;
    14001402    }
    … …  
    14371439    ///
    14381440    /// Make a copy of the given edge.
    1439     BpUGraphCopy& edge(TEdge& tedge, const Edge& edge) {
     1441    BpUGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
    14401442      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
    1441                               EdgeRefMap, TEdge>(tedge, edge));
     1443                              EdgeRefMap, TEdge>(tedge, sedge));
    14421444      return *this;
    14431445    }
    … …  
    14801482    ///
    14811483    /// Make a copy of the given undirected edge.
    1482     BpUGraphCopy& uEdge(TUEdge& tuedge, const UEdge& uedge) {
     1484    BpUGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
    14831485      uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge,
    1484                                UEdgeRefMap, TUEdge>(tuedge, uedge));
     1486                               UEdgeRefMap, TUEdge>(tuedge, suedge));
    14851487      return *this;
    14861488    }
    … …  
    14971499      _graph_utils_bits::BpUGraphCopySelector<Target>::
    14981500        copy(target, source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
    1499       for (int i = 0; i < (int)aNodeMapCopies.size(); ++i) {
     1501      for (int i = 0; i < int(aNodeMapCopies.size()); ++i) {
    15001502        aNodeMapCopies[i]->copy(source, aNodeRefMap);
    15011503      }
    1502       for (int i = 0; i < (int)bNodeMapCopies.size(); ++i) {
     1504      for (int i = 0; i < int(bNodeMapCopies.size()); ++i) {
    15031505        bNodeMapCopies[i]->copy(source, bNodeRefMap);
    15041506      }
    1505       for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
     1507      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
    15061508        nodeMapCopies[i]->copy(source, nodeRefMap);
    15071509      }
    1508       for (int i = 0; i < (int)uEdgeMapCopies.size(); ++i) {
     1510      for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
    15091511        uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
    15101512      }
    1511       for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
     1513      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
    15121514        edgeMapCopies[i]->copy(source, edgeRefMap);
    15131515      }
    … …  
    17781780    /// \c AlterationNotifier.
    17791781    virtual void erase(const std::vector<Key>& keys) {
    1780       for (int i = 0; i < (int)keys.size(); ++i) {
     1782      for (int i = 0; i < int(keys.size()); ++i) {
    17811783        Value val = Map::operator[](keys[i]);
    17821784        typename Container::iterator it = invMap.find(val);
    … …  
    18741876    explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
    18751877      Item it;
    1876       const typename Map::Notifier* notifier = Map::notifier();
    1877       for (notifier->first(it); it != INVALID; notifier->next(it)) {
     1878      const typename Map::Notifier* nf = Map::notifier();
     1879      for (nf->first(it); it != INVALID; nf->next(it)) {
    18781880        Map::set(it, invMap.size());
    18791881        invMap.push_back(it);   
    … …  
    18991901    virtual void add(const std::vector<Item>& items) {
    19001902      Map::add(items);
    1901       for (int i = 0; i < (int)items.size(); ++i) {
     1903      for (int i = 0; i < int(items.size()); ++i) {
    19021904        Map::set(items[i], invMap.size());
    19031905        invMap.push_back(items[i]);
    … …  
    19211923    /// \c AlterationNotifier.
    19221924    virtual void erase(const std::vector<Item>& items) {
    1923       for (int i = 0; i < (int)items.size(); ++i) {
     1925      for (int i = 0; i < int(items.size()); ++i) {
    19241926        Map::set(invMap.back(), Map::operator[](items[i]));
    19251927        invMap[Map::operator[](items[i])] = invMap.back();
    … …  
    19361938      Map::build();
    19371939      Item it;
    1938       const typename Map::Notifier* notifier = Map::notifier();
    1939       for (notifier->first(it); it != INVALID; notifier->next(it)) {
     1940      const typename Map::Notifier* nf = Map::notifier();
     1941      for (nf->first(it); it != INVALID; nf->next(it)) {
    19401942        Map::set(it, invMap.size());
    19411943        invMap.push_back(it);   
    … …  
    22812283      virtual void add(const std::vector<Key>& keys) {
    22822284        Parent::add(keys);
    2283         for (int i = 0; i < (int)keys.size(); ++i) {
     2285        for (int i = 0; i < int(keys.size()); ++i) {
    22842286          Parent::set(keys[i], 0);
    22852287        }
    … …  
    23142316
    23152317    virtual void add(const std::vector<Edge>& edges) {
    2316       for (int i = 0; i < (int)edges.size(); ++i) {
     2318      for (int i = 0; i < int(edges.size()); ++i) {
    23172319        ++deg[graph.target(edges[i])];
    23182320      }
    … …  
    23242326
    23252327    virtual void erase(const std::vector<Edge>& edges) {
    2326       for (int i = 0; i < (int)edges.size(); ++i) {
     2328      for (int i = 0; i < int(edges.size()); ++i) {
    23272329        --deg[graph.target(edges[i])];
    23282330      }
    … …  
    23932395      virtual void add(const std::vector<Key>& keys) {
    23942396        Parent::add(keys);
    2395         for (int i = 0; i < (int)keys.size(); ++i) {
     2397        for (int i = 0; i < int(keys.size()); ++i) {
    23962398          Parent::set(keys[i], 0);
    23972399        }
    … …  
    24262428
    24272429    virtual void add(const std::vector<Edge>& edges) {
    2428       for (int i = 0; i < (int)edges.size(); ++i) {
     2430      for (int i = 0; i < int(edges.size()); ++i) {
    24292431        ++deg[graph.source(edges[i])];
    24302432      }
    … …  
    24362438
    24372439    virtual void erase(const std::vector<Edge>& edges) {
    2438       for (int i = 0; i < (int)edges.size(); ++i) {
     2440      for (int i = 0; i < int(edges.size()); ++i) {
    24392441        --deg[graph.source(edges[i])];
    24402442      }

  • lemon/graph_writer.h

    r2200 r2386  
    159159   /// This function issues a new <i> node map writing command</i> to the writer.
    160160    template <typename Map>
    161     GraphWriter& writeNodeMap(std::string name, const Map& map) {
    162       nodeset_writer.writeNodeMap(name, map);
     161    GraphWriter& writeNodeMap(std::string label, const Map& map) {
     162      nodeset_writer.writeNodeMap(label, map);
    163163      return *this;
    164164    }
    … …  
    168168    ///
    169169   /// This function issues a new <i> node map writing command</i> to the writer.
    170     template <typename Writer, typename Map>
    171     GraphWriter& writeNodeMap(std::string name, const Map& map,
    172                               const Writer& writer = Writer()) {
    173       nodeset_writer.writeNodeMap(name, map, writer);
     170    template <typename ItemWriter, typename Map>
     171    GraphWriter& writeNodeMap(std::string label, const Map& map,
     172                              const ItemWriter& iw = ItemWriter()) {
     173      nodeset_writer.writeNodeMap(label, map, iw);
    174174      return *this;
    175175    }
    … …  
    180180   /// This function issues a new <i> edge map writing command</i> to the writer.
    181181    template <typename Map>
    182     GraphWriter& writeEdgeMap(std::string name, const Map& map) {
    183       edgeset_writer.writeEdgeMap(name, map);
     182    GraphWriter& writeEdgeMap(std::string label, const Map& map) {
     183      edgeset_writer.writeEdgeMap(label, map);
    184184      return *this;
    185185    }
    … …  
    189189    ///
    190190   /// This function issues a new <i> edge map writing command</i> to the writer.
    191     template <typename Writer, typename Map>
    192     GraphWriter& writeEdgeMap(std::string name, const Map& map,
    193                               const Writer& writer = Writer()) {
    194       edgeset_writer.writeEdgeMap(name, map, writer);
     191    template <typename ItemWriter, typename Map>
     192    GraphWriter& writeEdgeMap(std::string label, const Map& map,
     193                              const ItemWriter& iw = ItemWriter()) {
     194      edgeset_writer.writeEdgeMap(label, map, iw);
    195195      return *this;
    196196    }
    … …  
    200200    /// This function issues a new <i> labeled node writing command</i>
    201201    /// to the writer.
    202     GraphWriter& writeNode(std::string name, const Node& node) {
    203       node_writer.writeNode(name, node);
     202    GraphWriter& writeNode(std::string label, const Node& node) {
     203      node_writer.writeNode(label, node);
    204204      return *this;
    205205    }
    … …  
    209209    /// This function issues a new <i> labeled edge writing command</i>
    210210    /// to the writer.
    211     GraphWriter& writeEdge(std::string name, const Edge& edge) {
    212       edge_writer.writeEdge(name, edge);
     211    GraphWriter& writeEdge(std::string label, const Edge& edge) {
     212      edge_writer.writeEdge(label, edge);
    213213    }
    214214
    … …  
    218218    /// to the writer.
    219219    template <typename Value>
    220     GraphWriter& writeAttribute(std::string name, const Value& value) {
    221       attribute_writer.writeAttribute(name, value);
     220    GraphWriter& writeAttribute(std::string label, const Value& value) {
     221      attribute_writer.writeAttribute(label, value);
    222222      return *this;
    223223    }
    … …  
    227227    /// This function issues a new <i> attribute writing command</i>
    228228    /// to the writer.
    229     template <typename Writer, typename Value>
    230     GraphWriter& writeAttribute(std::string name, const Value& value,
    231                                const Writer& writer) {
    232       attribute_writer.writeAttribute<Writer>(name, value, writer);
     229    template <typename ItemWriter, typename Value>
     230    GraphWriter& writeAttribute(std::string label, const Value& value,
     231                               const ItemWriter& iw = ItemWriter()) {
     232      attribute_writer.writeAttribute(label, value, iw);
    233233      return *this;
    234234    }
    … …  
    413413    /// the writer.
    414414    template <typename Map>
    415     UGraphWriter& writeNodeMap(std::string name, const Map& map) {
    416       nodeset_writer.writeNodeMap(name, map);
     415    UGraphWriter& writeNodeMap(std::string label, const Map& map) {
     416      nodeset_writer.writeNodeMap(label, map);
    417417      return *this;
    418418    }
    … …  
    422422    /// This function issues a new <i> node map writing command</i> to
    423423    /// the writer.
    424     template <typename Writer, typename Map>
    425     UGraphWriter& writeNodeMap(std::string name, const Map& map,
    426                               const Writer& writer = Writer()) {
    427       nodeset_writer.writeNodeMap(name, map, writer);
     424    template <typename ItemWriter, typename Map>
     425    UGraphWriter& writeNodeMap(std::string label, const Map& map,
     426                              const ItemWriter& iw = ItemWriter()) {
     427      nodeset_writer.writeNodeMap(label, map, iw);
    428428      return *this;
    429429    }
    … …  
    434434    /// the writer.
    435435    template <typename Map>
    436     UGraphWriter& writeEdgeMap(std::string name, const Map& map) {
    437       u_edgeset_writer.writeEdgeMap(name, map);
     436    UGraphWriter& writeEdgeMap(std::string label, const Map& map) {
     437      u_edgeset_writer.writeEdgeMap(label, map);
    438438      return *this;
    439439    }
    … …  
    443443    /// This function issues a new <i> edge map writing command</i> to
    444444    /// the writer.
    445     template <typename Writer, typename Map>
    446     UGraphWriter& writeEdgeMap(std::string name, const Map& map,
    447                                    const Writer& writer = Writer()) {
    448       u_edgeset_writer.writeEdgeMap(name, map, writer);
     445    template <typename ItemWriter, typename Map>
     446    UGraphWriter& writeEdgeMap(std::string label, const Map& map,
     447                                   const ItemWriter& iw = ItemWriter()) {
     448      u_edgeset_writer.writeEdgeMap(label, map, iw);
    449449      return *this;
    450450    }
    … …  
    455455    /// command</i> to the writer.
    456456    template <typename Map>
    457     UGraphWriter& writeUEdgeMap(std::string name, const Map& map) {
    458       u_edgeset_writer.writeUEdgeMap(name, map);
     457    UGraphWriter& writeUEdgeMap(std::string label, const Map& map) {
     458      u_edgeset_writer.writeUEdgeMap(label, map);
    459459      return *this;
    460460    }
    … …  
    464464    /// This function issues a new <i> undirected edge map writing
    465465    /// command</i> to the writer.
    466    template <typename Writer, typename Map>
    467     UGraphWriter& writeUEdgeMap(std::string name, const Map& map,
    468                                         const Writer& writer = Writer()) {
    469       u_edgeset_writer.writeUEdgeMap(name, map, writer);
     466   template <typename ItemWriter, typename Map>
     467    UGraphWriter& writeUEdgeMap(std::string label, const Map& map,
     468                                        const ItemWriter& iw = ItemWriter()) {
     469      u_edgeset_writer.writeUEdgeMap(label, map, iw);
    470470      return *this;
    471471    }
    … …  
    475475    /// This function issues a new <i> labeled node writing
    476476    /// command</i> to the writer.
    477     UGraphWriter& writeNode(std::string name, const Node& node) {
    478       node_writer.writeNode(name, node);
     477    UGraphWriter& writeNode(std::string label, const Node& node) {
     478      node_writer.writeNode(label, node);
    479479      return *this;
    480480    }
    … …  
    484484    /// This function issues a new <i> labeled edge writing
    485485    /// command</i> to the writer.
    486     UGraphWriter& writeEdge(std::string name, const Edge& edge) {
    487       u_edge_writer.writeEdge(name, edge);
     486    UGraphWriter& writeEdge(std::string label, const Edge& edge) {
     487      u_edge_writer.writeEdge(label, edge);
    488488    }
    489489
    … …  
    493493    /// Issue a new <i>labeled undirected edge writing command</i> to
    494494    /// the writer.
    495     UGraphWriter& writeUEdge(std::string name, const UEdge& edge) {
    496       u_edge_writer.writeUEdge(name, edge);
     495    UGraphWriter& writeUEdge(std::string label, const UEdge& edge) {
     496      u_edge_writer.writeUEdge(label, edge);
    497497    }
    498498
    … …  
    502502    /// command</i> to the writer.
    503503    template <typename Value>
    504     UGraphWriter& writeAttribute(std::string name, const Value& value) {
    505       attribute_writer.writeAttribute(name, value);
     504    UGraphWriter& writeAttribute(std::string label, const Value& value) {
     505      attribute_writer.writeAttribute(label, value);
    506506      return *this;
    507507    }
    … …  
    511511    /// This function issues a new <i> attribute writing
    512512    /// command</i> to the writer.
    513     template <typename Writer, typename Value>
    514     UGraphWriter& writeAttribute(std::string name, const Value& value,
    515                                const Writer& writer) {
    516       attribute_writer.writeAttribute<Writer>(name, value, writer);
     513    template <typename ItemWriter, typename Value>
     514    UGraphWriter& writeAttribute(std::string label, const Value& value,
     515                               const ItemWriter& iw = ItemWriter()) {
     516      attribute_writer.writeAttribute(label, value, iw);
    517517      return *this;
    518518    }

  • lemon/grid_ugraph.h

    r2384 r2386  
    5050  protected:
    5151
    52     void construct(int width, int height) {
    53       _height = height; _width = width;
    54       _nodeNum = height * width; _edgeNum = 2 * _nodeNum - width - height;
    55       _edgeLimit = _nodeNum - width;
     52    void construct(int w, int h) {
     53      _height = h; _width = w;
     54      _nodeNum = h * w; _edgeNum = 2 * _nodeNum - w - h;
     55      _edgeLimit = _nodeNum - w;
    5656    }
    5757

  • lemon/hao_orlin.h

    r2376 r2386  
    198198    template <typename ResGraph>
    199199    void findMinCut(const Node& target, bool out, ResGraph& res_graph) {
    200       typedef typename Graph::Node Node;
    201200      typedef typename ResGraph::Edge ResEdge;
    202201      typedef typename ResGraph::OutEdgeIt ResOutEdgeIt;
    … …  
    328327      _dormant[0].push_front(_target);
    329328      (*_source_set)[_target] = true;
    330       if ((int)_dormant[0].size() == _node_num){
     329      if (int(_dormant[0].size()) == _node_num){
    331330        _dormant[0].clear();
    332331        return false;

  • lemon/hypercube_graph.h

    r2260 r2386  
    155155
    156156    bool projection(Node node, int n) const {
    157       return (bool)(node.id & (1 << n));
     157      return static_cast<bool>(node.id & (1 << n));
    158158    }
    159159
    … …  
    166166    }
    167167
    168     Node operator()(int index) const {
    169       return Node(index);
     168    Node operator()(int ix) const {
     169      return Node(ix);
    170170    }
    171171   
    … …  
    237237    ///
    238238    /// Gives back the node by its index.
    239     Node operator()(int index) const {
    240       return Parent::operator()(index);
     239    Node operator()(int ix) const {
     240      return Parent::operator()(ix);
    241241    }
    242242

  • lemon/iterable_maps.h

    r2210 r2386  
    9898
    9999      Reference& operator=(const Reference& value) {
    100         _map.set(_key, (bool)value);
     100        _map.set(_key, static_cast<bool>(value));
    101101        return *this;
    102102      }
    … …  
    248248      /// \param _map The IterableIntMap
    249249      explicit FalseIt(const IterableBoolMap& _map)
    250         : Parent(_map.sep < (int)_map.array.size() ?
     250        : Parent(_map.sep < int(_map.array.size()) ?
    251251                 _map.array.back() : INVALID), map(&_map) {}
    252252
    … …  
    289289      ItemIt(const IterableBoolMap& _map, bool value)
    290290        : Parent(value ? (_map.sep > 0 ? _map.array[_map.sep - 1] : INVALID) :
    291                  (_map.sep < (int)_map.array.size() ?
     291                 (_map.sep < int(_map.array.size()) ?
    292292                  _map.array.back() : INVALID)), map(&_map) {}
    293293
    … …  
    322322    virtual void add(const std::vector<Key>& keys) {
    323323      Parent::add(keys);
    324       for (int i = 0; i < (int)keys.size(); ++i) {
     324      for (int i = 0; i < int(keys.size()); ++i) {
    325325        Parent::set(keys[i], array.size());
    326326        array.push_back(keys[i]);
    … …  
    346346
    347347    virtual void erase(const std::vector<Key>& keys) {
    348       for (int i = 0; i < (int)keys.size(); ++i) {
     348      for (int i = 0; i < int(keys.size()); ++i) {
    349349        int pos = position(keys[i]);
    350350        if (pos < sep) {
    … …  
    457457      typename Parent::Value& node = Parent::operator[](key);
    458458      if (node.value < 0) return;
    459       if (node.value >= (int)first.size()) {
     459      if (node.value >= int(first.size())) {
    460460        first.resize(node.value + 1, INVALID);
    461461      }
    … …  
    485485
    486486      Reference& operator=(const Reference& value) {
    487         _map.set(_key, (const int&)value);
     487        _map.set(_key, static_cast<const int&>(value));
    488488        return *this;
    489489      }
    … …  
    618618      /// \param value The value
    619619      ItemIt(const IterableIntMap& map, int value) : _map(&map) {
    620         if (value < 0 || value >= (int)_map->first.size()) {     
     620        if (value < 0 || value >= int(_map->first.size())) {     
    621621          Parent::operator=(INVALID);
    622622        } else {
    … …  
    647647
    648648    virtual void erase(const std::vector<Key>& keys) {
    649       for (int i = 0; i < (int)keys.size(); ++i) {
     649      for (int i = 0; i < int(keys.size()); ++i) {
    650650        unlace(keys[i]);
    651651      }
    … …  
    885885    virtual void add(const std::vector<Key>& keys) {
    886886      Parent::add(keys);
    887       for (int i = 0; i < (int)keys.size(); ++i) {
     887      for (int i = 0; i < int(keys.size()); ++i) {
    888888        lace(keys[i]);
    889889      }
    … …  
    896896
    897897    virtual void erase(const std::vector<Key>& keys) {
    898       for (int i = 0; i < (int)keys.size(); ++i) {
     898      for (int i = 0; i < int(keys.size()); ++i) {
    899899        unlace(keys[i]);
    900900      }

  • lemon/johnson.h

    r2376 r2386  
    564564      BellmanFordType bellmanford(*graph, *length);
    565565
    566       NullMap<Node, Edge> predMap;
    567 
    568       bellmanford.predMap(predMap);
     566      NullMap<Node, Edge> pm;
     567
     568      bellmanford.predMap(pm);
    569569     
    570570      bellmanford.init(OperationTraits::zero());
    … …  
    591591      BellmanFordType bellmanford(*graph, *length);
    592592
    593       NullMap<Node, Edge> predMap;
    594 
    595       bellmanford.predMap(predMap);
     593      NullMap<Node, Edge> pm;
     594
     595      bellmanford.predMap(pm);
    596596     
    597597      bellmanford.init(OperationTraits::zero());

  • lemon/kruskal.h

    r2354 r2386  
    103103//        //,typename OUT::Key = typename GR::Edge()
    104104          const typename IN::value_type::first_type * =
    105           (const typename IN::value_type::first_type *)(0),
    106           const typename OUT::Key * = (const typename OUT::Key *)(0)
     105          reinterpret_cast<const typename IN::value_type::first_type*>(0),
     106          const typename OUT::Key * =
     107          reinterpret_cast<const typename OUT::Key*>(0)
    107108          )
    108109#endif
    … …  
    171172//        typename OUT::Key = GR::Edge()
    172173          const typename IN::value_type::first_type * =
    173           (const typename IN::value_type::first_type *)(0),
    174           const typename OUT::Key * = (const typename OUT::Key *)(0)
     174          reinterpret_cast<const typename IN::value_type::first_type*>(0),
     175          const typename OUT::Key * =
     176          reinterpret_cast<const typename OUT::Key*>(0)
    175177          )
    176178  {
    … …  
    358360          //typename IN::Key = typename IN::Key (),
    359361          //      typename RET::Key = typename GR::Edge()
    360           const typename IN::Key *  = (const typename IN::Key *)(0),
    361           const typename RET::Key * = (const typename RET::Key *)(0)
     362          const typename IN::Key * =
     363          reinterpret_cast<const typename IN::Key*>(0),
     364          const typename RET::Key * =
     365          reinterpret_cast<const typename RET::Key*>(0)
    362366          )
    363367  {
    … …  
    408412          RET out,
    409413          const typename RET::value_type * =
    410           (const typename RET::value_type *)(0)
     414          reinterpret_cast<const typename RET::value_type*>(0)
    411415          )
    412416  {

  • lemon/lemon_reader.h

    r2368 r2386  
    534534      virtual std::streambuf* setbuf(char *buf, std::streamsize len) {
    535535        if (base()) return 0;
    536         if (buf != 0 && len >= (int)sizeof(small_buf)) {
     536        if (buf != 0 && len >= int(sizeof(small_buf))) {
    537537          setb(buf, len);
    538538        } else {
    … …  
    710710              FilterStreamBuf buffer(*is, line_num);
    711711              buffer.pubsetbuf(buf, sizeof(buf));
    712               std::istream is(&buffer);
    713               it->first->read(is);
     712              std::istream ss(&buffer);
     713              it->first->read(ss);
    714714              break;
    715715            }
    … …  
    798798    /// Add a new node map reader command for the reader.
    799799    template <typename Map>
    800     NodeSetReader& readNodeMap(std::string name, Map& map) {
     800    NodeSetReader& readNodeMap(std::string label, Map& map) {
    801801      return _readMap<
    802802        typename Traits::template Reader<typename Map::Value>, Map,
    803         typename _reader_bits::Arg<Map>::Type>(name, map);
     803        typename _reader_bits::Arg<Map>::Type>(label, map);
    804804    }
    805805
    806806    template <typename Map>
    807     NodeSetReader& readNodeMap(std::string name, const Map& map) {
     807    NodeSetReader& readNodeMap(std::string label, const Map& map) {
    808808      return _readMap<
    809809        typename Traits::template Reader<typename Map::Value>, Map,
    810         typename _reader_bits::Arg<Map>::Type>(name, map);
     810        typename _reader_bits::Arg<Map>::Type>(label, map);
    811811    }
    812812
    … …  
    814814    ///
    815815    /// Add a new node map reader command for the reader.
    816     template <typename Reader, typename Map>
    817     NodeSetReader& readNodeMap(std::string name, Map& map,
    818                                const Reader& reader = Reader()) {
    819       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    820         (name, map, reader);
    821     }
    822 
    823     template <typename Reader, typename Map>
    824     NodeSetReader& readNodeMap(std::string name, const Map& map,
    825                                const Reader& reader = Reader()) {
    826       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    827         (name, map, reader);
     816    template <typename ItemReader, typename Map>
     817    NodeSetReader& readNodeMap(std::string label, Map& map,
     818                               const ItemReader& ir = ItemReader()) {
     819      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
     820        (label, map, ir);
     821    }
     822
     823    template <typename ItemReader, typename Map>
     824    NodeSetReader& readNodeMap(std::string label, const Map& map,
     825                               const ItemReader& ir = ItemReader()) {
     826      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
     827        (label, map, ir);
    828828    }
    829829
    830830  private:
    831831
    832     template <typename Reader, typename Map, typename MapParameter>
    833     NodeSetReader& _readMap(std::string name, MapParameter map,
    834                             const Reader& reader = Reader()) {
     832    template <typename ItemReader, typename Map, typename MapParameter>
     833    NodeSetReader& _readMap(std::string label, MapParameter map,
     834                            const ItemReader& ir = ItemReader()) {
    835835      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
    836       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    837       if (readers.find(name) != readers.end()) {
     836      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
     837      if (readers.find(label) != readers.end()) {
    838838        ErrorMessage msg;
    839         msg << "Multiple read rule for node map: " << name;
     839        msg << "Multiple read rule for node map: " << label;
    840840        throw IoParameterError(msg.message());
    841841      }     
    842842      readers.insert(
    843         make_pair(name, new _reader_bits::
    844                   MapReader<Node, Map, Reader>(map, reader)));
     843        make_pair(label, new _reader_bits::
     844                  MapReader<Node, Map, ItemReader>(map, ir)));
    845845      return *this;
    846846    }
    … …  
    851851    ///
    852852    /// Add a new node map skipper command for the reader.
    853     template <typename Reader>
    854     NodeSetReader& skipNodeMap(std::string name,
    855                            const Reader& reader = Reader()) {
    856       if (readers.find(name) != readers.end()) {
     853    template <typename ItemReader>
     854    NodeSetReader& skipNodeMap(std::string label,
     855                               const ItemReader& ir = ItemReader()) {
     856      if (readers.find(label) != readers.end()) {
    857857        ErrorMessage msg;
    858         msg << "Multiple read rule for node map: " << name;
     858        msg << "Multiple read rule for node map: " << label;
    859859        throw IoParameterError(msg.message());
    860860      }
    861       readers.insert(make_pair(name, new _reader_bits::
    862                                SkipReader<Node, Reader>(reader)));
     861      readers.insert(make_pair(label, new _reader_bits::
     862                               SkipReader<Node, ItemReader>(ir)));
    863863      return *this;
    864864    }
    … …  
    886886      std::string line;
    887887
    888       getline(is, line);
    889       std::istringstream ls(line);
    890       std::string id;
    891       while (ls >> id) {
    892         typename MapReaders::iterator it = readers.find(id);
    893         if (it != readers.end()) {
    894           it->second->touch();
    895           index.push_back(it->second);
    896         } else {
    897           index.push_back(&skipper);
    898         }
    899         if (id == "label") {
    900           inverter.reset(index.back()->getInverter());
    901           index.back() = inverter.get();
    902         }
     888      {
     889        getline(is, line);
     890        std::istringstream ls(line);
     891        std::string id;
     892        while (ls >> id) {
     893          typename MapReaders::iterator it = readers.find(id);
     894          if (it != readers.end()) {
     895            it->second->touch();
     896            index.push_back(it->second);
     897          } else {
     898            index.push_back(&skipper);
     899          }
     900          if (id == "label") {
     901            inverter.reset(index.back()->getInverter());
     902            index.back() = inverter.get();
     903          }
     904        }
    903905      }
    904906      for (typename MapReaders::iterator it = readers.begin();
    … …  
    913915        Node node = graph.addNode();
    914916        std::istringstream ls(line);
    915         for (int i = 0; i < (int)index.size(); ++i) {
     917        for (int i = 0; i < int(index.size()); ++i) {
    916918          index[i]->read(ls, node);
    917919        }
    … …  
    10281030    /// Add a new edge map reader command for the reader.
    10291031    template <typename Map>
    1030     EdgeSetReader& readEdgeMap(std::string name, Map& map) {
     1032    EdgeSetReader& readEdgeMap(std::string label, Map& map) {
    10311033      return _readMap<
    10321034        typename Traits::template Reader<typename Map::Value>, Map,
    1033         typename _reader_bits::Arg<Map>::Type>(name, map);
     1035        typename _reader_bits::Arg<Map>::Type>(label, map);
    10341036    }
    10351037
    10361038    template <typename Map>
    1037     EdgeSetReader& readEdgeMap(std::string name, const Map& map) {
     1039    EdgeSetReader& readEdgeMap(std::string label, const Map& map) {
    10381040      return _readMap<
    10391041        typename Traits::template Reader<typename Map::Value>, Map,
    1040         typename _reader_bits::Arg<Map>::Type>(name, map);
     1042        typename _reader_bits::Arg<Map>::Type>(label, map);
    10411043    }
    10421044
    … …  
    10441046    ///
    10451047    /// Add a new edge map reader command for the reader.
    1046     template <typename Reader, typename Map>
    1047     EdgeSetReader& readEdgeMap(std::string name, Map& map,
    1048                            const Reader& reader = Reader()) {
    1049       return _readMap<Reader, Map,
    1050         typename _reader_bits::Arg<Map>::Type>(name, map, reader);
    1051     }
    1052 
    1053     template <typename Reader, typename Map>
    1054     EdgeSetReader& readEdgeMap(std::string name, const Map& map,
    1055                                const Reader& reader = Reader()) {
    1056       return _readMap<Reader, Map,
    1057         typename _reader_bits::Arg<Map>::Type>(name, map, reader);
     1048    template <typename ItemReader, typename Map>
     1049    EdgeSetReader& readEdgeMap(std::string label, Map& map,
     1050                               const ItemReader& ir = ItemReader()) {
     1051      return _readMap<ItemReader, Map,
     1052        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
     1053    }
     1054
     1055    template <typename ItemReader, typename Map>
     1056    EdgeSetReader& readEdgeMap(std::string label, const Map& map,
     1057                               const ItemReader& ir = ItemReader()) {
     1058      return _readMap<ItemReader, Map,
     1059        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
    10581060    }
    10591061
    10601062  private:
    10611063
    1062     template <typename Reader, typename Map, typename MapParameter>
    1063     EdgeSetReader& _readMap(std::string name, MapParameter map,
    1064                             const Reader& reader = Reader()) {
     1064    template <typename ItemReader, typename Map, typename MapParameter>
     1065    EdgeSetReader& _readMap(std::string label, MapParameter map,
     1066                            const ItemReader& ir = ItemReader()) {
    10651067      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
    1066       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    1067       if (readers.find(name) != readers.end()) {
     1068      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
     1069      if (readers.find(label) != readers.end()) {
    10681070        ErrorMessage msg;
    1069         msg << "Multiple read rule for edge map: " << name;
     1071        msg << "Multiple read rule for edge map: " << label;
    10701072        throw IoParameterError(msg.message());
    10711073      }
    10721074      readers.insert(
    1073         make_pair(name, new _reader_bits::
    1074                   MapReader<Edge, Map, Reader>(map, reader)));
     1075        make_pair(label, new _reader_bits::
     1076                  MapReader<Edge, Map, ItemReader>(map, ir)));
    10751077      return *this;
    10761078    }
    … …  
    10811083    ///
    10821084    /// Add a new edge map skipper command for the reader.
    1083     template <typename Reader>
    1084     EdgeSetReader& skipEdgeMap(std::string name,
    1085                                const Reader& reader = Reader()) {
    1086       if (readers.find(name) != readers.end()) {
     1085    template <typename ItemReader>
     1086    EdgeSetReader& skipEdgeMap(std::string label,
     1087                               const ItemReader& ir = ItemReader()) {
     1088      if (readers.find(label) != readers.end()) {
    10871089        ErrorMessage msg;
    1088         msg << "Multiple read rule for edge map: " << name;
     1090        msg << "Multiple read rule for edge map: " << label;
    10891091        throw IoParameterError(msg.message());
    10901092      }
    1091       readers.insert(make_pair(name, new _reader_bits::
    1092                                SkipReader<Edge, Reader>(reader)));
     1093      readers.insert(make_pair(label, new _reader_bits::
     1094                               SkipReader<Edge, ItemReader>(ir)));
    10931095      return *this;
    10941096    }
    … …  
    11191121      std::string line;
    11201122
    1121       getline(is, line);
    1122       std::istringstream ls(line);     
    1123       std::string id;
    1124       while (ls >> id) {
    1125         typename MapReaders::iterator it = readers.find(id);
    1126         if (it != readers.end()) {
    1127           index.push_back(it->second);
    1128           it->second->touch();
    1129         } else {
    1130           index.push_back(&skipper);
    1131         }
    1132         if (id == "label") {
    1133           inverter.reset(index.back()->getInverter());
    1134           index.back() = inverter.get();
    1135         }
     1123      {
     1124        getline(is, line);
     1125        std::istringstream ls(line);   
     1126        std::string id;
     1127        while (ls >> id) {
     1128          typename MapReaders::iterator it = readers.find(id);
     1129          if (it != readers.end()) {
     1130            index.push_back(it->second);
     1131            it->second->touch();
     1132          } else {
     1133            index.push_back(&skipper);
     1134          }
     1135          if (id == "label") {
     1136            inverter.reset(index.back()->getInverter());
     1137            index.back() = inverter.get();
     1138          }
     1139        }
    11361140      }
    11371141      for (typename MapReaders::iterator it = readers.begin();
    … …  
    11481152        Node to = nodeLabelReader->read(ls);
    11491153        Edge edge = graph.addEdge(from, to);
    1150         for (int i = 0; i < (int)index.size(); ++i) {
     1154        for (int i = 0; i < int(index.size()); ++i) {
    11511155          index[i]->read(ls, edge);
    11521156        }
    … …  
    12721276    /// Add a new edge undirected map reader command for the reader.
    12731277    template <typename Map>
    1274     UEdgeSetReader& readUEdgeMap(std::string name, Map& map) {
     1278    UEdgeSetReader& readUEdgeMap(std::string label, Map& map) {
    12751279      return _readMap<
    12761280        typename Traits::template Reader<typename Map::Value>, Map,
    1277         typename _reader_bits::Arg<Map>::Type>(name, map);
     1281        typename _reader_bits::Arg<Map>::Type>(label, map);
    12781282    }
    12791283
    12801284    template <typename Map>
    1281     UEdgeSetReader& readUEdgeMap(std::string name, const Map& map) {
     1285    UEdgeSetReader& readUEdgeMap(std::string label, const Map& map) {
    12821286      return _readMap<
    12831287        typename Traits::template Reader<typename Map::Value>, Map,
    1284         typename _reader_bits::Arg<Map>::Type>(name, map);
     1288        typename _reader_bits::Arg<Map>::Type>(label, map);
    12851289    }
    12861290
    … …  
    12881292    ///
    12891293    /// Add a new edge undirected map reader command for the reader.
    1290     template <typename Reader, typename Map>
    1291     UEdgeSetReader& readUEdgeMap(std::string name, Map& map,
    1292                                          const Reader& reader = Reader()) {
    1293       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    1294         (name, map, reader);
    1295     }
    1296 
    1297     template <typename Reader, typename Map>
    1298     UEdgeSetReader& readUEdgeMap(std::string name, const Map& map,
    1299                                          const Reader& reader = Reader()) {
    1300       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type >
    1301         (name, map, reader);
     1294    template <typename ItemReader, typename Map>
     1295    UEdgeSetReader& readUEdgeMap(std::string label, Map& map,
     1296                                 const ItemReader& ir = ItemReader()) {
     1297      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
     1298        (label, map, ir);
     1299    }
     1300
     1301    template <typename ItemReader, typename Map>
     1302    UEdgeSetReader& readUEdgeMap(std::string label, const Map& map,
     1303                                 const ItemReader& ir = ItemReader()) {
     1304      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type >
     1305        (label, map, ir);
    13021306    }
    13031307
    13041308  private:
    13051309
    1306     template <typename Reader, typename Map, typename MapParameter>
    1307     UEdgeSetReader& _readMap(std::string name, MapParameter map,
    1308                                  const Reader& reader = Reader()) {
     1310    template <typename ItemReader, typename Map, typename MapParameter>
     1311    UEdgeSetReader& _readMap(std::string label, MapParameter map,
     1312                             const ItemReader& ir = ItemReader()) {
    13091313      checkConcept<concepts::WriteMap<UEdge, typename Map::Value>, Map>();
    1310       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    1311       if (readers.find(name) != readers.end()) {
     1314      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
     1315      if (readers.find(label) != readers.end()) {
    13121316        ErrorMessage msg;
    1313         msg << "Multiple read rule for edge map: " << name;
     1317        msg << "Multiple read rule for edge map: " << label;
    13141318        throw IoParameterError(msg.message());
    13151319      }
    13161320      readers.insert(
    1317         make_pair(name, new _reader_bits::
    1318                   MapReader<UEdge, Map, Reader>(map, reader)));
     1321        make_pair(label, new _reader_bits::
     1322                  MapReader<UEdge, Map, ItemReader>(map, ir)));
    13191323      return *this;
    13201324    }
    … …  
    13251329    ///
    13261330    /// Add a new undirected edge map skipper command for the reader.
    1327     template <typename Reader>
    1328     UEdgeSetReader& skipUEdgeMap(std::string name,
    1329                                          const Reader& reader = Reader()) {
    1330       if (readers.find(name) != readers.end()) {
     1331    template <typename ItemReader>
     1332    UEdgeSetReader& skipUEdgeMap(std::string label,
     1333                                 const ItemReader& ir = ItemReader()) {
     1334      if (readers.find(label) != readers.end()) {
    13311335        ErrorMessage msg;
    1332         msg << "Multiple read rule for node map: " << name;
     1336        msg << "Multiple read rule for node map: " << label;
    13331337        throw IoParameterError(msg.message());
    13341338      }
    1335       readers.insert(make_pair(name, new _reader_bits::
    1336                                SkipReader<UEdge, Reader>(reader)));
     1339      readers.insert(make_pair(label, new _reader_bits::
     1340                               SkipReader<UEdge, ItemReader>(ir)));
    13371341      return *this;
    13381342    }
    … …  
    13421346    /// Add a new directed edge map reader command for the reader.
    13431347    template <typename Map>
    1344     UEdgeSetReader& readEdgeMap(std::string name, Map& map) {
     1348    UEdgeSetReader& readEdgeMap(std::string label, Map& map) {
    13451349      return _readDirMap<
    13461350        typename Traits::template Reader<typename Map::Value>, Map,
    1347         typename _reader_bits::Arg<Map>::Type>(name, map);
     1351        typename _reader_bits::Arg<Map>::Type>(label, map);
    13481352    }
    13491353
    13501354    template <typename Map>
    1351     UEdgeSetReader& readEdgeMap(std::string name, const Map& map) {
     1355    UEdgeSetReader& readEdgeMap(std::string label, const Map& map) {
    13521356      return _readDirMap<
    13531357        typename Traits::template Reader<typename Map::Value>, Map,
    1354         typename _reader_bits::Arg<Map>::Type>(name, map);
     1358        typename _reader_bits::Arg<Map>::Type>(label, map);
    13551359    }
    13561360
    … …  
    13581362    ///
    13591363    /// Add a new directed edge map reader command for the reader.
    1360     template <typename Reader, typename Map>
    1361     UEdgeSetReader& readEdgeMap(std::string name, Map& map,
    1362                                     const Reader& reader = Reader()) {
    1363       return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    1364         (name, map, reader);
    1365     }
    1366 
    1367     template <typename Reader, typename Map>
    1368     UEdgeSetReader& readEdgeMap(std::string name, const Map& map,
    1369                                     const Reader& reader = Reader()) {
    1370       return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    1371         (name, map, reader);
     1364    template <typename ItemReader, typename Map>
     1365    UEdgeSetReader& readEdgeMap(std::string label, Map& map,
     1366                                    const ItemReader& ir = ItemReader()) {
     1367      return _readDirMap<ItemReader, Map,
     1368        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
     1369    }
     1370
     1371    template <typename ItemReader, typename Map>
     1372    UEdgeSetReader& readEdgeMap(std::string label, const Map& map,
     1373                                    const ItemReader& ir = ItemReader()) {
     1374      return _readDirMap<ItemReader, Map,
     1375        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
    13721376    }
    13731377
    13741378  private:
    13751379
    1376     template <typename Reader, typename Map, typename MapParameter>
    1377     UEdgeSetReader& _readDirMap(std::string name, MapParameter map,
    1378                                     const Reader& reader = Reader()) {
    1379       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
     1380    template <typename ItemReader, typename Map, typename MapParameter>
     1381    UEdgeSetReader& _readDirMap(std::string label, MapParameter map,
     1382                                    const ItemReader& ir = ItemReader()) {
     1383      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
    13801384      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
    1381       readUEdgeMap("+" + name,
    1382                    _reader_bits::forwardComposeMap(graph, map), reader);
    1383       readUEdgeMap("-" + name,
    1384                    _reader_bits::backwardComposeMap(graph, map), reader);
     1385      readUEdgeMap("+" + label,
     1386                   _reader_bits::forwardComposeMap(graph, map), ir);
     1387      readUEdgeMap("-" + label,
     1388                   _reader_bits::backwardComposeMap(graph, map), ir);
    13851389      return *this;     
    13861390    }
    … …  
    13911395    ///
    13921396    /// Add a new directed edge map skipper command for the reader.
    1393     template <typename Reader>
    1394     UEdgeSetReader& skipEdgeMap(std::string name,
    1395                                 const Reader& reader = Reader()) {
    1396       skipUEdgeMap("+" + name, reader);
    1397       skipUEdgeMap("-" + name, reader);
     1397    template <typename ItemReader>
     1398    UEdgeSetReader& skipEdgeMap(std::string label,
     1399                                const ItemReader& ir = ItemReader()) {
     1400      skipUEdgeMap("+" + label, ir);
     1401      skipUEdgeMap("-" + label, ir);
    13981402      return *this;
    13991403    }
    … …  
    14241428      std::string line;
    14251429
    1426       getline(is, line);
    1427       std::istringstream ls(line);     
    1428       std::string id;
    1429       while (ls >> id) {
    1430         typename MapReaders::iterator it = readers.find(id);
    1431         if (it != readers.end()) {
    1432           index.push_back(it->second);
    1433           it->second->touch();
    1434         } else {
    1435           index.push_back(&skipper);
    1436         }
    1437         if (id == "label") {
    1438           inverter.reset(index.back()->getInverter());
    1439           index.back() = inverter.get();
    1440         }
    1441       }
    1442       for (typename MapReaders::iterator it = readers.begin();
    1443            it != readers.end(); ++it) {
    1444         if (!it->second->touched()) {
    1445           ErrorMessage msg;
    1446           msg << "Map not found in file: " << it->first;
    1447           throw IoParameterError(msg.message());
    1448         }
     1430      {
     1431        getline(is, line);
     1432        std::istringstream ls(line);   
     1433        std::string id;
     1434        while (ls >> id) {
     1435          typename MapReaders::iterator it = readers.find(id);
     1436          if (it != readers.end()) {
     1437            index.push_back(it->second);
     1438            it->second->touch();
     1439          } else {
     1440            index.push_back(&skipper);
     1441          }
     1442          if (id == "label") {
     1443            inverter.reset(index.back()->getInverter());
     1444            index.back() = inverter.get();
     1445          }
     1446        }
     1447        for (typename MapReaders::iterator it = readers.begin();
     1448             it != readers.end(); ++it) {
     1449          if (!it->second->touched()) {
     1450            ErrorMessage msg;
     1451            msg << "Map not found in file: " << it->first;
     1452            throw IoParameterError(msg.message());
     1453          }
     1454        }
    14491455      }
    14501456      while (getline(is, line)) {       
    … …  
    14531459        Node to = nodeLabelReader->read(ls);
    14541460        UEdge edge = graph.addEdge(from, to);
    1455         for (int i = 0; i < (int)index.size(); ++i) {
     1461        for (int i = 0; i < int(index.size()); ++i) {
    14561462          index[i]->read(ls, edge);
    14571463        }
    … …  
    15641570    ///
    15651571    /// Add a node reader command for the NodeReader.
    1566     void readNode(const std::string& name, Node& item) {
    1567       if (readers.find(name) != readers.end()) {
     1572    void readNode(std::string label, Node& item) {
     1573      if (readers.find(label) != readers.end()) {
    15681574        ErrorMessage msg;
    1569         msg << "Multiple read rule for node: " << name;
     1575        msg << "Multiple read rule for node: " << label;
    15701576        throw IoParameterError(msg.message());
    15711577      }
    1572       readers.insert(make_pair(name, _reader_bits::ItemStore<Node>(item)));
     1578      readers.insert(make_pair(label, _reader_bits::ItemStore<Node>(item)));
    15731579    }
    15741580
    … …  
    16771683    ///
    16781684    /// Add an edge reader command for the EdgeReader.
    1679     void readEdge(const std::string& name, Edge& item) {
    1680       if (readers.find(name) != readers.end()) {
     1685    void readEdge(std::string label, Edge& item) {
     1686      if (readers.find(label) != readers.end()) {
    16811687        ErrorMessage msg;
    1682         msg << "Multiple read rule for edge: " << name;
     1688        msg << "Multiple read rule for edge: " << label;
    16831689        throw IoParameterError(msg.message());
    16841690      }
    1685       readers.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
     1691      readers.insert(make_pair(label, _reader_bits::ItemStore<Edge>(item)));
    16861692    }
    16871693
    … …  
    17951801    ///
    17961802    /// Add an undirected edge reader command for the UEdgeReader.
    1797     void readUEdge(const std::string& name, UEdge& item) {
    1798       if (uEdgeReaders.find(name) != uEdgeReaders.end()) {
     1803    void readUEdge(std::string label, UEdge& item) {
     1804      if (uEdgeReaders.find(label) != uEdgeReaders.end()) {
    17991805        ErrorMessage msg;
    1800         msg << "Multiple read rule for undirected edge: " << name;
     1806        msg << "Multiple read rule for undirected edge: " << label;
    18011807        throw IoParameterError(msg.message());
    18021808      }
    1803       uEdgeReaders.insert(make_pair(name, _reader_bits::
     1809      uEdgeReaders.insert(make_pair(label, _reader_bits::
    18041810                                        ItemStore<UEdge>(item)));
    18051811    }
    … …  
    18081814    ///
    18091815    /// Add an edge reader command for the UEdgeReader.
    1810     void readEdge(const std::string& name, Edge& item) {
    1811       if (edgeReaders.find(name) != edgeReaders.end()) {
     1816    void readEdge(std::string label, Edge& item) {
     1817      if (edgeReaders.find(label) != edgeReaders.end()) {
    18121818        ErrorMessage msg;
    1813         msg << "Multiple read rule for edge: " << name;
     1819        msg << "Multiple read rule for edge: " << label;
    18141820        throw IoParameterError(msg.message());
    18151821      }
    1816       edgeReaders.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
     1822      edgeReaders.insert(make_pair(label, _reader_bits::ItemStore<Edge>(item)));
    18171823    }
    18181824
    … …  
    19541960    ///
    19551961    /// Add an attribute reader command for the reader.
    1956     template <typename Reader, typename Value>
    1957     AttributeReader& readAttribute(const std::string& name, Value& value,
    1958                                    const Reader& reader = Reader()) {
    1959       checkConcept<_reader_bits::ItemReader<Value>, Reader>();
    1960       if (readers.find(name) != readers.end()) {
     1962    template <typename ItemReader, typename Value>
     1963    AttributeReader& readAttribute(std::string label, Value& value,
     1964                                   const ItemReader& ir = ItemReader()) {
     1965      checkConcept<_reader_bits::ItemReader<Value>, ItemReader>();
     1966      if (readers.find(label) != readers.end()) {
    19611967        ErrorMessage msg;
    1962         msg << "Multiple read rule for attribute: " << name;
     1968        msg << "Multiple read rule for attribute: " << label;
    19631969        throw IoParameterError(msg.message());
    19641970      }
    1965       readers.insert(make_pair(name, new _reader_bits::
    1966                                ValueReader<Value, Reader>(value, reader)));
     1971      readers.insert(make_pair(label, new _reader_bits::
     1972                               ValueReader<Value, ItemReader>(value, ir)));
    19671973      return *this;
    19681974    }

  • lemon/lemon_writer.h

    r2282 r2386  
    473473    /// Add a new node map writer command for the writer.
    474474    template <typename Map>
    475     NodeSetWriter& writeNodeMap(std::string name, const Map& map) {
     475    NodeSetWriter& writeNodeMap(std::string label, const Map& map) {
    476476      return writeNodeMap<typename Traits::
    477         template Writer<typename Map::Value>, Map>(name, map);
     477        template Writer<typename Map::Value>, Map>(label, map);
    478478    }
    479479
    … …  
    481481    ///
    482482    /// Add a new node map writer command for the writer.
    483     template <typename Writer, typename Map>
    484     NodeSetWriter& writeNodeMap(std::string name, const Map& map,
    485                             const Writer& writer = Writer()) {
     483    template <typename ItemWriter, typename Map>
     484    NodeSetWriter& writeNodeMap(std::string label, const Map& map,
     485                            const ItemWriter& iw = ItemWriter()) {
    486486      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
    487       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
     487      checkConcept<_writer_bits::ItemWriter<typename Map::Value>,ItemWriter>();
    488488      writers.push_back(
    489         make_pair(name, new _writer_bits::
    490                   MapWriter<Node, Map, Writer>(map, writer)));
     489        make_pair(label, new _writer_bits::
     490                  MapWriter<Node, Map, ItemWriter>(map, iw)));
    491491      return *this;
    492492    }
    … …  
    505505    /// Write the content of the section.
    506506    virtual void write(std::ostream& os) {
    507       for (int i = 0; i < (int)writers.size(); ++i) {
     507      for (int i = 0; i < int(writers.size()); ++i) {
    508508        if (writers[i].first == "label") {
    509509          labelMap = writers[i].second;
    … …  
    529529        os << "label\t";
    530530      }
    531       for (int i = 0; i < (int)writers.size(); ++i) {
     531      for (int i = 0; i < int(writers.size()); ++i) {
    532532        os << writers[i].first << '\t';
    533533      }
    … …  
    538538          os << graph.id(*it) << '\t';
    539539        }
    540         for (int i = 0; i < (int)writers.size(); ++i) {
     540        for (int i = 0; i < int(writers.size()); ++i) {
    541541          writers[i].second->write(os, *it);
    542542          os << '\t';
    … …  
    662662    /// Add a new edge map writer command for the writer.
    663663    template <typename Map>
    664     EdgeSetWriter& writeEdgeMap(std::string name, const Map& map) {
     664    EdgeSetWriter& writeEdgeMap(std::string label, const Map& map) {
    665665      return writeEdgeMap<typename Traits::
    666         template Writer<typename Map::Value>, Map>(name, map);
     666        template Writer<typename Map::Value>, Map>(label, map);
    667667    }
    668668
    … …  
    670670    ///
    671671    /// Add a new edge map writer command for the writer.
    672     template <typename Writer, typename Map>
    673     EdgeSetWriter& writeEdgeMap(std::string name, const Map& map,
    674                             const Writer& writer = Writer()) {
     672    template <typename ItemWriter, typename Map>
     673    EdgeSetWriter& writeEdgeMap(std::string label, const Map& map,
     674                            const ItemWriter& iw = ItemWriter()) {
    675675      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
    676       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
     676      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, ItemWriter>();
    677677      writers.push_back(
    678         make_pair(name, new _writer_bits::
    679                   MapWriter<Edge, Map, Writer>(map, writer)));
     678        make_pair(label, new _writer_bits::
     679                  MapWriter<Edge, Map, ItemWriter>(map, iw)));
    680680      return *this;
    681681    }
    … …  
    697697        throw DataFormatError("Cannot find nodeset or label map");
    698698      }
    699       for (int i = 0; i < (int)writers.size(); ++i) {
     699      for (int i = 0; i < int(writers.size()); ++i) {
    700700        if (writers[i].first == "label") {
    701701          labelMap = writers[i].second;
    … …  
    722722        os << "label\t";
    723723      }
    724       for (int i = 0; i < (int)writers.size(); ++i) {
     724      for (int i = 0; i < int(writers.size()); ++i) {
    725725        os << writers[i].first << '\t';
    726726      }
    … …  
    735735          os << graph.id(*it) << '\t';
    736736        }
    737         for (int i = 0; i < (int)writers.size(); ++i) {
     737        for (int i = 0; i < int(writers.size()); ++i) {
    738738          writers[i].second->write(os, *it);
    739739          os << '\t';
    … …  
    868868    /// Add a new undirected map writer command for the writer.
    869869    template <typename Map>
    870     UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map) {
     870    UEdgeSetWriter& writeUEdgeMap(std::string label, const Map& map) {
    871871      return writeUEdgeMap<typename Traits::
    872         template Writer<typename Map::Value>, Map>(name, map);
     872        template Writer<typename Map::Value>, Map>(label, map);
    873873    }
    874874
    … …  
    876876    ///
    877877    /// Add a new undirected map writer command for the writer.
    878     template <typename Writer, typename Map>
    879     UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map,
    880                                   const Writer& writer = Writer()) {
     878    template <typename ItemWriter, typename Map>
     879    UEdgeSetWriter& writeUEdgeMap(std::string label, const Map& map,
     880                                  const ItemWriter& iw = ItemWriter()) {
    881881      checkConcept<concepts::ReadMap<UEdge, typename Map::Value>, Map>();
    882       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
     882      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, ItemWriter>();
    883883      writers.push_back(
    884         make_pair(name, new _writer_bits::
    885                   MapWriter<UEdge, Map, Writer>(map, writer)));
     884        make_pair(label, new _writer_bits::
     885                  MapWriter<UEdge, Map, ItemWriter>(map, iw)));
    886886      return *this;
    887887    }
    … …  
    891891    /// Add a new directed map writer command for the writer.
    892892    template <typename Map>
    893     UEdgeSetWriter& writeEdgeMap(std::string name, const Map& map) {
     893    UEdgeSetWriter& writeEdgeMap(std::string label, const Map& map) {
    894894      return writeEdgeMap<typename Traits::
    895         template Writer<typename Map::Value>, Map>(name, map);
     895        template Writer<typename Map::Value>, Map>(label, map);
    896896    }
    897897
    … …  
    899899    ///
    900900    /// Add a new directed map writer command for the writer.
    901     template <typename Writer, typename Map>
    902     UEdgeSetWriter& writeEdgeMap(std::string name, const Map& map,
    903                                  const Writer& writer = Writer()) {
     901    template <typename ItemWriter, typename Map>
     902    UEdgeSetWriter& writeEdgeMap(std::string label, const Map& map,
     903                                 const ItemWriter& iw = ItemWriter()) {
    904904      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
    905       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
     905      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, ItemWriter>();
    906906      writeUEdgeMap("+" + name,
    907                     _writer_bits::forwardComposeMap(graph, map), writer);
     907                    _writer_bits::forwardComposeMap(graph, map), iw);
    908908      writeUEdgeMap("-" + name,
    909                     _writer_bits::backwardComposeMap(graph, map), writer);
     909                    _writer_bits::backwardComposeMap(graph, map), iw);
    910910      return *this;
    911911    }
    … …  
    927927        throw DataFormatError("Cannot find nodeset or label map");
    928928      }
    929       for (int i = 0; i < (int)writers.size(); ++i) {
     929      for (int i = 0; i < int(writers.size()); ++i) {
    930930        if (writers[i].first == "label") {
    931931          labelMap = writers[i].second;
    … …  
    952952        os << "label\t";
    953953      }
    954       for (int i = 0; i < (int)writers.size(); ++i) {
     954      for (int i = 0; i < int(writers.size()); ++i) {
    955955        os << writers[i].first << '\t';
    956956      }
    … …  
    965965          os << graph.id(*it) << '\t';
    966966        }
    967         for (int i = 0; i < (int)writers.size(); ++i) {
     967        for (int i = 0; i < int(writers.size()); ++i) {
    968968          writers[i].second->write(os, *it);
    969969          os << '\t';
    … …  
    10811081    ///
    10821082    /// Add a node writer command for the NodeWriter.
    1083     void writeNode(const std::string& name, const Node& item) {
    1084       writers.push_back(make_pair(name, &item));
     1083    void writeNode(std::string label, const Node& item) {
     1084      writers.push_back(make_pair(label, &item));
    10851085    }
    10861086
    … …  
    11011101        throw DataFormatError("Cannot find nodeset or label map");
    11021102      }
    1103       for (int i = 0; i < (int)writers.size(); ++i) {
     1103      for (int i = 0; i < int(writers.size()); ++i) {
    11041104        os << writers[i].first << ' ';
    11051105        labelWriter->write(os, *(writers[i].second));
    … …  
    11651165    ///
    11661166    /// Add an edge writer command for the EdgeWriter.
    1167     void writeEdge(const std::string& name, const Edge& item) {
    1168       writers.push_back(make_pair(name, &item));
     1167    void writeEdge(std::string label, const Edge& item) {
     1168      writers.push_back(make_pair(label, &item));
    11691169    }
    11701170
    … …  
    11851185        throw DataFormatError("Cannot find edgeset or label map");
    11861186      }
    1187       for (int i = 0; i < (int)writers.size(); ++i) {
     1187      for (int i = 0; i < int(writers.size()); ++i) {
    11881188        os << writers[i].first << ' ';
    11891189        labelWriter->write(os, *(writers[i].second));
    … …  
    12571257    ///
    12581258    /// Add an edge writer command for the UEdgeWriter.
    1259     void writeEdge(const std::string& name, const Edge& item) {
    1260       edgeWriters.push_back(make_pair(name, &item));
     1259    void writeEdge(std::string label, const Edge& item) {
     1260      edgeWriters.push_back(make_pair(label, &item));
    12611261    }
    12621262
    … …  
    12641264    ///
    12651265    /// Add an undirected edge writer command for the UEdgeWriter.
    1266     void writeUEdge(const std::string& name, const UEdge& item) {
    1267       uEdgeWriters.push_back(make_pair(name, &item));
     1266    void writeUEdge(std::string label, const UEdge& item) {
     1267      uEdgeWriters.push_back(make_pair(label, &item));
    12681268    }
    12691269
    … …  
    12871287        throw DataFormatError("Cannot find undirected edgeset or label map");
    12881288      }
    1289       for (int i = 0; i < (int)uEdgeWriters.size(); ++i) {
     1289      for (int i = 0; i < int(uEdgeWriters.size()); ++i) {
    12901290        os << uEdgeWriters[i].first << ' ';
    12911291        uEdgeLabelWriter->write(os, *(uEdgeWriters[i].second));
    12921292        os << std::endl;
    12931293      }
    1294       for (int i = 0; i < (int)edgeWriters.size(); ++i) {
     1294      for (int i = 0; i < int(edgeWriters.size()); ++i) {
    12951295        os << edgeWriters[i].first << ' ';
    12961296        edgeLabelWriter->write(os, *(edgeWriters[i].second));
    … …  
    13641364    /// Add an attribute writer command for the writer.
    13651365    template <typename Value>
    1366     AttributeWriter& writeAttribute(const std::string& name,
     1366    AttributeWriter& writeAttribute(std::string label,
    13671367                                    const Value& value) {
    13681368      return
    … …  
    13731373    ///
    13741374    /// Add an attribute writer command for the writer.
    1375     template <typename Writer, typename Value>
    1376     AttributeWriter& writeAttribute(const std::string& name,
    1377                                     const Value& value,
    1378                                     const Writer& writer = Writer()) {
    1379       checkConcept<_writer_bits::ItemWriter<Value>, Writer>();
    1380       writers.push_back(make_pair(name, new _writer_bits::
    1381                                   ValueWriter<Value, Writer>(value, writer)));
     1375    template <typename ItemWriter, typename Value>
     1376    AttributeWriter& writeAttribute(std::string label, const Value& value,
     1377                                    const ItemWriter& iw = ItemWriter()) {
     1378      checkConcept<_writer_bits::ItemWriter<Value>, ItemWriter>();
     1379      writers.push_back(make_pair(label, new _writer_bits::
     1380                                  ValueWriter<Value, ItemWriter>(value, iw)));
    13821381      return *this;
    13831382    }

  • lemon/list_graph.h

    r2381 r2386  
    523523        }
    524524        virtual void erase(const std::vector<Node>& nodes) {
    525           for (int i = 0; i < (int)nodes.size(); ++i) {
     525          for (int i = 0; i < int(nodes.size()); ++i) {
    526526            snapshot.eraseNode(nodes[i]);
    527527          }
    528528        }
    529529        virtual void build() {
    530           NodeNotifier* _notifier = notifier();
    531530          Node node;
    532531          std::vector<Node> nodes;
    533           for (_notifier->first(node); node != INVALID;
    534                _notifier->next(node)) {
     532          for (notifier()->first(node); node != INVALID;
     533               notifier()->next(node)) {
    535534            nodes.push_back(node);
    536535          }
    … …  
    540539        }
    541540        virtual void clear() {
    542           NodeNotifier* _notifier = notifier();
    543541          Node node;
    544           for (_notifier->first(node); node != INVALID;
    545                _notifier->next(node)) {
     542          for (notifier()->first(node); node != INVALID;
     543               notifier()->next(node)) {
    546544            snapshot.eraseNode(node);
    547545          }
    … …  
    575573        }
    576574        virtual void erase(const std::vector<Edge>& edges) {
    577           for (int i = 0; i < (int)edges.size(); ++i) {
     575          for (int i = 0; i < int(edges.size()); ++i) {
    578576            snapshot.eraseEdge(edges[i]);
    579577          }
    580578        }
    581579        virtual void build() {
    582           EdgeNotifier* _notifier = notifier();
    583580          Edge edge;
    584581          std::vector<Edge> edges;
    585           for (_notifier->first(edge); edge != INVALID;
    586                _notifier->next(edge)) {
     582          for (notifier()->first(edge); edge != INVALID;
     583               notifier()->next(edge)) {
    587584            edges.push_back(edge);
    588585          }
    … …  
    592589        }
    593590        virtual void clear() {
    594           EdgeNotifier* _notifier = notifier();
    595591          Edge edge;
    596           for (_notifier->first(edge); edge != INVALID; _notifier->next(edge)) {
     592          for (notifier()->first(edge); edge != INVALID;
     593               notifier()->next(edge)) {
    597594            snapshot.eraseEdge(edge);
    598595          }
    … …  
    12701267        }
    12711268        virtual void erase(const std::vector<Node>& nodes) {
    1272           for (int i = 0; i < (int)nodes.size(); ++i) {
     1269          for (int i = 0; i < int(nodes.size()); ++i) {
    12731270            snapshot.eraseNode(nodes[i]);
    12741271          }
    12751272        }
    12761273        virtual void build() {
    1277           NodeNotifier* _notifier = notifier();
    12781274          Node node;
    12791275          std::vector<Node> nodes;
    1280           for (_notifier->first(node); node != INVALID;
    1281                _notifier->next(node)) {
     1276          for (notifier()->first(node); node != INVALID;
     1277               notifier()->next(node)) {
    12821278            nodes.push_back(node);
    12831279          }
    … …  
    12871283        }
    12881284        virtual void clear() {
    1289           NodeNotifier* _notifier = notifier();
    12901285          Node node;
    1291           for (_notifier->first(node); node != INVALID;
    1292                _notifier->next(node)) {
     1286          for (notifier()->first(node); node != INVALID;
     1287               notifier()->next(node)) {
    12931288            snapshot.eraseNode(node);
    12941289          }
    … …  
    13221317        }
    13231318        virtual void erase(const std::vector<UEdge>& edges) {
    1324           for (int i = 0; i < (int)edges.size(); ++i) {
     1319          for (int i = 0; i < int(edges.size()); ++i) {
    13251320            snapshot.eraseUEdge(edges[i]);
    13261321          }
    13271322        }
    13281323        virtual void build() {
    1329           UEdgeNotifier* _notifier = notifier();
    13301324          UEdge edge;
    13311325          std::vector<UEdge> edges;
    1332           for (_notifier->first(edge); edge != INVALID;
    1333                _notifier->next(edge)) {
     1326          for (notifier()->first(edge); edge != INVALID;
     1327               notifier()->next(edge)) {
    13341328            edges.push_back(edge);
    13351329          }
    … …  
    13391333        }
    13401334        virtual void clear() {
    1341           UEdgeNotifier* _notifier = notifier();
    13421335          UEdge edge;
    1343           for (_notifier->first(edge); edge != INVALID;
    1344                _notifier->next(edge)) {
     1336          for (notifier()->first(edge); edge != INVALID;
     1337               notifier()->next(edge)) {
    13451338            snapshot.eraseUEdge(edge);
    13461339          }
    … …  
    15761569 
    15771570    void first(UEdge& edge) const {
    1578       int aNodeId = first_anode;
    1579       while (aNodeId != -1 && aNodes[aNodeId].first_edge == -1) {
    1580         aNodeId = aNodes[aNodeId].next != -1 ?
    1581           aNodes[aNodeId].next >> 1 : -1;
    1582       }
    1583       if (aNodeId != -1) {
    1584         edge.id = aNodes[aNodeId].first_edge;
     1571      int aid = first_anode;
     1572      while (aid != -1 && aNodes[aid].first_edge == -1) {
     1573        aid = aNodes[aid].next != -1 ?
     1574          aNodes[aid].next >> 1 : -1;
     1575      }
     1576      if (aid != -1) {
     1577        edge.id = aNodes[aid].first_edge;
    15851578      } else {
    15861579        edge.id = -1;
    … …  
    15881581    }
    15891582    void next(UEdge& edge) const {
    1590       int aNodeId = edges[edge.id].aNode >> 1;
     1583      int aid = edges[edge.id].aNode >> 1;
    15911584      edge.id = edges[edge.id].next_out;
    15921585      if (edge.id == -1) {
    1593         aNodeId = aNodes[aNodeId].next != -1 ?
    1594           aNodes[aNodeId].next >> 1 : -1;
    1595         while (aNodeId != -1 && aNodes[aNodeId].first_edge == -1) {
    1596           aNodeId = aNodes[aNodeId].next != -1 ?
    1597           aNodes[aNodeId].next >> 1 : -1;
    1598         }
    1599         if (aNodeId != -1) {
    1600           edge.id = aNodes[aNodeId].first_edge;
     1586        aid = aNodes[aid].next != -1 ?
     1587          aNodes[aid].next >> 1 : -1;
     1588        while (aid != -1 && aNodes[aid].first_edge == -1) {
     1589          aid = aNodes[aid].next != -1 ?
     1590          aNodes[aid].next >> 1 : -1;
     1591        }
     1592        if (aid != -1) {
     1593          edge.id = aNodes[aid].first_edge;
    16011594        } else {
    16021595          edge.id = -1;
    … …  
    16781671
    16791672    Node addANode() {
    1680       int aNodeId;
     1673      int aid;
    16811674      if (first_free_anode == -1) {
    1682         aNodeId = aNodes.size();
     1675        aid = aNodes.size();
    16831676        aNodes.push_back(NodeT());
    16841677      } else {
    1685         aNodeId = first_free_anode;
     1678        aid = first_free_anode;
    16861679        first_free_anode = aNodes[first_free_anode].next;
    16871680      }
    16881681      if (first_anode != -1) {
    1689         aNodes[aNodeId].next = first_anode << 1;
    1690         aNodes[first_anode].prev = aNodeId << 1;
    1691       } else {
    1692         aNodes[aNodeId].next = -1;
    1693       }
    1694       aNodes[aNodeId].prev = -1;
    1695       first_anode = aNodeId;
    1696       aNodes[aNodeId].first_edge = -1;
    1697       return Node(aNodeId << 1);
     1682        aNodes[aid].next = first_anode << 1;
     1683        aNodes[first_anode].prev = aid << 1;
     1684      } else {
     1685        aNodes[aid].next = -1;
     1686      }
     1687      aNodes[aid].prev = -1;
     1688      first_anode = aid;
     1689      aNodes[aid].first_edge = -1;
     1690      return Node(aid << 1);
    16981691    }
    16991692
    17001693    Node addBNode() {
    1701       int bNodeId;
     1694      int bid;
    17021695      if (first_free_bnode == -1) {
    1703         bNodeId = bNodes.size();
     1696        bid = bNodes.size();
    17041697        bNodes.push_back(NodeT());
    17051698      } else {
    1706         bNodeId = first_free_bnode;
     1699        bid = first_free_bnode;
    17071700        first_free_bnode = bNodes[first_free_bnode].next;
    17081701      }
    17091702      if (first_bnode != -1) {
    1710         bNodes[bNodeId].next = (first_bnode << 1) + 1;
    1711         bNodes[first_bnode].prev = (bNodeId << 1) + 1;
    1712       } else {
    1713         bNodes[bNodeId].next = -1;
    1714       }
    1715       bNodes[bNodeId].prev = -1;
    1716       first_bnode = bNodeId;
    1717       bNodes[bNodeId].first_edge = -1;
    1718       return Node((bNodeId << 1) + 1);
     1703        bNodes[bid].next = (first_bnode << 1) + 1;
     1704        bNodes[first_bnode].prev = (bid << 1) + 1;
     1705      } else {
     1706        bNodes[bid].next = -1;
     1707      }
     1708      bNodes[bid].prev = -1;
     1709      first_bnode = bid;
     1710      bNodes[bid].first_edge = -1;
     1711      return Node((bid << 1) + 1);
    17191712    }
    17201713
    … …  
    17531746    void erase(const Node& node) {
    17541747      if (aNode(node)) {
    1755         int aNodeId = node.id >> 1;
    1756         if (aNodes[aNodeId].prev != -1) {
    1757           aNodes[aNodes[aNodeId].prev >> 1].next = aNodes[aNodeId].next;
     1748        int aid = node.id >> 1;
     1749        if (aNodes[aid].prev != -1) {
     1750          aNodes[aNodes[aid].prev >> 1].next = aNodes[aid].next;
    17581751        } else {
    17591752          first_anode =
    1760             aNodes[aNodeId].next != -1 ? aNodes[aNodeId].next >> 1 : -1;
    1761         }
    1762         if (aNodes[aNodeId].next != -1) {
    1763           aNodes[aNodes[aNodeId].next >> 1].prev = aNodes[aNodeId].prev;
    1764         }
    1765         aNodes[aNodeId].next = first_free_anode;
    1766         first_free_anode = aNodeId;
    1767       } else {
    1768         int bNodeId = node.id >> 1;
    1769         if (bNodes[bNodeId].prev != -1) {
    1770           bNodes[bNodes[bNodeId].prev >> 1].next = bNodes[bNodeId].next;
     1753            aNodes[aid].next != -1 ? aNodes[aid].next >> 1 : -1;
     1754        }
     1755        if (aNodes[aid].next != -1) {
     1756          aNodes[aNodes[aid].next >> 1].prev = aNodes[aid].prev;
     1757        }
     1758        aNodes[aid].next = first_free_anode;
     1759        first_free_anode = aid;
     1760      } else {
     1761        int bid = node.id >> 1;
     1762        if (bNodes[bid].prev != -1) {
     1763          bNodes[bNodes[bid].prev >> 1].next = bNodes[bid].next;
    17711764        } else {
    17721765          first_bnode =
    1773             bNodes[bNodeId].next != -1 ? bNodes[bNodeId].next >> 1 : -1;
    1774         }
    1775         if (bNodes[bNodeId].next != -1) {
    1776           bNodes[bNodes[bNodeId].next >> 1].prev = bNodes[bNodeId].prev;
    1777         }
    1778         bNodes[bNodeId].next = first_free_bnode;
    1779         first_free_bnode = bNodeId;
     1766            bNodes[bid].next != -1 ? bNodes[bid].next >> 1 : -1;
     1767        }
     1768        if (bNodes[bid].next != -1) {
     1769          bNodes[bNodes[bid].next >> 1].prev = bNodes[bid].prev;
     1770        }
     1771        bNodes[bid].next = first_free_bnode;
     1772        first_free_bnode = bid;
    17801773      }
    17811774    }
    … …  
    20522045        }
    20532046        virtual void erase(const std::vector<Node>& nodes) {
    2054           for (int i = 0; i < (int)nodes.size(); ++i) {
     2047          for (int i = 0; i < int(nodes.size()); ++i) {
    20552048            snapshot.eraseNode(nodes[i]);
    20562049          }
    20572050        }
    20582051        virtual void build() {
    2059           NodeNotifier* _notifier = notifier();
    20602052          Node node;
    20612053          std::vector<Node> nodes;
    2062           for (_notifier->first(node); node != INVALID;
    2063                _notifier->next(node)) {
     2054          for (notifier()->first(node); node != INVALID;
     2055               notifier()->next(node)) {
    20642056            nodes.push_back(node);
    20652057          }
    … …  
    20692061        }
    20702062        virtual void clear() {
    2071           NodeNotifier* _notifier = notifier();
    20722063          Node node;
    2073           for (_notifier->first(node); node != INVALID;
    2074                _notifier->next(node)) {
     2064          for (notifier()->first(node); node != INVALID;
     2065               notifier()->next(node)) {
    20752066            snapshot.eraseNode(node);
    20762067          }
    … …  
    21042095        }
    21052096        virtual void erase(const std::vector<UEdge>& edges) {
    2106           for (int i = 0; i < (int)edges.size(); ++i) {
     2097          for (int i = 0; i < int(edges.size()); ++i) {
    21072098            snapshot.eraseUEdge(edges[i]);
    21082099          }
    21092100        }
    21102101        virtual void build() {
    2111           UEdgeNotifier* _notifier = notifier();
    21122102          UEdge edge;
    21132103          std::vector<UEdge> edges;
    2114           for (_notifier->first(edge); edge != INVALID;
    2115                _notifier->next(edge)) {
     2104          for (notifier()->first(edge); edge != INVALID;
     2105               notifier()->next(edge)) {
    21162106            edges.push_back(edge);
    21172107          }
    … …  
    21212111        }
    21222112        virtual void clear() {
    2123           UEdgeNotifier* _notifier = notifier();
    21242113          UEdge edge;
    2125           for (_notifier->first(edge); edge != INVALID;
    2126                _notifier->next(edge)) {
     2114          for (notifier()->first(edge); edge != INVALID;
     2115               notifier()->next(edge)) {
    21272116            snapshot.eraseUEdge(edge);
    21282117          }

  • lemon/lp_base.h

    r2370 r2386  
    200200  protected:
    201201
    202     int _lpId(const Col& col) const {
    203       return cols.floatingId(id(col));
    204     }
    205 
    206     int _lpId(const Row& row) const {
    207       return rows.floatingId(id(row));
    208     }
    209 
    210     Col _item(int id, Col) const {
    211       return Col(cols.fixId(id));
    212     }
    213 
    214     Row _item(int id, Row) const {
    215       return Row(rows.fixId(id));
     202    int _lpId(const Col& c) const {
     203      return cols.floatingId(id(c));
     204    }
     205
     206    int _lpId(const Row& r) const {
     207      return rows.floatingId(id(r));
     208    }
     209
     210    Col _item(int i, Col) const {
     211      return Col(cols.fixId(i));
     212    }
     213
     214    Row _item(int i, Row) const {
     215      return Row(rows.fixId(i));
    216216    }
    217217
    … …  
    892892    ///function. It is 0 by default.
    893893    ///\return The created column.
    894     Col addCol(const DualExpr &e, Value obj=0) {
     894    Col addCol(const DualExpr &e, Value o = 0) {
    895895      Col c=addCol();
    896896      col(c,e);
    897       objCoeff(c,obj);
     897      objCoeff(c,o);
    898898      return c;
    899899    }

  • lemon/lp_glpk.cc

    r2368 r2386  
    104104 
    105105  void LpGlpk::_eraseCol(int i) {
    106     int cols[2];
    107     cols[1]=i;
    108     lpx_del_cols(lp, 1, cols);
     106    int ca[2];
     107    ca[1]=i;
     108    lpx_del_cols(lp, 1, ca);
    109109  }
    110110 
    111111  void LpGlpk::_eraseRow(int i) {
    112     int rows[2];
    113     rows[1]=i;
    114     lpx_del_rows(lp, 1, rows);
    115   }
    116 
    117   void LpGlpk::_getColName(int col, std::string & name) const
    118   {
    119    
    120     char *n = lpx_get_col_name(lp,col);
     112    int ra[2];
     113    ra[1]=i;
     114    lpx_del_rows(lp, 1, ra);
     115  }
     116
     117  void LpGlpk::_getColName(int c, std::string & name) const
     118  {
     119   
     120    char *n = lpx_get_col_name(lp,c);
    121121    name = n?n:"";
    122122  }
    123123 
    124124 
    125   void LpGlpk::_setColName(int col, const std::string & name)
    126   {
    127     lpx_set_col_name(lp,col,const_cast<char*>(name.c_str()));
     125  void LpGlpk::_setColName(int c, const std::string & name)
     126  {
     127    lpx_set_col_name(lp,c,const_cast<char*>(name.c_str()));
    128128
    129129  }
    … …  
    152152  }
    153153
    154   void LpGlpk::_getRowCoeffs(int i, RowIterator b) const
    155   {
    156     int length = lpx_get_mat_row(lp, i, 0, 0);
     154  void LpGlpk::_getRowCoeffs(int ix, RowIterator b) const
     155  {
     156    int length = lpx_get_mat_row(lp, ix, 0, 0);
    157157   
    158158    std::vector<int> indices(length + 1);
    159159    std::vector<Value> values(length + 1);
    160160   
    161     lpx_get_mat_row(lp, i, &indices[0], &values[0]);
     161    lpx_get_mat_row(lp, ix, &indices[0], &values[0]);
    162162   
    163163    for (int i = 1; i <= length; ++i) {
    … …  
    167167  }
    168168 
    169   void LpGlpk::_setColCoeffs(int i, ConstColIterator b, ConstColIterator e) {
     169  void LpGlpk::_setColCoeffs(int ix, ConstColIterator b, ConstColIterator e) {
    170170
    171171    std::vector<int> indices;
    … …  
    180180    }
    181181   
    182     lpx_set_mat_col(lp, i, values.size() - 1, &indices[0], &values[0]);
    183   }
    184 
    185   void LpGlpk::_getColCoeffs(int i, ColIterator b) const
    186   {
    187     int length = lpx_get_mat_col(lp, i, 0, 0);
     182    lpx_set_mat_col(lp, ix, values.size() - 1, &indices[0], &values[0]);
     183  }
     184
     185  void LpGlpk::_getColCoeffs(int ix, ColIterator b) const
     186  {
     187    int length = lpx_get_mat_col(lp, ix, 0, 0);
    188188   
    189189    std::vector<int> indices(length + 1);
    190190    std::vector<Value> values(length + 1);
    191191   
    192     lpx_get_mat_col(lp, i, &indices[0], &values[0]);
     192    lpx_get_mat_col(lp, ix, &indices[0], &values[0]);
    193193   
    194194    for (int i = 1; i <= length; ++i) {
    … …  
    198198  }
    199199
    200   void LpGlpk::_setCoeff(int row, int col, Value value)
     200  void LpGlpk::_setCoeff(int ix, int jx, Value value)
    201201  {
    202202
    203203    if (lpx_get_num_cols(lp) < lpx_get_num_rows(lp)) {
    204204
    205       int length=lpx_get_mat_row(lp, row, 0, 0);
     205      int length=lpx_get_mat_row(lp, ix, 0, 0);
    206206     
    207207      std::vector<int> indices(length + 2);
    208208      std::vector<Value> values(length + 2);
    209209     
    210       lpx_get_mat_row(lp, row, &indices[0], &values[0]);
     210      lpx_get_mat_row(lp, ix, &indices[0], &values[0]);
    211211     
    212212      //The following code does not suppose that the elements of the
    … …  
    214214      bool found=false;
    215215      for (int i = 1; i <= length; ++i) {
    216         if (indices[i]==col){
     216        if (indices[i]==jx){
    217217          found=true;
    218218          values[i]=value;
    … …  
    222222      if (!found){
    223223        ++length;
    224         indices[length]=col;
     224        indices[length]=jx;
    225225        values[length]=value;
    226226      }
    227227   
    228       lpx_set_mat_row(lp, row, length, &indices[0], &values[0]);
     228      lpx_set_mat_row(lp, ix, length, &indices[0], &values[0]);
    229229
    230230    } else {
    231231
    232       int length=lpx_get_mat_col(lp, col, 0, 0);
     232      int length=lpx_get_mat_col(lp, jx, 0, 0);
    233233     
    234234      std::vector<int> indices(length + 2);
    235235      std::vector<Value> values(length + 2);
    236236     
    237       lpx_get_mat_col(lp, col, &indices[0], &values[0]);
     237      lpx_get_mat_col(lp, jx, &indices[0], &values[0]);
    238238     
    239239      //The following code does not suppose that the elements of the
    … …  
    241241      bool found=false;
    242242      for (int i = 1; i <= length; ++i) {
    243         if (indices[i]==col){
     243        if (indices[i]==jx){
    244244          found=true;
    245245          values[i]=value;
    … …  
    249249      if (!found){
    250250        ++length;
    251         indices[length]=row;
     251        indices[length]=ix;
    252252        values[length]=value;
    253253      }
    254254   
    255       lpx_set_mat_col(lp, col, length, &indices[0], &values[0]);
    256     }
    257   }
    258 
    259   LpGlpk::Value LpGlpk::_getCoeff(int row, int col) const
    260   {
    261 
    262     int length=lpx_get_mat_row(lp, row, 0, 0);
     255      lpx_set_mat_col(lp, jx, length, &indices[0], &values[0]);
     256    }
     257  }
     258
     259  LpGlpk::Value LpGlpk::_getCoeff(int ix, int jx) const
     260  {
     261
     262    int length=lpx_get_mat_row(lp, ix, 0, 0);
    263263   
    264264    std::vector<int> indices(length + 1);
    265265    std::vector<Value> values(length + 1);
    266266   
    267     lpx_get_mat_row(lp, row, &indices[0], &values[0]);
     267    lpx_get_mat_row(lp, ix, &indices[0], &values[0]);
    268268   
    269269    //The following code does not suppose that the elements of the
    270270    //array indices are sorted
    271271    for (int i = 1; i <= length; ++i) {
    272       if (indices[i]==col){
     272      if (indices[i]==jx){
    273273        return values[i];
    274274      }

  • lemon/lp_soplex.cc

    r2368 r2386  
    4545  LpSolverBase &LpSoplex::_copyLp() {
    4646    LpSoplex* newlp = new LpSoplex();
    47     ((soplex::SPxLP&)*(newlp->soplex)) = *soplex;
     47    (*static_cast<soplex::SPxLP*>(newlp->soplex)) = *soplex;
    4848    return *newlp;
    4949  }
    5050
    5151  int LpSoplex::_addCol() {
    52     soplex::LPCol col;
    53     col.setLower(-soplex::infinity);
    54     col.setUpper(soplex::infinity);
    55     soplex->addCol(col);
     52    soplex::LPCol c;
     53    c.setLower(-soplex::infinity);
     54    c.setUpper(soplex::infinity);
     55    soplex->addCol(c);
    5656
    5757    colNames.push_back(std::string());
    … …  
    6363
    6464  int LpSoplex::_addRow() {
    65     soplex::LPRow row;
    66     row.setLhs(-soplex::infinity);
    67     row.setRhs(soplex::infinity);
    68     soplex->addRow(row);
     65    soplex::LPRow r;
     66    r.setLhs(-soplex::infinity);
     67    r.setRhs(soplex::infinity);
     68    soplex->addRow(r);
    6969
    7070    dual_value.push_back(0.0);
    … …  
    9393  }
    9494 
    95   void LpSoplex::_getColName(int col, std::string &name) const {
    96     name = colNames[col];
    97   }
    98  
    99   void LpSoplex::_setColName(int col, const std::string &name) {
    100     invColNames.erase(colNames[col]);
    101     colNames[col] = name;
     95  void LpSoplex::_getColName(int c, std::string &name) const {
     96    name = colNames[c];
     97  }
     98 
     99  void LpSoplex::_setColName(int c, const std::string &name) {
     100    invColNames.erase(colNames[c]);
     101    colNames[c] = name;
    102102    if (!name.empty()) {
    103       invColNames.insert(std::make_pair(name, col));
     103      invColNames.insert(std::make_pair(name, c));
    104104    }
    105105  }

  • lemon/matrix_maps.h

    r2384 r2386  
    350350
    351351    virtual void add(const Key& key) {
    352       if (size(Parent::notifier()->id(key) + 1) >= (int)values.size()) {
     352      if (size(Parent::notifier()->id(key) + 1) >= int(values.size())) {
    353353        values.resize(size(Parent::notifier()->id(key) + 1));   
    354354      }
    … …  
    357357    virtual void add(const std::vector<Key>& keys) {
    358358      int new_size = 0;
    359       for (int i = 0; i < (int)keys.size(); ++i) {
     359      for (int i = 0; i < int(keys.size()); ++i) {
    360360        if (size(Parent::notifier()->id(keys[i]) + 1) >= new_size) {
    361361          new_size = size(Parent::notifier()->id(keys[i]) + 1);
    362362        }
    363363      }
    364       if (new_size > (int)values.size()) {
     364      if (new_size > int(values.size())) {
    365365        values.resize(new_size);
    366366      }
    … …  
    505505
    506506    virtual void add(const Key& key) {
    507       if (size(Parent::notifier()->id(key) + 1) >= (int)values.size()) {
     507      if (size(Parent::notifier()->id(key) + 1) >= int(values.size())) {
    508508        values.resize(size(Parent::notifier()->id(key) + 1));   
    509509      }
    … …  
    512512    virtual void add(const std::vector<Key>& keys) {
    513513      int new_size = 0;
    514       for (int i = 0; i < (int)keys.size(); ++i) {
     514      for (int i = 0; i < int(keys.size()); ++i) {
    515515        if (size(Parent::notifier()->id(keys[i]) + 1) >= new_size) {
    516516          new_size = size(Parent::notifier()->id(keys[i]) + 1);
    517517        }
    518518      }
    519       if (new_size > (int)values.size()) {
     519      if (new_size > int(values.size())) {
    520520        values.resize(new_size);
    521521      }
    … …  
    916916    ///class belongs to the FirstKey type.
    917917    void addFirstKey(const FirstKey& firstKey) {
    918       int size = (int)values.size();
     918      int size = int(values.size());
    919919      if( _first_key_proxy.notifier()->id(firstKey)+1 >= size ){
    920920        values.resize(_first_key_proxy.notifier()->id(firstKey)+1);
    921         if( (int)values[0].size() != 0 ){
    922           int innersize = (int)values[0].size();
    923           for(int i=size; i!=(int)values.size();++i){
     921        if( int(values[0].size()) != 0 ){
     922          int innersize = int(values[0].size());
     923          for(int i = size; i < int(values.size());++i){
    924924            (values[i]).resize(innersize);
    925925          }
    926926        }else if(_second_key_proxy.notifier()->maxId() >= 0){
    927927          int innersize = _second_key_proxy.notifier()->maxId();
    928           for(int i = 0; i != (int)values.size(); ++i){
     928          for(int i = 0; i < int(values.size()); ++i){
    929929            values[0].resize(innersize);
    930930          }
    … …  
    939939    void addFirstKeys(const std::vector<FirstKey>& firstKeys){
    940940      int max = values.size() - 1;
    941       for(int i=0; i != (int)firstKeys.size(); ++i){
     941      for(int i = 0; i < int(firstKeys.size()); ++i){
    942942        int id = _first_key_proxy.notifier()->id(firstKeys[i]);
    943943        if(max < id){
    … …  
    945945        }
    946946      }
    947       int size = (int)values.size();
     947      int size = int(values.size());
    948948      if(max >= size){
    949949        values.resize(max + 1);
    950         if( (int)values[0].size() != 0){
    951           int innersize = (int)values[0].size();
    952           for(int i = size; i != (max + 1); ++i){
     950        if( int(values[0].size()) != 0){
     951          int innersize = int(values[0].size());
     952          for(int i = size; i < (max + 1); ++i){
    953953            values[i].resize(innersize);
    954954          }
    955955        }else if(_second_key_proxy.notifier()->maxId() >= 0){
    956956          int innersize = _second_key_proxy.notifier()->maxId();
    957           for(int i = 0; i != (int)values.size(); ++i){
     957          for(int i = 0; i < int(values.size()); ++i){
    958958            values[i].resize(innersize);
    959959          }
    … …  
    971971      }
    972972      int id = _second_key_proxy.notifier()->id(secondKey);
    973       if(id >= (int)values[0].size()){
    974         for(int i=0;i!=(int)values.size();++i){
     973      if(id >= int(values[0].size())){
     974        for(int i = 0; i < int(values.size());++i){
    975975          values[i].resize(id+1);
    976976        }
    … …  
    987987      }
    988988      int max = values[0].size();
    989       for(int i = 0; i != (int)secondKeys.size(); ++i){
     989      for(int i = 0; i < int(secondKeys.size()); ++i){
    990990        int id = _second_key_proxy.notifier()->id(secondKeys[i]);
    991991        if(max < id){
    … …  
    993993        }
    994994      }
    995       if(max > (int)values[0].size()){
    996         for(int i = 0; i != (int)values.size(); ++i){
     995      if(max > int(values[0].size())){
     996        for(int i = 0; i < int(values.size()); ++i){
    997997          values[i].resize(max + 1);
    998998        }
    … …  
    10061006    void eraseFirstKey(const FirstKey& first) {
    10071007      int id = _first_key_proxy.notifier()->id(first);
    1008       for(int i = 0; i != (int)values[id].size(); ++i){
     1008      for(int i = 0; i < int(values[id].size()); ++i){
    10091009        values[id][i] = Value();
    10101010      }
    … …  
    10161016    ///class belongs to the FirstKey type.
    10171017    void eraseFirstKeys(const std::vector<FirstKey>& firstKeys) {
    1018       for(int j = 0; j != (int)firstKeys.size(); ++j){
     1018      for(int j = 0; j < int(firstKeys.size()); ++j){
    10191019        int id = _first_key_proxy.notifier()->id(firstKeys[j]);
    1020         for(int i = 0; i != (int)values[id].size(); ++i){
     1020        for(int i = 0; i < int(values[id].size()); ++i){
    10211021          values[id][i] = Value();
    10221022        }
    … …  
    10331033      }
    10341034      int id = _second_key_proxy.notifier()->id(second);
    1035       for(int i = 0; i != (int)values.size(); ++i){
     1035      for(int i = 0; i < int(values.size()); ++i){
    10361036        values[i][id] = Value();
    10371037      }
    … …  
    10461046        return;
    10471047      }
    1048       for(int j = 0; j != (int)secondKeys.size(); ++j){
     1048      for(int j = 0; j < int(secondKeys.size()); ++j){
    10491049        int id = _second_key_proxy.notifier()->id(secondKeys[j]);
    1050         for(int i = 0; i != (int)values.size(); ++i){
     1050        for(int i = 0; i < int(values.size()); ++i){
    10511051          values[i][id] = Value();
    10521052        }
    … …  
    10601060    void build() {
    10611061      values.resize(_first_key_proxy.notifier()->maxId());
    1062       for(int i=0; i!=(int)values.size(); ++i){
     1062      for(int i = 0; i< int(values.size()); ++i){
    10631063        values[i].resize(_second_key_proxy.notifier()->maxId());
    10641064      }
    … …  
    10701070    ///belongs to the FirstKey or SecondKey type.
    10711071    void clear() {
    1072       for(int i=0; i!=(int)values.size(); ++i) {
     1072      for(int i = 0; i < int(values.size()); ++i) {
    10731073        values[i].clear();
    10741074      }

  • lemon/max_matching.h

    r2308 r2386  
    356356  template <typename Graph>
    357357  void MaxMatching<Graph>::lateShrink(Node v, typename Graph::template
    358                                       NodeMap<Node>& ear, UFE& blossom, UFE& tree) {
     358                                      NodeMap<Node>& ear, UFE& blossom,
     359                                      UFE& tree) {
    359360    //We have one tree which we grow, and also shrink but only if it cannot be
    360361    //postponed. If we augment then we return to the "for" cycle of
    … …  
    373374        //growOrAugment grows if y is covered by the matching and
    374375        //augments if not. In this latter case it returns 1.
    375         if ( position[y]==C && growOrAugment(y, x, ear, blossom, tree, Q) ) return;
     376        if ( position[y]==C && growOrAugment(y, x, ear, blossom, tree, Q) )
     377          return;
    376378      }
    377379      R.push(x);
    … …  
    390392       
    391393        while ( !Q.empty() ) {
    392           Node x=Q.front();
     394          Node z=Q.front();
    393395          Q.pop();
    394           for( IncEdgeIt e(g,x); e!= INVALID; ++e ) {
    395             Node y=g.runningNode(e);
     396          for( IncEdgeIt f(g,z); f!= INVALID; ++f ) {
     397            Node w=g.runningNode(f);
    396398            //growOrAugment grows if y is covered by the matching and
    397399            //augments if not. In this latter case it returns 1.
    398             if ( position[y]==C && growOrAugment(y, x, ear, blossom, tree, Q) ) return;
     400            if ( position[w]==C && growOrAugment(w, z, ear, blossom, tree, Q) )
     401              return;
    399402          }
    400           R.push(x);
     403          R.push(z);
    401404        }
    402405      } //for e

  • lemon/nagamochi_ibaraki.h

    r2376 r2386  
    439439    /// automatically allocated map, of course.
    440440    /// \return <tt> (*this) </tt>
    441     MaxCardinalitySearch &heap(Heap& heap, HeapCrossRef &crossRef) {
     441    MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) {
    442442      if(local_heap_cross_ref) {
    443443        delete _heap_cross_ref;
    444444        local_heap_cross_ref = false;
    445445      }
    446       _heap_cross_ref = &crossRef;
     446      _heap_cross_ref = &cr;
    447447      if(local_heap) {
    448448        delete _heap;
    449449        local_heap = false;
    450450      }
    451       _heap = &heap;
     451      _heap = &hp;
    452452      return *this;
    453453    }
    … …  
    11691169    /// automatically allocated heap and cross reference, of course.
    11701170    /// \return <tt> (*this) </tt>
    1171     NagamochiIbaraki &heap(Heap& heap, HeapCrossRef &crossRef)
     1171    NagamochiIbaraki &heap(Heap& hp, HeapCrossRef &cr)
    11721172    {
    11731173      if (local_heap_cross_ref) {
    … …  
    11751175        local_heap_cross_ref=false;
    11761176      }
    1177       _heap_cross_ref = &crossRef;
     1177      _heap_cross_ref = &cr;
    11781178      if (local_heap) {
    11791179        delete _heap;
    11801180        local_heap=false;
    11811181      }
    1182       _heap = &heap;
     1182      _heap = &hp;
    11831183      return *this;
    11841184    }
    … …  
    13191319      }
    13201320
    1321       if ((int)nodes.size() < _node_num) {
     1321      if (int(nodes.size()) < _node_num) {
    13221322        _aux_graph->clear();
    13231323        _node_num = 1;
    13241324        _cut.clear();
    1325         for (int i = 0; i < (int)nodes.size(); ++i) {
     1325        for (int i = 0; i < int(nodes.size()); ++i) {
    13261326          typename Graph::Node n = (*_first)[nodes[i]];
    13271327          while (n != INVALID) {
    … …  
    13611361      }
    13621362
    1363       if (ufe.size((typename Ufe::ClassIt)(ufe)) == _node_num) {
     1363      typedef typename Ufe::ClassIt UfeCIt;
     1364      if (ufe.size(UfeCIt(ufe)) == _node_num) {
    13641365        _aux_graph->clear();
    13651366        _node_num = 1;
    … …  
    13731374        if (ufe.size(c) == 1) continue;
    13741375        for (typename Ufe::ItemIt r(ufe, c); r != INVALID; ++r) {
    1375           if ((Node)r == (Node)c) continue;
     1376          if (static_cast<Node>(r) == static_cast<Node>(c)) continue;
    13761377          _next->set((*_last)[c], (*_first)[r]);
    13771378          _last->set(c, (*_last)[r]);
    … …  
    14081409      }
    14091410
    1410       for (int i = 0; i < (int)remedges.size(); ++i) {
     1411      for (int i = 0; i < int(remedges.size()); ++i) {
    14111412        _aux_graph->erase(remedges[i]);
    14121413      }
    … …  
    14161417      {
    14171418        int i = 0;
    1418         while (i < (int)addedges.size()) {
     1419        while (i < int(addedges.size())) {
    14191420          Node sn = addedges[i].source;
    14201421          Node tn = addedges[i].target;
    14211422          Value ec = addedges[i].capacity;
    14221423          ++i;
    1423           while (i < (int)addedges.size() &&
     1424          while (i < int(addedges.size()) &&
    14241425                 sn == addedges[i].source && tn == addedges[i].target) {
    14251426            ec += addedges[i].capacity;
    … …  
    14431444      }
    14441445
    1445       for (int i = 0; i < (int)remnodes.size(); ++i) {
     1446      for (int i = 0; i < int(remnodes.size()); ++i) {
    14461447        _aux_graph->erase(remnodes[i]);
    14471448      }
    … …  
    15011502    template <typename NodeMap>
    15021503    Value quickMinCut(NodeMap& nodeMap) const {
    1503       for (int i = 0; i < (int)_cut.size(); ++i) {
     1504      for (int i = 0; i < int(_cut.size()); ++i) {
    15041505        nodeMap.set(_cut[i], true);
    15051506      }

  • lemon/path.h

    r2357 r2386  
    141141    /// \pre n is in the [0..length() - 1] range
    142142    const Edge& nth(int n) const {
    143       return n < (int)head.size() ? *(head.rbegin() + n) :
     143      return n < int(head.size()) ? *(head.rbegin() + n) :
    144144        *(tail.begin() + (n - head.size()));
    145145    }

  • lemon/polynomial.h

    r2207 r2386  
    5151    template<class U> Polynomial(const Polynomial<U> &u) : _coeff(u.deg()+1)
    5252    {
    53       for(int i=0;i<(int)_coeff.size();i++) _coeff[i]=u[i];
     53      for(int i=0;i<int(_coeff.size());i++) _coeff[i]=u[i];
    5454    }
    5555    ///Query the degree of the polynomial.
    … …  
    112112    Polynomial &derivateMyself()
    113113    {
    114       for(int i=1;i<(int)_coeff.size();i++) _coeff[i-1]=i*_coeff[i];
     114      for(int i=1;i<int(_coeff.size());i++) _coeff[i-1]=i*_coeff[i];
    115115      _coeff.pop_back();
    116116      return *this;
    … …  
    121121    {
    122122      Polynomial tmp(deg()-1);
    123       for(int i=1;i<(int)_coeff.size();i++) tmp[i-1]=i*_coeff[i];
     123      for(int i=1;i<int(_coeff.size());i++) tmp[i-1]=i*_coeff[i];
    124124      return tmp;
    125125    }
    … …  
    139139      Polynomial tmp(deg()+1);
    140140      tmp[0]=0;
    141       for(int i=0;i<(int)_coeff.size();i++) tmp[i+1]=_coeff[i]/(i+1);
     141      for(int i=0;i<int(_coeff.size());i++) tmp[i+1]=_coeff[i]/(i+1);
    142142      return tmp;
    143143    }
    … …  
    148148    {
    149149      if(p.deg()>deg()) _coeff.resize(p.deg()+1);
    150       for(int i=0;i<=(int)std::min(deg(),p.deg());i++)
     150      for(int i=0;i<=int(std::min(deg(),p.deg()));i++)
    151151        _coeff[i]+=p[i];
    152152      return *this;

  • lemon/preflow.h

    r2376 r2386  
    235235    void phase1()
    236236    {
    237       int heur0=(int)(H0*_node_num);  //time while running 'bound decrease'
    238       int heur1=(int)(H1*_node_num);  //time while running 'highest label'
     237      int heur0=int(H0*_node_num);  //time while running 'bound decrease'
     238      int heur1=int(H1*_node_num);  //time while running 'highest label'
    239239      int heur=heur1;         //starting time interval (#of relabels)
    240240      int numrelabel=0;

  • lemon/radix_heap.h

    r2263 r2386  
    151151  private:
    152152
    153     bool upper(int box, Prio prio) {
    154       return prio < boxes[box].min;
    155     }
    156 
    157     bool lower(int box, Prio prio) {
    158       return prio >= boxes[box].min + boxes[box].size;
     153    bool upper(int box, Prio pr) {
     154      return pr < boxes[box].min;
     155    }
     156
     157    bool lower(int box, Prio pr) {
     158      return pr >= boxes[box].min + boxes[box].size;
    159159    }
    160160
    … …  
    188188    void extend() {
    189189      int min = boxes.back().min + boxes.back().size;
    190       int size = 2 * boxes.back().size;
    191       boxes.push_back(RadixBox(min, size));
     190      int bs = 2 * boxes.back().size;
     191      boxes.push_back(RadixBox(min, bs));
    192192    }
    193193
    … …  
    201201
    202202    /// \brief Find up the proper box for the item with the given prio.
    203     int findUp(int start, int prio) {
    204       while (lower(start, prio)) {
    205         if (++start == (int)boxes.size()) {
     203    int findUp(int start, int pr) {
     204      while (lower(start, pr)) {
     205        if (++start == int(boxes.size())) {
    206206          extend();
    207207        }
    … …  
    219219
    220220    /// \brief Find up the proper box for the item with the given prio.
    221     int findDown(int start, int prio) {
    222       while (upper(start, prio)) {
     221    int findDown(int start, int pr) {
     222      while (upper(start, pr)) {
    223223        if (--start < 0) throw UnderFlowPriorityError();
    224224      }
    … …  
    261261
    262262    void relocate_last(int index) {
    263       if (index != (int)data.size() - 1) {
     263      if (index != int(data.size()) - 1) {
    264264        data[index] = data.back();
    265265        if (data[index].prev != -1) {

  • lemon/radix_sort.h

    r2084 r2386  
    265265                       int byte, Functor functor) {
    266266    const int size =
    267       (unsigned int)std::numeric_limits<unsigned char>::max() + 1;
     267      unsigned(std::numeric_limits<unsigned char>::max()) + 1;
    268268    std::vector<int> counter(size);
    269269    for (int i = 0; i < size; ++i) {
    … …  
    291291                             int byte, Functor functor) {
    292292    const int size =
    293       (unsigned int)std::numeric_limits<unsigned char>::max() + 1;
     293      unsigned(std::numeric_limits<unsigned char>::max()) + 1;
    294294    std::vector<int> counter(size);
    295295    for (int i = 0; i < size; ++i) {
    … …  
    331331      bool dir = true;
    332332      std::copy(first, last, buffer);
    333       for (int i = 0; i < (int)sizeof(Value) - 1; ++i) {
     333      for (int i = 0; i < int(sizeof(Value)) - 1; ++i) {
    334334        if (dir) {
    335335          counterIntroSort(buffer, buffer + length, buffer + length,
    … …  
    369369      bool dir = true;
    370370      std::copy(first, last, buffer);
    371       for (int i = 0; i < (int)sizeof(Value); ++i) {
     371      for (int i = 0; i < int(sizeof(Value)); ++i) {
    372372        if (dir) {
    373373          counterIntroSort(buffer, buffer + length,

  • lemon/random.h

    r2380 r2386  
    122122      static const int shift = 156;
    123123
    124       static const Word mul = (Word)0x5851F42Du << 32 | (Word)0x4C957F2Du;
    125       static const Word arrayInit = (Word)0x00000000u << 32 |(Word)0x012BD6AAu;
    126       static const Word arrayMul1 = (Word)0x369DEA0Fu << 32 |(Word)0x31A53F85u;
    127       static const Word arrayMul2 = (Word)0x27BB2EE6u << 32 |(Word)0x87B0B0FDu;
    128 
    129       static const Word mask = (Word)0xB5026F5Au << 32 | (Word)0xA96619E9u;
    130       static const Word loMask = ((Word)1u << 31) - 1;
     124      static const Word mul = Word(0x5851F42Du) << 32 | Word(0x4C957F2Du);
     125      static const Word arrayInit = Word(0x00000000u) << 32 |Word(0x012BD6AAu);
     126      static const Word arrayMul1 = Word(0x369DEA0Fu) << 32 |Word(0x31A53F85u);
     127      static const Word arrayMul2 = Word(0x27BB2EE6u) << 32 |Word(0x87B0B0FDu);
     128
     129      static const Word mask = Word(0xB5026F5Au) << 32 | Word(0xA96619E9u);
     130      static const Word loMask = (Word(1u) << 31) - 1;
    131131      static const Word hiMask = ~loMask;
    132132
    133133      static Word tempering(Word rnd) {
    134         rnd ^= (rnd >> 29) & ((Word)0x55555555u << 32 | (Word)0x55555555u);
    135         rnd ^= (rnd << 17) & ((Word)0x71D67FFFu << 32 | (Word)0xEDA60000u);
    136         rnd ^= (rnd << 37) & ((Word)0xFFF7EEE0u << 32 | (Word)0x00000000u);
     134        rnd ^= (rnd >> 29) & (Word(0x55555555u) << 32 | Word(0x55555555u));
     135        rnd ^= (rnd << 17) & (Word(0x71D67FFFu) << 32 | Word(0xEDA60000u));
     136        rnd ^= (rnd << 37) & (Word(0xFFF7EEE0u) << 32 | Word(0x00000000u));
    137137        rnd ^= (rnd >> 43);
    138138        return rnd;
    … …  
    217217        }
    218218       
    219         state[length - 1] = (Word)1 << (bits - 1);
     219        state[length - 1] = Word(1) << (bits - 1);
    220220      }
    221221     
    … …  
    274274      static Result mask(const Result& result) {
    275275        return Masker<Result, (shift + 1) / 2>::
    276           mask((Result)(result | (result >> shift)));
     276          mask(static_cast<Result>(result | (result >> shift)));
    277277      }
    278278    };
    … …  
    281281    struct Masker<Result, 1> {
    282282      static Result mask(const Result& result) {
    283         return (Result)(result | (result >> 1));
     283        return static_cast<Result>(result | (result >> 1));
    284284      }
    285285    };
    … …  
    292292   
    293293      static Result convert(RandomCore<Word>& rnd) {
    294         return (Result)(rnd() >> (bits - rest)) << shift;
     294        return static_cast<Result>(rnd() >> (bits - rest)) << shift;
    295295      }
    296296     
    … …  
    302302
    303303      static Result convert(RandomCore<Word>& rnd) {
    304         return ((Result)rnd() << shift) |
     304        return (static_cast<Result>(rnd()) << shift) |
    305305          IntConversion<Result, Word, rest - bits, shift + bits>::convert(rnd);
    306306      }
    … …  
    313313    struct Mapping {
    314314      static Result map(RandomCore<Word>& rnd, const Result& bound) {
    315         Word max = (Word)(bound - 1);
     315        Word max = Word(bound - 1);
    316316        Result mask = Masker<Result>::mask(bound - 1);
    317317        Result num;
    … …  
    326326    struct Mapping<Result, Word, false> {
    327327      static Result map(RandomCore<Word>& rnd, const Result& bound) {
    328         Word max = (Word)(bound - 1);
     328        Word max = Word(bound - 1);
    329329        Word mask = Masker<Word, (std::numeric_limits<Result>::digits + 1) / 2>
    330330          ::mask(max);
    … …  
    342342        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
    343343        res *= res;
    344         if ((exp & 1) == 1) res *= (Result)2.0;
     344        if ((exp & 1) == 1) res *= static_cast<Result>(2.0);
    345345        return res;
    346346      }
    … …  
    352352        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
    353353        res *= res;
    354         if ((exp & 1) == 1) res *= (Result)0.5;
     354        if ((exp & 1) == 1) res *= static_cast<Result>(0.5);
    355355        return res;
    356356      }
    … …  
    360360    struct ShiftMultiplier<Result, 0, true> {
    361361      static const Result multiplier() {
    362         return (Result)1.0;
     362        return static_cast<Result>(1.0);
    363363      }
    364364    };
    … …  
    367367    struct ShiftMultiplier<Result, -20, true> {
    368368      static const Result multiplier() {
    369         return (Result)(1.0/1048576.0);
     369        return static_cast<Result>(1.0/1048576.0);
    370370      }
    371371    };
    … …  
    374374    struct ShiftMultiplier<Result, -32, true> {
    375375      static const Result multiplier() {
    376         return (Result)(1.0/424967296.0);
     376        return static_cast<Result>(1.0/424967296.0);
    377377      }
    378378    };
    … …  
    381381    struct ShiftMultiplier<Result, -53, true> {
    382382      static const Result multiplier() {
    383         return (Result)(1.0/9007199254740992.0);
     383        return static_cast<Result>(1.0/9007199254740992.0);
    384384      }
    385385    };
    … …  
    388388    struct ShiftMultiplier<Result, -64, true> {
    389389      static const Result multiplier() {
    390         return (Result)(1.0/18446744073709551616.0);
     390        return static_cast<Result>(1.0/18446744073709551616.0);
    391391      }
    392392    };
    … …  
    407407      static Result convert(RandomCore<Word>& rnd) {
    408408        return Shifting<Result, - shift - rest>::
    409           shift((Result)(rnd() >> (bits - rest)));
     409          shift(static_cast<Result>(rnd() >> (bits - rest)));
    410410      }
    411411    };
    … …  
    416416
    417417      static Result convert(RandomCore<Word>& rnd) {
    418         return Shifting<Result, - shift - bits>::shift((Result)rnd()) +
    419           RealConversion<Result, Word, rest-bits, shift + bits>::convert(rnd);
     418        return Shifting<Result, - shift - bits>::
     419          shift(static_cast<Result>(rnd())) +
     420          RealConversion<Result, Word, rest-bits, shift + bits>::
     421          convert(rnd);
    420422      }
    421423    };
    … …  
    428430        std::vector<Word> ws;
    429431        for (Iterator it = begin; it != end; ++it) {
    430           ws.push_back((Word)*it);
     432          ws.push_back(Word(*it));
    431433        }
    432434        rnd.initState(ws.begin(), ws.end());

  • lemon/smart_graph.h

    r2381 r2386  
    642642    void saveSnapshot(Snapshot &s)
    643643    {
    644       s.g = this;
     644      s.graph = this;
    645645      s.node_num = nodes.size();
    646646      s.edge_num = edges.size();
    … …  
    689689    class Snapshot
    690690    {
    691       SmartUGraph *g;
     691      SmartUGraph *graph;
    692692    protected:
    693693      friend class SmartUGraph;
    … …  
    700700      ///To actually make a snapshot you must call save().
    701701      ///
    702       Snapshot() : g(0) {}
     702      Snapshot() : graph(0) {}
    703703      ///Constructor that immediately makes a snapshot
    704704     
    … …  
    730730      void restore()
    731731      {
    732         g->restoreSnapshot(*this);
     732        graph->restoreSnapshot(*this);
    733733      }
    734734    };

  • lemon/steiner.h

    r2382 r2386  
    205205      {
    206206        int i = 0;
    207         while (i < (int)externals.size()) {
     207        while (i < int(externals.size())) {
    208208          int sn = externals[i].source;
    209209          int tn = externals[i].target;
    … …  
    211211          UEdge ee = externals[i].uedge;
    212212          ++i;
    213           while (i < (int)externals.size() &&
     213          while (i < int(externals.size()) &&
    214214                 sn == externals[i].source && tn == externals[i].target) {
    215215            if (externals[i].value < ev) {

  • lemon/ugraph_adaptor.h

    r2381 r2386  
    100100
    101101    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
    102     Edge findEdge(const Node& source, const Node& target,
     102    Edge findEdge(const Node& u, const Node& v,
    103103                  const Edge& prev = INVALID) {
    104       return graph->findEdge(source, target, prev);
    105     }
    106     UEdge findUEdge(const Node& source, const Node& target,
     104      return graph->findEdge(u, v, prev);
     105    }
     106    UEdge findUEdge(const Node& u, const Node& v,
    107107                    const UEdge& prev = INVALID) {
    108       return graph->findUEdge(source, target, prev);
     108      return graph->findUEdge(u, v, prev);
    109109    }
    110110 
    111111    Node addNode() const { return graph->addNode(); }
    112     UEdge addEdge(const Node& source, const Node& target) const {
    113       return graph->addEdge(source, target);
     112    UEdge addEdge(const Node& u, const Node& v) const {
     113      return graph->addEdge(u, v);
    114114    }
    115115
    … …  
    126126    int id(const UEdge& e) const { return graph->id(e); }
    127127
    128     Node fromNodeId(int id) const {
    129       return graph->fromNodeId(id);
    130     }
    131 
    132     Edge fromEdgeId(int id) const {
    133       return graph->fromEdgeId(id);
    134     }
    135 
    136     UEdge fromUEdgeId(int id) const {
    137       return graph->fromUEdgeId(id);
     128    Node fromNodeId(int ix) const {
     129      return graph->fromNodeId(ix);
     130    }
     131
     132    Edge fromEdgeId(int ix) const {
     133      return graph->fromEdgeId(ix);
     134    }
     135
     136    UEdge fromUEdgeId(int ix) const {
     137      return graph->fromUEdgeId(ix);
    138138    }
    139139
    … …  
    396396
    397397    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
    398     Edge findEdge(const Node& source, const Node& target,
     398    Edge findEdge(const Node& u, const Node& v,
    399399                  const Edge& prev = INVALID) {
    400       if (!(*node_filter_map)[source] || !(*node_filter_map)[target]) {
     400      if (!(*node_filter_map)[u] || !(*node_filter_map)[v]) {
    401401        return INVALID;
    402402      }
    403       Edge edge = Parent::findEdge(source, target, prev);
     403      Edge edge = Parent::findEdge(u, v, prev);
    404404      while (edge != INVALID && !(*uedge_filter_map)[edge]) {
    405         edge = Parent::findEdge(source, target, edge);
     405        edge = Parent::findEdge(u, v, edge);
    406406      }
    407407      return edge;
    408408    }
    409     UEdge findUEdge(const Node& source, const Node& target,
     409    UEdge findUEdge(const Node& u, const Node& v,
    410410                  const UEdge& prev = INVALID) {
    411       if (!(*node_filter_map)[source] || !(*node_filter_map)[target]) {
     411      if (!(*node_filter_map)[u] || !(*node_filter_map)[v]) {
    412412        return INVALID;
    413413      }
    414       UEdge uedge = Parent::findUEdge(source, target, prev);
     414      UEdge uedge = Parent::findUEdge(u, v, prev);
    415415      while (uedge != INVALID && !(*uedge_filter_map)[uedge]) {
    416         uedge = Parent::findUEdge(source, target, uedge);
     416        uedge = Parent::findUEdge(u, v, uedge);
    417417      }
    418418      return uedge;
    … …  
    429429                             template NodeMap<_Value> > Parent;
    430430   
    431       NodeMap(const Graph& graph)
    432         : Parent(graph) {}
    433       NodeMap(const Graph& graph, const _Value& value)
    434         : Parent(graph, value) {}
     431      NodeMap(const Graph& g)
     432        : Parent(g) {}
     433      NodeMap(const Graph& g, const _Value& v)
     434        : Parent(g, v) {}
    435435   
    436436      NodeMap& operator=(const NodeMap& cmap) {
    … …  
    455455                             template EdgeMap<_Value> > Parent;
    456456   
    457       EdgeMap(const Graph& graph)
    458         : Parent(graph) {}
    459       EdgeMap(const Graph& graph, const _Value& value)
    460         : Parent(graph, value) {}
     457      EdgeMap(const Graph& g)
     458        : Parent(g) {}
     459      EdgeMap(const Graph& g, const _Value& v)
     460        : Parent(g, v) {}
    461461   
    462462      EdgeMap& operator=(const EdgeMap& cmap) {
    … …  
    481481                             template UEdgeMap<_Value> > Parent;
    482482   
    483       UEdgeMap(const Graph& graph)
    484         : Parent(graph) {}
    485       UEdgeMap(const Graph& graph, const _Value& value)
    486         : Parent(graph, value) {}
     483      UEdgeMap(const Graph& g)
     484        : Parent(g) {}
     485      UEdgeMap(const Graph& g, const _Value& v)
     486        : Parent(g, v) {}
    487487   
    488488      UEdgeMap& operator=(const UEdgeMap& cmap) {
    … …  
    623623
    624624    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
    625     Edge findEdge(const Node& source, const Node& target,
     625    Edge findEdge(const Node& u, const Node& v,
    626626                  const Edge& prev = INVALID) {
    627       Edge edge = Parent::findEdge(source, target, prev);
     627      Edge edge = Parent::findEdge(u, v, prev);
    628628      while (edge != INVALID && !(*uedge_filter_map)[edge]) {
    629         edge = Parent::findEdge(source, target, edge);
     629        edge = Parent::findEdge(u, v, edge);
    630630      }
    631631      return edge;
    632632    }
    633     UEdge findUEdge(const Node& source, const Node& target,
     633    UEdge findUEdge(const Node& u, const Node& v,
    634634                  const UEdge& prev = INVALID) {
    635       UEdge uedge = Parent::findUEdge(source, target, prev);
     635      UEdge uedge = Parent::findUEdge(u, v, prev);
    636636      while (uedge != INVALID && !(*uedge_filter_map)[uedge]) {
    637         uedge = Parent::findUEdge(source, target, uedge);
     637        uedge = Parent::findUEdge(u, v, uedge);
    638638      }
    639639      return uedge;
    … …  
    650650                             template NodeMap<_Value> > Parent;
    651651   
    652       NodeMap(const Graph& graph)
    653         : Parent(graph) {}
    654       NodeMap(const Graph& graph, const _Value& value)
    655         : Parent(graph, value) {}
     652      NodeMap(const Graph& g)
     653        : Parent(g) {}
     654      NodeMap(const Graph& g, const _Value& v)
     655        : Parent(g, v) {}
    656656   
    657657      NodeMap& operator=(const NodeMap& cmap) {
    … …  
    676676                             template EdgeMap<_Value> > Parent;
    677677   
    678       EdgeMap(const Graph& graph)
    679         : Parent(graph) {}
    680       EdgeMap(const Graph& graph, const _Value& value)
    681         : Parent(graph, value) {}
     678      EdgeMap(const Graph& g)
     679        : Parent(g) {}
     680      EdgeMap(const Graph& g, const _Value& v)
     681        : Parent(g, v) {}
    682682   
    683683      EdgeMap& operator=(const EdgeMap& cmap) {
    … …  
    702702                             template UEdgeMap<_Value> > Parent;
    703703   
    704       UEdgeMap(const Graph& graph)
    705         : Parent(graph) {}
    706       UEdgeMap(const Graph& graph, const _Value& value)
    707         : Parent(graph, value) {}
     704      UEdgeMap(const Graph& g)
     705        : Parent(g) {}
     706      UEdgeMap(const Graph& g, const _Value& v)
     707        : Parent(g, v) {}
    708708   
    709709      UEdgeMap& operator=(const UEdgeMap& cmap) {
    … …  
    944944
    945945    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
    946     Edge findEdge(const Node& source, const Node& target,
     946    Edge findEdge(const Node& u, const Node& v,
    947947                  const Edge& prev = INVALID) {
    948948      Edge edge = prev;
    949949      bool d = edge == INVALID ? true : (*direction)[edge];
    950950      if (d) {
    951         edge = graph->findUEdge(source, target, edge);
     951        edge = graph->findUEdge(u, v, edge);
    952952        while (edge != INVALID && !(*direction)[edge]) {
    953           graph->findUEdge(source, target, edge);
     953          graph->findUEdge(u, v, edge);
    954954        }
    955955        if (edge != INVALID) return edge;
    956956      }
    957       graph->findUEdge(target, source, edge);
     957      graph->findUEdge(v, u, edge);
    958958      while (edge != INVALID && (*direction)[edge]) {
    959         graph->findUEdge(source, target, edge);
     959        graph->findUEdge(u, v, edge);
    960960      }
    961961      return edge;
    … …  
    966966    }
    967967
    968     Edge addEdge(const Node& source, const Node& target) const {
    969       Edge edge = graph->addEdge(source, target);
    970       direction->set(edge, graph->source(edge) == source);
     968    Edge addEdge(const Node& u, const Node& v) const {
     969      Edge edge = graph->addEdge(u, v);
     970      direction->set(edge, graph->source(edge) == u);
    971971      return edge;
    972972    }

  • lemon/unionfind.h

    r2332 r2386  
    409409          }
    410410     
    411           int idx = items[k].nextItem;
    412           while (idx != k) {
    413             items[idx].parent = nk;
    414             idx = items[idx].nextItem;
     411          int l = items[k].nextItem;
     412          while (l != k) {
     413            items[l].parent = nk;
     414            l = items[l].nextItem;
    415415          }
    416416         

  • test/all_pairs_shortest_path_test.cc

    r2335 r2386  
    4949
    5050  const int n = argc > 1 ? atoi(argv[1]) : 20;
    51   const int e = argc > 2 ? atoi(argv[2]) : (int)(n * log((double)n));
     51  const int e = argc > 2 ? atoi(argv[2]) : int(n * log(double(n)));
    5252  const int m = argc > 3 ? atoi(argv[3]) : 100;
    5353

  • test/arborescence_test.cc

    r2242 r2386  
    2020using namespace std;
    2121
    22 const int n = 10;
    23 const int e = 22;
     22const int NODES = 10;
     23const int EDGES = 22;
    2424
    2525int sourceNode = 0;
    2626
    27 int sources[e] = {
     27int sources[EDGES] = {
    2828  1, 0, 2, 4, 4, 3, 9, 8, 9, 8,
    2929  4, 2, 0, 6, 4, 1, 7, 2, 8, 6,
    … …  
    3131};
    3232
    33 int targets[e] = {
     33int targets[EDGES] = {
    3434  8, 3, 1, 1, 4, 9, 8, 1, 8, 0,
    3535  3, 2, 1, 3, 1, 1, 2, 6, 3, 9,
    … …  
    3737};
    3838
    39 double costs[e] = {
     39double costs[EDGES] = {
    4040  107.444, 70.3069, 46.0496, 28.3962, 91.4325,
    4141  76.9443, 61.986, 39.3754, 74.9575, 39.3153,
    … …  
    5757  vector<Node> nodes;
    5858 
    59   for (int i = 0; i < n; ++i) {
     59  for (int i = 0; i < NODES; ++i) {
    6060    nodes.push_back(graph.addNode());
    6161  }
    6262
    63   for (int i = 0; i < e; ++i) {
     63  for (int i = 0; i < EDGES; ++i) {
    6464    Edge edge = graph.addEdge(nodes[sources[i]], nodes[targets[i]]);
    6565    cost[edge] = costs[i];
    … …  
    8686    if (mca.reached(graph.source(it))) {
    8787      double sum = 0.0;
    88       for (int i = 0; i < (int)dualSolution.size(); ++i) {
     88      for (int i = 0; i < int(dualSolution.size()); ++i) {
    8989        if (dualSolution[i].second.find(graph.target(it))
    9090            != dualSolution[i].second.end() &&

  • test/bipartite_matching_test.cc

    r2137 r2386  
    2020BPUGRAPH_TYPEDEFS(Graph);
    2121
    22 const int n = 10;
    23 const int m = 10;
    24 const int e = 52;
    25 const int c = 100;
    26 
    27 const int sa[e] = { 6, 5, 6, 4, 1, 0, 9, 5, 2, 4, 4, 3, 5,
     22const int N = 10;
     23const int M = 10;
     24const int E = 52;
     25const int C = 100;
     26
     27const int sa[E] = { 6, 5, 6, 4, 1, 0, 9, 5, 2, 4, 4, 3, 5,
    2828                    2, 3, 8, 3, 4, 9, 6, 9, 4, 3, 1, 5, 8,
    2929                    4, 8, 9, 2, 2, 3, 0, 5, 2, 3, 6, 3, 8,
    3030                    8, 4, 0, 9, 9, 6, 2, 1, 2, 7, 1, 9, 4};
    3131
    32 const int ta[e] = { 2, 7, 4, 8, 6, 3, 4, 1, 7, 7, 0, 1, 6,
     32const int ta[E] = { 2, 7, 4, 8, 6, 3, 4, 1, 7, 7, 0, 1, 6,
    3333                    3, 2, 6, 8, 3, 5, 6, 3, 1, 8, 7, 2, 0,
    3434                    6, 9, 6, 7, 8, 3, 3, 4, 5, 8, 6, 4, 1,
    3535                    4, 3, 3, 8, 7, 7, 3, 7, 7, 3, 5, 1, 6};
    3636
    37 const int wa[e] = { 3, 99, 85, 16, 79, 52, 83, 99, 62, 6, 42, 6, 95,
     37const int wa[E] = { 3, 99, 85, 16, 79, 52, 83, 99, 62, 6, 42, 6, 95,
    3838                    13, 34, 9, 5, 38, 39, 75, 99, 12, 73, 35, 93, 43,
    3939                    54, 91, 45, 26, 77, 47, 11, 22, 50, 74, 37, 64, 91,
    … …  
    5353  int min_cost_matching;
    5454
    55   for (int i = 0; i < n; ++i) {
     55  for (int i = 0; i < N; ++i) {
    5656    Node node = graph.addANode();
    5757    aNodes.push_back(node);
    5858  }
    59   for (int i = 0; i < m; ++i) {
     59  for (int i = 0; i < M; ++i) {
    6060    Node node = graph.addBNode();
    6161    bNodes.push_back(node);
    6262  }
    63   for (int i = 0; i < e; ++i) {
     63  for (int i = 0; i < E; ++i) {
    6464    Node aNode = aNodes[sa[i]];
    6565    Node bNode = bNodes[ta[i]];
    … …  
    289289
    290290  Graph::UEdgeMap<int> cost(graph);
    291   cost = subMap(constMap<UEdge>(c), weight);
     291  cost = subMap(constMap<UEdge>(C), weight);
    292292  {
    293293
    … …  
    304304    min_cost_matching = bpmatch.matchingCost();
    305305    check(max_cardinality == bpmatch.matchingSize(), "WRONG SIZE");
    306     check(max_cardinality * c - max_cardinality_max_weight
     306    check(max_cardinality * C - max_cardinality_max_weight
    307307          == bpmatch.matchingCost(), "WRONG SIZE");
    308308
    … …  
    327327    min_cost_matching = bpmatch.matchingCost();
    328328    check(max_cardinality == bpmatch.matchingSize(), "WRONG SIZE");
    329     check(max_cardinality * c - max_cardinality_max_weight
     329    check(max_cardinality * C - max_cardinality_max_weight
    330330          == bpmatch.matchingCost(), "WRONG SIZE");
    331331

  • test/lp_test.cc

    r2369 r2386  
    262262
    263263  if (stat ==  LpSolverBase::OPTIMAL) {
    264     std::ostringstream buf;
    265     buf << "Wrong optimal value: the right optimum is " << exp_opt;
    266     check(std::abs(lp.primalValue()-exp_opt) < 1e-3, buf.str());
     264    std::ostringstream sbuf;
     265    sbuf << "Wrong optimal value: the right optimum is " << exp_opt;
     266    check(std::abs(lp.primalValue()-exp_opt) < 1e-3, sbuf.str());
    267267    //+ecvt(exp_opt,2)
    268268  }

  • test/map_test.h

    r1956 r2386  
    4646    typedef typename Graph::template NodeMap<int> IntNodeMap;
    4747    IntNodeMap map(graph, 42);
    48     for (int i = 0; i < (int)nodes.size(); ++i) {
     48    for (int i = 0; i < int(nodes.size()); ++i) {
    4949      check(map[nodes[i]] == 42, "Wrong map constructor.");     
    5050    }
    … …  
    5454    }
    5555    map = constMap<Node>(12);
    56     for (int i = 0; i < (int)nodes.size(); ++i) {
     56    for (int i = 0; i < int(nodes.size()); ++i) {
    5757      check(map[nodes[i]] == 12, "Wrong map constructor.");     
    5858    }   
    … …  
    8484    IntEdgeMap map(graph, 42);
    8585   
    86     for (int i = 0; i < (int)edges.size(); ++i) {
     86    for (int i = 0; i < int(edges.size()); ++i) {
    8787      check(map[edges[i]] == 42, "Wrong map constructor.");     
    8888    }
    … …  
    9595    }
    9696    map = constMap<Edge>(12);
    97     for (int i = 0; i < (int)edges.size(); ++i) {
     97    for (int i = 0; i < int(edges.size()); ++i) {
    9898      check(map[edges[i]] == 12, "Wrong map constructor.");     
    9999    }   

  • test/max_matching_test.cc

    r2116 r2386  
    7575    if ( mate[v]!=INVALID ) ++s;
    7676  }
    77   int size=(int)s/2;  //size will be used as the size of a maxmatching
     77  int size=int(s/2);  //size will be used as the size of a maxmatching
    7878
    7979  for(NodeIt v(g); v!=INVALID; ++v) {
    … …  
    9393    if ( mate[v]!=INVALID ) ++s;
    9494  }
    95   check ( (int)s/2 == size, "The size does not equal!" );
     95  check ( int(s/2) == size, "The size does not equal!" );
    9696
    9797  Graph::NodeMap<MaxMatching<Graph>::pos_enum> pos1(g);
    … …  
    104104    if ( mate[v]!=INVALID ) ++s;
    105105  }
    106   check ( (int)s/2 == size, "The size does not equal!" );
     106  check ( int(s/2) == size, "The size does not equal!" );
    107107 
    108108  Graph::NodeMap<MaxMatching<Graph>::pos_enum> pos2(g);
    … …  
    116116    if ( mate[v]!=INVALID ) ++s;
    117117  }
    118   check ( (int)s/2 == size, "The size does not equal!" );
     118  check ( int(s/2) == size, "The size does not equal!" );
    119119 
    120120  Graph::NodeMap<MaxMatching<Graph>::pos_enum> pos(g);
    … …  
    177177    if ( pos[v]==max_matching.A ) ++barrier;
    178178  }
    179   int expected_size=(int)( countNodes(g)-num_comp+barrier)/2;
     179  int expected_size=int( countNodes(g)-num_comp+barrier)/2;
    180180  check ( size==expected_size, "The size of the matching is wrong." );
    181181 

  • test/mip_test.cc

    r2369 r2386  
    3131
    3232  if (stat ==  MipSolverBase::OPTIMAL) {
    33     std::ostringstream buf;
     33    std::ostringstream sbuf;
    3434    buf << "Wrong optimal value: the right optimum is " << exp_opt;
    35     check(std::abs(lp.primalValue()-exp_opt) < 1e-3, buf.str());
     35    check(std::abs(lp.primalValue()-exp_opt) < 1e-3, sbuf.str());
    3636    //+ecvt(exp_opt,2)
    3737  }

  • test/radix_sort_test.cc

    r2242 r2386  
    3333using namespace lemon;
    3434
     35typedef unsigned char uchar;
     36
    3537void checkRadixSort() {
    3638  {
    … …  
    4951    vector<unsigned char> data1(n), data2(n);
    5052    for (int i = 0; i < n; ++i) {
    51       data1[i] = data2[i] = rnd[(unsigned char)200];
     53      data1[i] = data2[i] = rnd[uchar(200)];
    5254    }
    5355    radixSort(data1.begin(), data1.end());
    … …  
    7678    vector<unsigned char> data1(n), data2(n);
    7779    for (int i = 0; i < n; ++i) {
    78       data1[i] = data2[i] = rnd[(unsigned char)200];
     80      data1[i] = data2[i] = rnd[uchar(200)];
    7981    }
    8082    counterSort(data1.begin(), data1.end());
    … …  
    9799
    98100  const int n = 100;
    99   const int e = (int)(n * log((double)n));
     101  const int e = int(n * log(double(n)));
    100102
    101103  Graph graph;
    … …  
    118120  Graph::EdgeMap<bool> was(graph, false);
    119121
    120   for (int i = 0; i < (int)edges.size(); ++i) {
     122  for (int i = 0; i < int(edges.size()); ++i) {
    121123    check(!was[edges[i]], "Test failed");
    122124    was[edges[i]] = true;
    123125  }
    124126
    125   for (int i = 1; i < (int)edges.size(); ++i) {
     127  for (int i = 1; i < int(edges.size()); ++i) {
    126128    check(graph.id(graph.source(edges[i - 1])) <=
    127129          graph.id(graph.source(edges[i])), "Test failed");
    … …  
    136138
    137139  const int n = 100;
    138   const int e = (int)(n * log((double)n));
     140  const int e = int(n * log(double(n)));
    139141
    140142  Graph graph;
    … …  
    161163  Graph::EdgeMap<bool> was(graph, false);
    162164
    163   for (int i = 0; i < (int)edges.size(); ++i) {
     165  for (int i = 0; i < int(edges.size()); ++i) {
    164166    check(!was[edges[i]], "Test failed");
    165167    was[edges[i]] = true;
    166168  }
    167169
    168   for (int i = 1; i < (int)edges.size(); ++i) {
     170  for (int i = 1; i < int(edges.size()); ++i) {
    169171    check(graph.id(graph.target(edges[i - 1])) <
    170172          graph.id(graph.target(edges[i])) ||
Note: See TracChangeset for help on using the changeset viewer.