COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [1082:cae19e9eeca4:1086:97f1760dcd13] in lemon-main


Ignore:
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • lemon/concept_check.h

    r997 r1083  
    5959#if !defined(NDEBUG)
    6060    void (Concept::*x)() = & Concept::constraints;
    61     ignore_unused_variable_warning(x);
     61    ::lemon::ignore_unused_variable_warning(x);
    6262#endif
    6363  }
    … …  
    6969    typedef typename Concept::template Constraints<Type> ConceptCheck;
    7070    void (ConceptCheck::*x)() = & ConceptCheck::constraints;
    71     ignore_unused_variable_warning(x);
     71    ::lemon::ignore_unused_variable_warning(x);
    7272#endif
    7373  }

  • lemon/concepts/digraph.h

    r1049 r1086  
    313313        /// Sets the iterator to the first arc of the given digraph.
    314314        ///
    315         explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
     315        explicit ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); }
    316316        /// Sets the iterator to the given arc.
    317317

  • lemon/concepts/graph.h

    r1049 r1086  
    397397        /// Sets the iterator to the first arc of the given graph.
    398398        ///
    399         explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
     399        explicit ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); }
    400400        /// Sets the iterator to the given arc.
    401401
    … …  
    443443        ///
    444444        OutArcIt(const Graph& n, const Node& g) {
    445           ignore_unused_variable_warning(n);
    446           ignore_unused_variable_warning(g);
     445          ::lemon::ignore_unused_variable_warning(n);
     446          ::lemon::ignore_unused_variable_warning(g);
    447447        }
    448448        /// Sets the iterator to the given arc.
    … …  
    491491        ///
    492492        InArcIt(const Graph& g, const Node& n) {
    493           ignore_unused_variable_warning(n);
    494           ignore_unused_variable_warning(g);
     493          ::lemon::ignore_unused_variable_warning(n);
     494          ::lemon::ignore_unused_variable_warning(g);
    495495        }
    496496        /// Sets the iterator to the given arc.

  • lemon/concepts/graph_components.h

    r1049 r1086  
    109109
    110110          bool b;
    111           ignore_unused_variable_warning(b);
     111          ::lemon::ignore_unused_variable_warning(b);
    112112
    113113          b = (ia == ib) && (ia != ib);
    … …  
    290290            ue = e;
    291291            bool d = graph.direction(e);
    292             ignore_unused_variable_warning(d);
     292            ::lemon::ignore_unused_variable_warning(d);
    293293          }
    294294        }
    … …  
    535535
    536536          nid = digraph.maxNodeId();
    537           ignore_unused_variable_warning(nid);
     537          ::lemon::ignore_unused_variable_warning(nid);
    538538          eid = digraph.maxArcId();
    539           ignore_unused_variable_warning(eid);
     539          ::lemon::ignore_unused_variable_warning(eid);
    540540        }
    541541
    … …  
    590590          edge = graph.edgeFromId(ueid);
    591591          ueid = graph.maxEdgeId();
    592           ignore_unused_variable_warning(ueid);
     592          ::lemon::ignore_unused_variable_warning(ueid);
    593593        }
    594594
    … …  
    727727          _GraphItemIt it3 = it1;
    728728          _GraphItemIt it4 = INVALID;
    729           ignore_unused_variable_warning(it3);
    730           ignore_unused_variable_warning(it4);
     729          ::lemon::ignore_unused_variable_warning(it3);
     730          ::lemon::ignore_unused_variable_warning(it4);
    731731
    732732          it2 = ++it1;
    … …  
    818818          _GraphIncIt it3 = it1;
    819819          _GraphIncIt it4 = INVALID;
    820           ignore_unused_variable_warning(it3);
    821           ignore_unused_variable_warning(it4);
     820          ::lemon::ignore_unused_variable_warning(it3);
     821          ::lemon::ignore_unused_variable_warning(it4);
    822822
    823823          it2 = ++it1;
    … …  
    10011001            n = digraph.baseNode(oait);
    10021002            n = digraph.runningNode(oait);
    1003             ignore_unused_variable_warning(n);
     1003            ::lemon::ignore_unused_variable_warning(n);
    10041004          }
    10051005        }
    … …  
    12781278            = digraph.notifier(typename _Digraph::Arc());
    12791279
    1280           ignore_unused_variable_warning(nn);
    1281           ignore_unused_variable_warning(en);
     1280          ::lemon::ignore_unused_variable_warning(nn);
     1281          ::lemon::ignore_unused_variable_warning(en);
    12821282        }
    12831283
    … …  
    13261326          typename _Graph::EdgeNotifier& uen
    13271327            = graph.notifier(typename _Graph::Edge());
    1328           ignore_unused_variable_warning(uen);
     1328          ::lemon::ignore_unused_variable_warning(uen);
    13291329        }
    13301330
    … …  
    14621462          // m3 = cmap;
    14631463
    1464           ignore_unused_variable_warning(m1);
    1465           ignore_unused_variable_warning(m2);
    1466           // ignore_unused_variable_warning(m3);
     1464          ::lemon::ignore_unused_variable_warning(m1);
     1465          ::lemon::ignore_unused_variable_warning(m2);
     1466          // ::lemon::ignore_unused_variable_warning(m3);
    14671467        }
    14681468

  • lemon/concepts/heap.h

    r976 r1084  
    261261          item=Item();
    262262          prio=Prio();
    263           ignore_unused_variable_warning(item);
    264           ignore_unused_variable_warning(prio);
     263          ::lemon::ignore_unused_variable_warning(item);
     264          ::lemon::ignore_unused_variable_warning(prio);
    265265
    266266          OwnItem own_item;
    … …  
    269269          own_item=Item();
    270270          own_prio=Prio();
    271           ignore_unused_variable_warning(own_item);
    272           ignore_unused_variable_warning(own_prio);
    273           ignore_unused_variable_warning(own_state);
     271          ::lemon::ignore_unused_variable_warning(own_item);
     272          ::lemon::ignore_unused_variable_warning(own_prio);
     273          ::lemon::ignore_unused_variable_warning(own_state);
    274274
    275275          _Heap heap1(map);
    276276          _Heap heap2 = heap1;
    277           ignore_unused_variable_warning(heap1);
    278           ignore_unused_variable_warning(heap2);
     277          ::lemon::ignore_unused_variable_warning(heap1);
     278          ::lemon::ignore_unused_variable_warning(heap2);
    279279
    280280          int s = heap.size();
    281           ignore_unused_variable_warning(s);
     281          ::lemon::ignore_unused_variable_warning(s);
    282282          bool e = heap.empty();
    283           ignore_unused_variable_warning(e);
     283          ::lemon::ignore_unused_variable_warning(e);
    284284
    285285          prio = heap.prio();

  • lemon/concepts/maps.h

    r997 r1083  
    6161          own_val = m[own_key];
    6262
    63           ignore_unused_variable_warning(key);
    64           ignore_unused_variable_warning(val);
    65           ignore_unused_variable_warning(own_key);
    66           ignore_unused_variable_warning(own_val);
     63          ::lemon::ignore_unused_variable_warning(key);
     64          ::lemon::ignore_unused_variable_warning(val);
     65          ::lemon::ignore_unused_variable_warning(own_key);
     66          ::lemon::ignore_unused_variable_warning(own_val);
    6767        }
    6868        const Key& key;
    … …  
    101101          m.set(own_key, own_val);
    102102
    103           ignore_unused_variable_warning(key);
    104           ignore_unused_variable_warning(val);
    105           ignore_unused_variable_warning(own_key);
    106           ignore_unused_variable_warning(own_val);
     103          ::lemon::ignore_unused_variable_warning(key);
     104          ::lemon::ignore_unused_variable_warning(val);
     105          ::lemon::ignore_unused_variable_warning(own_key);
     106          ::lemon::ignore_unused_variable_warning(own_val);
    107107        }
    108108        const Key& key;

  • lemon/concepts/path.h

    r976 r1084  
    7676      template <typename CPath>
    7777      Path& operator=(const CPath& cpath) {
    78         ignore_unused_variable_warning(cpath);
     78        ::lemon::ignore_unused_variable_warning(cpath);
    7979        return *this;
    8080      }
    … …  
    136136          e = (i < ii);
    137137
    138           ignore_unused_variable_warning(l);
    139           ignore_unused_variable_warning(pp);
    140           ignore_unused_variable_warning(e);
    141           ignore_unused_variable_warning(id);
    142           ignore_unused_variable_warning(ii);
    143           ignore_unused_variable_warning(ed);
     138          ::lemon::ignore_unused_variable_warning(l);
     139          ::lemon::ignore_unused_variable_warning(pp);
     140          ::lemon::ignore_unused_variable_warning(e);
     141          ::lemon::ignore_unused_variable_warning(id);
     142          ::lemon::ignore_unused_variable_warning(ii);
     143          ::lemon::ignore_unused_variable_warning(ed);
    144144        }
    145145      };
    … …  
    163163          e = (i != INVALID);
    164164
    165           ignore_unused_variable_warning(l);
    166           ignore_unused_variable_warning(e);
    167           ignore_unused_variable_warning(id);
    168           ignore_unused_variable_warning(ed);
     165          ::lemon::ignore_unused_variable_warning(l);
     166          ::lemon::ignore_unused_variable_warning(e);
     167          ::lemon::ignore_unused_variable_warning(id);
     168          ::lemon::ignore_unused_variable_warning(ed);
    169169        }
    170170        _Path& p;
    … …  
    189189          e = (i != INVALID);
    190190
    191           ignore_unused_variable_warning(l);
    192           ignore_unused_variable_warning(e);
    193           ignore_unused_variable_warning(id);
    194           ignore_unused_variable_warning(ed);
     191          ::lemon::ignore_unused_variable_warning(l);
     192          ::lemon::ignore_unused_variable_warning(e);
     193          ::lemon::ignore_unused_variable_warning(id);
     194          ::lemon::ignore_unused_variable_warning(ed);
    195195        }
    196196        _Path& p;

  • test/adaptors_test.cc

    r998 r1084  
    6666  Digraph::Arc a2 = digraph.addArc(n1, n3);
    6767  Digraph::Arc a3 = digraph.addArc(n2, n3);
    68   ignore_unused_variable_warning(a3);
     68  ::lemon::ignore_unused_variable_warning(a3);
    6969
    7070  // Check the adaptor
    … …  
    101101  Adaptor::Arc a7 = adaptor.addArc(n1, n4);
    102102  Adaptor::Arc a8 = adaptor.addArc(n1, n2);
    103   ignore_unused_variable_warning(a6,a7,a8);
     103  ::lemon::ignore_unused_variable_warning(a6,a7,a8);
    104104
    105105  adaptor.erase(a1);
    … …  
    761761  Digraph::Arc a2 = digraph.addArc(n1, n3);
    762762  Digraph::Arc a3 = digraph.addArc(n2, n3);
    763   ignore_unused_variable_warning(a1,a2,a3);
     763  ::lemon::ignore_unused_variable_warning(a1,a2,a3);
    764764
    765765  checkGraphNodeList(adaptor, 6);

  • test/bellman_ford_test.cc

    r1009 r1085  
    6666  Arc e;
    6767  Value l;
    68   ignore_unused_variable_warning(l);
     68  ::lemon::ignore_unused_variable_warning(l);
    6969  int k=3;
    7070  bool b;
    71   ignore_unused_variable_warning(b);
     71  ::lemon::ignore_unused_variable_warning(b);
    7272  BF::DistMap d(gr);
    7373  BF::PredMap p(gr);
    … …  
    150150  Digraph g;
    151151  bool b;
    152   ignore_unused_variable_warning(b);
     152  ::lemon::ignore_unused_variable_warning(b);
    153153
    154154  bellmanFord(g,LengthMap()).run(Node());

  • test/bfs_test.cc

    r1008 r1084  
    6262  Arc e;
    6363  int l, i;
    64   ignore_unused_variable_warning(l,i);
     64  ::lemon::ignore_unused_variable_warning(l,i);
    6565  bool b;
    6666  BType::DistMap d(G);
    … …  
    152152  Digraph g;
    153153  bool b;
    154   ignore_unused_variable_warning(b);
     154  ::lemon::ignore_unused_variable_warning(b);
    155155
    156156  bfs(g).run(Node());

  • test/circulation_test.cc

    r1008 r1084  
    7474  VType v;
    7575  bool b;
    76   ignore_unused_variable_warning(v,b);
     76  ::lemon::ignore_unused_variable_warning(v,b);
    7777
    7878  typedef Circulation<Digraph, CapMap, CapMap, SupplyMap>
    … …  
    105105  const_circ_test.barrierMap(bar);
    106106
    107   ignore_unused_variable_warning(fm);
     107  ::lemon::ignore_unused_variable_warning(fm);
    108108}
    109109

  • test/connectivity_test.cc

    r998 r1084  
    6969    Graph g(d);
    7070    Digraph::Node n = d.addNode();
    71     ignore_unused_variable_warning(n);
     71    ::lemon::ignore_unused_variable_warning(n);
    7272
    7373    check(stronglyConnected(d), "This digraph is strongly connected");
    … …  
    247247    Digraph::Node watch = d.addNode();
    248248    Digraph::Node pants = d.addNode();
    249     ignore_unused_variable_warning(watch);
     249    ::lemon::ignore_unused_variable_warning(watch);
    250250
    251251    d.addArc(socks, shoe);

  • test/dfs_test.cc

    r1010 r1086  
    6868  int l, i;
    6969  bool b;
    70   ignore_unused_variable_warning(l,i,b);
     70  ::lemon::ignore_unused_variable_warning(l,i,b);
    7171
    7272  DType::DistMap d(G);
    … …  
    154154  Digraph g;
    155155  bool b;
    156   ignore_unused_variable_warning(b);
     156  ::lemon::ignore_unused_variable_warning(b);
    157157
    158158  dfs(g).run(Node());

  • test/digraph_test.cc

    r999 r1085  
    6565      a3 = G.addArc(n2, n3),
    6666      a4 = G.addArc(n2, n3);
    67   ignore_unused_variable_warning(a2,a3,a4);
     67  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
    6868
    6969  checkGraphNodeList(G, 3);
    … …  
    9494  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
    9595      a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
    96   ignore_unused_variable_warning(a1,a2,a3,a4);
     96  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
    9797
    9898  Node n4 = G.split(n2);
    … …  
    128128      a3 = G.addArc(n4, n3), a4 = G.addArc(n4, n3),
    129129      a5 = G.addArc(n2, n4);
    130   ignore_unused_variable_warning(a1,a2,a3,a5);
     130  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a5);
    131131
    132132  checkGraphNodeList(G, 4);
    … …  
    208208      a3 = G.addArc(n4, n3), a4 = G.addArc(n3, n1),
    209209      a5 = G.addArc(n2, n4);
    210   ignore_unused_variable_warning(a2,a3,a4,a5);
     210  ::lemon::ignore_unused_variable_warning(a2,a3,a4,a5);
    211211
    212212  // Check arc deletion
    … …  
    256256  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
    257257      a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
    258   ignore_unused_variable_warning(a1,a2,a3,a4);
     258  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
    259259
    260260  typename Digraph::Snapshot snapshot(G);
    … …  
    357357    e1 = g.addArc(n1, n2),
    358358    e2 = g.addArc(n2, n3);
    359   ignore_unused_variable_warning(e2);
     359  ::lemon::ignore_unused_variable_warning(e2);
    360360
    361361  check(g.valid(n1), "Wrong validity check");
    … …  
    443443    a3 = g.addArc(n2, n3),
    444444    a4 = g.addArc(n2, n3);
    445   ignore_unused_variable_warning(a2,a3,a4);
     445  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
    446446
    447447  digraphCopy(g, G).nodeRef(nref).run();

  • test/dijkstra_test.cc

    r1008 r1084  
    6666  int i;
    6767  bool b;
    68   ignore_unused_variable_warning(l,i,b);
     68  ::lemon::ignore_unused_variable_warning(l,i,b);
    6969
    7070  DType::DistMap d(G);
    … …  
    165165  Digraph g;
    166166  bool b;
    167   ignore_unused_variable_warning(b);
     167  ::lemon::ignore_unused_variable_warning(b);
    168168
    169169  dijkstra(g,LengthMap()).run(Node());

  • test/edge_set_test.cc

    r998 r1084  
    4545
    4646  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    47   ignore_unused_variable_warning(ga1);
     47  ::lemon::ignore_unused_variable_warning(ga1);
    4848
    4949  ArcSet arc_set(digraph);
    5050
    5151  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    52   ignore_unused_variable_warning(ga2);
     52  ::lemon::ignore_unused_variable_warning(ga2);
    5353
    5454  checkGraphNodeList(arc_set, 2);
    … …  
    7878    a3 = arc_set.addArc(n2, n3),
    7979    a4 = arc_set.addArc(n2, n3);
    80   ignore_unused_variable_warning(a2,a3,a4);
     80  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
    8181
    8282  checkGraphNodeList(arc_set, 3);
    … …  
    115115
    116116  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    117   ignore_unused_variable_warning(ga1);
     117  ::lemon::ignore_unused_variable_warning(ga1);
    118118
    119119  ArcSet arc_set(digraph);
    120120
    121121  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    122   ignore_unused_variable_warning(ga2);
     122  ::lemon::ignore_unused_variable_warning(ga2);
    123123
    124124  checkGraphNodeList(arc_set, 2);
    … …  
    148148    a3 = arc_set.addArc(n2, n3),
    149149    a4 = arc_set.addArc(n2, n3);
    150   ignore_unused_variable_warning(a2,a3,a4);
     150  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
    151151
    152152  checkGraphNodeList(arc_set, 3);
    … …  
    199199
    200200  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    201   ignore_unused_variable_warning(ga1);
     201  ::lemon::ignore_unused_variable_warning(ga1);
    202202
    203203  EdgeSet edge_set(digraph);
    204204
    205205  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    206   ignore_unused_variable_warning(ga2);
     206  ::lemon::ignore_unused_variable_warning(ga2);
    207207
    208208  checkGraphNodeList(edge_set, 2);
    … …  
    241241    e3 = edge_set.addEdge(n2, n3),
    242242    e4 = edge_set.addEdge(n2, n3);
    243   ignore_unused_variable_warning(e2,e3,e4);
     243  ::lemon::ignore_unused_variable_warning(e2,e3,e4);
    244244
    245245  checkGraphNodeList(edge_set, 3);
    … …  
    287287
    288288  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    289   ignore_unused_variable_warning(ga1);
     289  ::lemon::ignore_unused_variable_warning(ga1);
    290290
    291291  EdgeSet edge_set(digraph);
    292292
    293293  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    294   ignore_unused_variable_warning(ga2);
     294  ::lemon::ignore_unused_variable_warning(ga2);
    295295
    296296  checkGraphNodeList(edge_set, 2);
    … …  
    329329    e3 = edge_set.addEdge(n2, n3),
    330330    e4 = edge_set.addEdge(n2, n3);
    331   ignore_unused_variable_warning(e2,e3,e4);
     331  ::lemon::ignore_unused_variable_warning(e2,e3,e4);
    332332
    333333  checkGraphNodeList(edge_set, 3);

  • test/euler_test.cc

    r998 r1084  
    102102    Graph g(d);
    103103    Digraph::Node n = d.addNode();
    104     ignore_unused_variable_warning(n);
     104    ::lemon::ignore_unused_variable_warning(n);
    105105 
    106106    checkDiEulerIt(d);
    … …  
    191191    Digraph::Node n4 = d.addNode();
    192192    Digraph::Node n5 = d.addNode();
    193     ignore_unused_variable_warning(n0,n4,n5);
     193    ::lemon::ignore_unused_variable_warning(n0,n4,n5);
    194194
    195195    d.addArc(n1, n2);

  • test/fractional_matching_test.cc

    r999 r1085  
    343343      pv += weight[mwfm.matching(n)];
    344344      SmartGraph::Node o = graph.target(mwfm.matching(n));
    345       ignore_unused_variable_warning(o);
     345      ::lemon::ignore_unused_variable_warning(o);
    346346    } else {
    347347      check(mwfm.nodeValue(n) == 0, "Invalid matching");
    … …  
    408408    pv += weight[mwpfm.matching(n)];
    409409    SmartGraph::Node o = graph.target(mwpfm.matching(n));
    410     ignore_unused_variable_warning(o);
     410    ::lemon::ignore_unused_variable_warning(o);
    411411  }
    412412

  • test/gomory_hu_test.cc

    r1008 r1084  
    6969  Value v;
    7070  int d;
    71   ignore_unused_variable_warning(v,d);
     71  ::lemon::ignore_unused_variable_warning(v,d);
    7272
    7373  GomoryHu<Graph, CapMap> gh_test(g, cap);

  • test/graph_test.cc

    r998 r1084  
    6767  Edge e2 = G.addEdge(n2, n1),
    6868       e3 = G.addEdge(n2, n3);
    69   ignore_unused_variable_warning(e2,e3);
     69  ::lemon::ignore_unused_variable_warning(e2,e3);
    7070
    7171  checkGraphNodeList(G, 3);
    … …  
    100100       e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
    101101       e5 = G.addEdge(n4, n3);
    102   ignore_unused_variable_warning(e1,e3,e4,e5);
     102  ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
    103103
    104104  checkGraphNodeList(G, 4);
    … …  
    180180       e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
    181181       e5 = G.addEdge(n4, n3);
    182   ignore_unused_variable_warning(e1,e3,e4,e5);
     182  ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
    183183
    184184  // Check edge deletion
    … …  
    221221  Edge e1 = G.addEdge(n1, n2), e2 = G.addEdge(n2, n1),
    222222       e3 = G.addEdge(n2, n3);
    223   ignore_unused_variable_warning(e1,e2,e3);
     223  ::lemon::ignore_unused_variable_warning(e1,e2,e3);
    224224
    225225  checkGraphNodeList(G, 3);
    … …  
    386386    e1 = g.addEdge(n1, n2),
    387387    e2 = g.addEdge(n2, n3);
    388   ignore_unused_variable_warning(e2);
     388  ::lemon::ignore_unused_variable_warning(e2);
    389389
    390390  check(g.valid(n1), "Wrong validity check");
    … …  
    525525
    526526  Node n = G.nodeFromId(dim);
    527   ignore_unused_variable_warning(n);
     527  ::lemon::ignore_unused_variable_warning(n);
    528528
    529529  for (NodeIt n(G); n != INVALID; ++n) {

  • test/hao_orlin_test.cc

    r1008 r1084  
    6767  CutMap cut;
    6868  Value v;
    69   ignore_unused_variable_warning(v);
     69  ::lemon::ignore_unused_variable_warning(v);
    7070
    7171  HaoOrlin<Digraph, CapMap> ho_test(g, cap);

  • test/maps_test.cc

    r1067 r1086  
    104104    NullMap<A,B> map1;
    105105    NullMap<A,B> map2 = map1;
    106     ignore_unused_variable_warning(map2);
     106    ::lemon::ignore_unused_variable_warning(map2);
    107107    map1 = nullMap<A,B>();
    108108  }
    … …  
    115115    ConstMap<A,B> map2 = B();
    116116    ConstMap<A,B> map3 = map1;
    117     ignore_unused_variable_warning(map2,map3);
     117    ::lemon::ignore_unused_variable_warning(map2,map3);
    118118
    119119    map1 = constMap<A>(B());
    … …  
    122122    ConstMap<A,C> map4(C(1));
    123123    ConstMap<A,C> map5 = map4;
    124     ignore_unused_variable_warning(map5);
     124    ::lemon::ignore_unused_variable_warning(map5);
    125125
    126126    map4 = constMap<A>(C(2));
    … …  
    144144    IdentityMap<A> map1;
    145145    IdentityMap<A> map2 = map1;
    146     ignore_unused_variable_warning(map2);
     146    ::lemon::ignore_unused_variable_warning(map2);
    147147
    148148    map1 = identityMap<A>();
    … …  
    205205    checkConcept<ReadMap<B,double>, CompMap>();
    206206    CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>());
    207     ignore_unused_variable_warning(map1);
     207    ::lemon::ignore_unused_variable_warning(map1);
    208208    CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
    209     ignore_unused_variable_warning(map2);
     209    ::lemon::ignore_unused_variable_warning(map2);
    210210
    211211    SparseMap<double, bool> m1(false); m1[3.14] = true;
    … …  
    220220    checkConcept<ReadMap<A,double>, CombMap>();
    221221    CombMap map1 = CombMap(DoubleMap(), DoubleMap());
    222     ignore_unused_variable_warning(map1);
     222    ::lemon::ignore_unused_variable_warning(map1);
    223223    CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
    224     ignore_unused_variable_warning(map2);
     224    ::lemon::ignore_unused_variable_warning(map2);
    225225
    226226    check(combineMap(constMap<B,int,2>(), identityMap<B>(), &binc)[B()] == 3,
    … …  
    234234    FunctorToMap<F> map1;
    235235    FunctorToMap<F> map2 = FunctorToMap<F>(F());
    236     ignore_unused_variable_warning(map2);
     236    ::lemon::ignore_unused_variable_warning(map2);
    237237
    238238    B b = functorToMap(F())[A()];
    239     ignore_unused_variable_warning(b);
     239    ::lemon::ignore_unused_variable_warning(b);
    240240
    241241    checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
    242242    MapToFunctor<ReadMap<A,B> > map =
    243243      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
    244     ignore_unused_variable_warning(map);
     244    ::lemon::ignore_unused_variable_warning(map);
    245245
    246246    check(functorToMap(&func)[A()] == 3,
    … …  
    260260      ConvertMap<ReadMap<double, int>, double> >();
    261261    ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));
    262     ignore_unused_variable_warning(map1);
     262    ::lemon::ignore_unused_variable_warning(map1);
    263263    ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
    264     ignore_unused_variable_warning(map2);
     264    ::lemon::ignore_unused_variable_warning(map2);
    265265
    266266  }

  • test/matching_test.cc

    r1008 r1084  
    146146  MaxMatching<Graph>::Status stat =
    147147    const_mat_test.status(n);
    148   ignore_unused_variable_warning(stat);
     148  ::lemon::ignore_unused_variable_warning(stat);
    149149  const MaxMatching<Graph>::StatusMap& smap =
    150150    const_mat_test.statusMap();

  • test/min_cost_arborescence_test.cc

    r1008 r1084  
    9292  VType c;
    9393  bool b;
    94   ignore_unused_variable_warning(c,b);
     94  ::lemon::ignore_unused_variable_warning(c,b);
    9595  int i;
    9696  CostMap cost;
    … …  
    128128  c = const_mcarb_test.dualValue(i);
    129129
    130   ignore_unused_variable_warning(am);
    131   ignore_unused_variable_warning(pm);
     130  ::lemon::ignore_unused_variable_warning(am);
     131  ::lemon::ignore_unused_variable_warning(pm);
    132132}
    133133

  • test/suurballe_test.cc

    r1008 r1084  
    118118  int f;
    119119  VType c;
    120   ignore_unused_variable_warning(f,c);
     120  ::lemon::ignore_unused_variable_warning(f,c);
    121121
    122122  c = const_suurb_test.totalLength();
    … …  
    130130  Path<Digraph> p = const_suurb_test.path(k);
    131131
    132   ignore_unused_variable_warning(fm);
    133   ignore_unused_variable_warning(pm);
     132  ::lemon::ignore_unused_variable_warning(fm);
     133  ::lemon::ignore_unused_variable_warning(pm);
    134134}
    135135

  • test/time_measure_test.cc

    r997 r1083  
    3636    {
    3737      TimeStamp x(T);
    38       ignore_unused_variable_warning(x);
     38      ::lemon::ignore_unused_variable_warning(x);
    3939    }
    4040}
Note: See TracChangeset for help on using the changeset viewer.