COIN-OR::LEMON - Graph Library

Changeset 2386:81b47fc5c444 in lemon-0.x


Ignore:
Timestamp:
03/02/07 19:04:28 (12 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