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 / [808:bdfc038f364c:806:14394c9603c2] in lemon-1.1


Ignore:
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • lemon/concept_check.h

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

  • lemon/concepts/digraph.h

    r808 r761  
    325325        /// This constructor sets the iterator to the first arc of \c g.
    326326        ///@param g the digraph
    327         ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); }
     327        ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
    328328        /// Arc -> ArcIt conversion
    329329

  • lemon/concepts/graph.h

    r807 r655  
    383383        /// This constructor sets the iterator to the first arc of \c g.
    384384        ///@param g the graph
    385         ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); }
     385        ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
    386386        /// Arc -> ArcIt conversion
    387387
    … …  
    432432        ///@param g the graph
    433433        OutArcIt(const Graph& n, const Node& g) {
    434           ::lemon::ignore_unused_variable_warning(n);
    435           ::lemon::ignore_unused_variable_warning(g);
     434          ignore_unused_variable_warning(n);
     435          ignore_unused_variable_warning(g);
    436436        }
    437437        /// Arc -> OutArcIt conversion
    … …  
    484484        ///@param g the graph
    485485        InArcIt(const Graph& g, const Node& n) {
    486           ::lemon::ignore_unused_variable_warning(n);
    487           ::lemon::ignore_unused_variable_warning(g);
     486          ignore_unused_variable_warning(n);
     487          ignore_unused_variable_warning(g);
    488488        }
    489489        /// Arc -> InArcIt conversion

  • lemon/concepts/graph_components.h

    r808 r797  
    109109
    110110          bool b;
    111           ::lemon::ignore_unused_variable_warning(b);
     111          ignore_unused_variable_warning(b);
    112112
    113113          b = (ia == ib) && (ia != ib);
    … …  
    290290            ue = e;
    291291            bool d = graph.direction(e);
    292             ::lemon::ignore_unused_variable_warning(d);
     292            ignore_unused_variable_warning(d);
    293293          }
    294294        }
    … …  
    369369
    370370          nid = digraph.maxNodeId();
    371           ::lemon::ignore_unused_variable_warning(nid);
     371          ignore_unused_variable_warning(nid);
    372372          eid = digraph.maxArcId();
    373           ::lemon::ignore_unused_variable_warning(eid);
     373          ignore_unused_variable_warning(eid);
    374374        }
    375375
    … …  
    424424          edge = graph.edgeFromId(ueid);
    425425          ueid = graph.maxEdgeId();
    426           ::lemon::ignore_unused_variable_warning(ueid);
     426          ignore_unused_variable_warning(ueid);
    427427        }
    428428
    … …  
    497497          _GraphItemIt it3 = it1;
    498498          _GraphItemIt it4 = INVALID;
    499           ::lemon::ignore_unused_variable_warning(it3);
    500           ::lemon::ignore_unused_variable_warning(it4);
     499          ignore_unused_variable_warning(it3);
     500          ignore_unused_variable_warning(it4);
    501501
    502502          it2 = ++it1;
    … …  
    588588          _GraphIncIt it3 = it1;
    589589          _GraphIncIt it4 = INVALID;
    590           ::lemon::ignore_unused_variable_warning(it3);
    591           ::lemon::ignore_unused_variable_warning(it4);
     590          ignore_unused_variable_warning(it3);
     591          ignore_unused_variable_warning(it4);
    592592
    593593          it2 = ++it1;
    … …  
    771771            n = digraph.baseNode(oait);
    772772            n = digraph.runningNode(oait);
    773             ::lemon::ignore_unused_variable_warning(n);
     773            ignore_unused_variable_warning(n);
    774774          }
    775775        }
    … …  
    954954            = digraph.notifier(typename _Digraph::Arc());
    955955
    956           ::lemon::ignore_unused_variable_warning(nn);
    957           ::lemon::ignore_unused_variable_warning(en);
     956          ignore_unused_variable_warning(nn);
     957          ignore_unused_variable_warning(en);
    958958        }
    959959
    … …  
    997997          typename _Graph::EdgeNotifier& uen
    998998            = graph.notifier(typename _Graph::Edge());
    999           ::lemon::ignore_unused_variable_warning(uen);
     999          ignore_unused_variable_warning(uen);
    10001000        }
    10011001
    … …  
    10711071          // m3 = cmap;
    10721072
    1073           ::lemon::ignore_unused_variable_warning(m1);
    1074           ::lemon::ignore_unused_variable_warning(m2);
    1075           // ::lemon::ignore_unused_variable_warning(m3);
     1073          ignore_unused_variable_warning(m1);
     1074          ignore_unused_variable_warning(m2);
     1075          // ignore_unused_variable_warning(m3);
    10761076        }
    10771077

  • lemon/concepts/heap.h

    r807 r783  
    199199          item=Item();
    200200          prio=Prio();
    201           ::lemon::ignore_unused_variable_warning(item);
    202           ::lemon::ignore_unused_variable_warning(prio);
     201          ignore_unused_variable_warning(item);
     202          ignore_unused_variable_warning(prio);
    203203
    204204          OwnItem own_item;
    … …  
    207207          own_item=Item();
    208208          own_prio=Prio();
    209           ::lemon::ignore_unused_variable_warning(own_item);
    210           ::lemon::ignore_unused_variable_warning(own_prio);
    211           ::lemon::ignore_unused_variable_warning(own_state);
     209          ignore_unused_variable_warning(own_item);
     210          ignore_unused_variable_warning(own_prio);
     211          ignore_unused_variable_warning(own_state);
    212212
    213213          _Heap heap1(map);
    214214          _Heap heap2 = heap1;
    215           ::lemon::ignore_unused_variable_warning(heap1);
    216           ::lemon::ignore_unused_variable_warning(heap2);
     215          ignore_unused_variable_warning(heap1);
     216          ignore_unused_variable_warning(heap2);
    217217
    218218          int s = heap.size();
    219           ::lemon::ignore_unused_variable_warning(s);
     219          ignore_unused_variable_warning(s);
    220220          bool e = heap.empty();
    221           ::lemon::ignore_unused_variable_warning(e);
     221          ignore_unused_variable_warning(e);
    222222
    223223          prio = heap.prio();

  • lemon/concepts/maps.h

    r808 r793  
    6161          own_val = m[own_key];
    6262
    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);
     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);
    6767        }
    6868        const Key& key;
    … …  
    101101          m.set(own_key, own_val);
    102102
    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);
     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);
    107107        }
    108108        const Key& key;

  • lemon/concepts/path.h

    r807 r783  
    6767      template <typename CPath>
    6868      Path& operator=(const CPath& cpath) {
    69         ::lemon::ignore_unused_variable_warning(cpath);
     69        ignore_unused_variable_warning(cpath);
    7070        return *this;
    7171      }
    … …  
    127127          e = (i < ii);
    128128
    129           ::lemon::ignore_unused_variable_warning(l);
    130           ::lemon::ignore_unused_variable_warning(pp);
    131           ::lemon::ignore_unused_variable_warning(e);
    132           ::lemon::ignore_unused_variable_warning(id);
    133           ::lemon::ignore_unused_variable_warning(ii);
    134           ::lemon::ignore_unused_variable_warning(ed);
     129          ignore_unused_variable_warning(l);
     130          ignore_unused_variable_warning(pp);
     131          ignore_unused_variable_warning(e);
     132          ignore_unused_variable_warning(id);
     133          ignore_unused_variable_warning(ii);
     134          ignore_unused_variable_warning(ed);
    135135        }
    136136      };
    … …  
    154154          e = (i != INVALID);
    155155
    156           ::lemon::ignore_unused_variable_warning(l);
    157           ::lemon::ignore_unused_variable_warning(e);
    158           ::lemon::ignore_unused_variable_warning(id);
    159           ::lemon::ignore_unused_variable_warning(ed);
     156          ignore_unused_variable_warning(l);
     157          ignore_unused_variable_warning(e);
     158          ignore_unused_variable_warning(id);
     159          ignore_unused_variable_warning(ed);
    160160        }
    161161        _Path& p;
    … …  
    180180          e = (i != INVALID);
    181181
    182           ::lemon::ignore_unused_variable_warning(l);
    183           ::lemon::ignore_unused_variable_warning(e);
    184           ::lemon::ignore_unused_variable_warning(id);
    185           ::lemon::ignore_unused_variable_warning(ed);
     182          ignore_unused_variable_warning(l);
     183          ignore_unused_variable_warning(e);
     184          ignore_unused_variable_warning(id);
     185          ignore_unused_variable_warning(ed);
    186186        }
    187187        _Path& p;

  • test/adaptors_test.cc

    r808 r793  
    6666  Digraph::Arc a2 = digraph.addArc(n1, n3);
    6767  Digraph::Arc a3 = digraph.addArc(n2, n3);
    68   ::lemon::ignore_unused_variable_warning(a3);
     68  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   ::lemon::ignore_unused_variable_warning(a6,a7,a8);
     103  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   ::lemon::ignore_unused_variable_warning(a1,a2,a3);
     763  ignore_unused_variable_warning(a1,a2,a3);
    764764
    765765  checkGraphNodeList(adaptor, 6);

  • test/bfs_test.cc

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

  • test/circulation_test.cc

    r808 r797  
    7474  VType v;
    7575  bool b;
    76   ::lemon::ignore_unused_variable_warning(v,b);
     76  ignore_unused_variable_warning(v,b);
    7777
    7878  typedef Circulation<Digraph, CapMap, CapMap, SupplyMap>
    … …  
    100100  const_circ_test.barrierMap(bar);
    101101
    102   ::lemon::ignore_unused_variable_warning(fm);
     102  ignore_unused_variable_warning(fm);
    103103}
    104104

  • test/connectivity_test.cc

    r808 r793  
    6969    Graph g(d);
    7070    Digraph::Node n = d.addNode();
    71     ::lemon::ignore_unused_variable_warning(n);
     71    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     ::lemon::ignore_unused_variable_warning(watch);
     249    ignore_unused_variable_warning(watch);
    250250
    251251    d.addArc(socks, shoe);

  • test/dfs_test.cc

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

  • test/digraph_test.cc

    r807 r792  
    6161      a3 = G.addArc(n2, n3),
    6262      a4 = G.addArc(n2, n3);
    63   ::lemon::ignore_unused_variable_warning(a2,a3,a4);
     63  ignore_unused_variable_warning(a2,a3,a4);
    6464
    6565  checkGraphNodeList(G, 3);
    … …  
    9090  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
    9191      a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
    92   ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
     92  ignore_unused_variable_warning(a1,a2,a3,a4);
    9393
    9494  Node n4 = G.split(n2);
    … …  
    124124      a3 = G.addArc(n4, n3), a4 = G.addArc(n4, n3),
    125125      a5 = G.addArc(n2, n4);
    126   ::lemon::ignore_unused_variable_warning(a1,a2,a3,a5);
     126  ignore_unused_variable_warning(a1,a2,a3,a5);
    127127
    128128  checkGraphNodeList(G, 4);
    … …  
    204204      a3 = G.addArc(n4, n3), a4 = G.addArc(n3, n1),
    205205      a5 = G.addArc(n2, n4);
    206   ::lemon::ignore_unused_variable_warning(a2,a3,a4,a5);
     206  ignore_unused_variable_warning(a2,a3,a4,a5);
    207207
    208208  // Check arc deletion
    … …  
    252252  Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
    253253      a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
    254   ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
     254  ignore_unused_variable_warning(a1,a2,a3,a4);
    255255
    256256  typename Digraph::Snapshot snapshot(G);
    … …  
    341341    e1 = g.addArc(n1, n2),
    342342    e2 = g.addArc(n2, n3);
    343   ::lemon::ignore_unused_variable_warning(e2);
     343  ignore_unused_variable_warning(e2);
    344344
    345345  check(g.valid(n1), "Wrong validity check");

  • test/dijkstra_test.cc

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

  • test/edge_set_test.cc

    r808 r793  
    4545
    4646  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    47   ::lemon::ignore_unused_variable_warning(ga1);
     47  ignore_unused_variable_warning(ga1);
    4848
    4949  ArcSet arc_set(digraph);
    5050
    5151  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    52   ::lemon::ignore_unused_variable_warning(ga2);
     52  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   ::lemon::ignore_unused_variable_warning(a2,a3,a4);
     80  ignore_unused_variable_warning(a2,a3,a4);
    8181
    8282  checkGraphNodeList(arc_set, 3);
    … …  
    115115
    116116  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    117   ::lemon::ignore_unused_variable_warning(ga1);
     117  ignore_unused_variable_warning(ga1);
    118118
    119119  ArcSet arc_set(digraph);
    120120
    121121  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    122   ::lemon::ignore_unused_variable_warning(ga2);
     122  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   ::lemon::ignore_unused_variable_warning(a2,a3,a4);
     150  ignore_unused_variable_warning(a2,a3,a4);
    151151
    152152  checkGraphNodeList(arc_set, 3);
    … …  
    199199
    200200  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    201   ::lemon::ignore_unused_variable_warning(ga1);
     201  ignore_unused_variable_warning(ga1);
    202202
    203203  EdgeSet edge_set(digraph);
    204204
    205205  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    206   ::lemon::ignore_unused_variable_warning(ga2);
     206  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   ::lemon::ignore_unused_variable_warning(e2,e3,e4);
     243  ignore_unused_variable_warning(e2,e3,e4);
    244244
    245245  checkGraphNodeList(edge_set, 3);
    … …  
    287287
    288288  Digraph::Arc ga1 = digraph.addArc(n1, n2);
    289   ::lemon::ignore_unused_variable_warning(ga1);
     289  ignore_unused_variable_warning(ga1);
    290290
    291291  EdgeSet edge_set(digraph);
    292292
    293293  Digraph::Arc ga2 = digraph.addArc(n2, n1);
    294   ::lemon::ignore_unused_variable_warning(ga2);
     294  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   ::lemon::ignore_unused_variable_warning(e2,e3,e4);
     331  ignore_unused_variable_warning(e2,e3,e4);
    332332
    333333  checkGraphNodeList(edge_set, 3);

  • test/euler_test.cc

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

  • test/gomory_hu_test.cc

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

  • test/graph_test.cc

    r807 r792  
    6464  Edge e2 = G.addEdge(n2, n1),
    6565       e3 = G.addEdge(n2, n3);
    66   ::lemon::ignore_unused_variable_warning(e2,e3);
     66  ignore_unused_variable_warning(e2,e3);
    6767
    6868  checkGraphNodeList(G, 3);
    … …  
    9797       e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
    9898       e5 = G.addEdge(n4, n3);
    99   ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
     99  ignore_unused_variable_warning(e1,e3,e4,e5);
    100100
    101101  checkGraphNodeList(G, 4);
    … …  
    177177       e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
    178178       e5 = G.addEdge(n4, n3);
    179   ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
     179  ignore_unused_variable_warning(e1,e3,e4,e5);
    180180
    181181  // Check edge deletion
    … …  
    218218  Edge e1 = G.addEdge(n1, n2), e2 = G.addEdge(n2, n1),
    219219       e3 = G.addEdge(n2, n3);
    220   ::lemon::ignore_unused_variable_warning(e1,e2,e3);
     220  ignore_unused_variable_warning(e1,e2,e3);
    221221
    222222  checkGraphNodeList(G, 3);
    … …  
    367367    e1 = g.addEdge(n1, n2),
    368368    e2 = g.addEdge(n2, n3);
    369   ::lemon::ignore_unused_variable_warning(e2);
     369  ignore_unused_variable_warning(e2);
    370370
    371371  check(g.valid(n1), "Wrong validity check");
    … …  
    497497
    498498  Node n = G.nodeFromId(dim);
    499   ::lemon::ignore_unused_variable_warning(n);
     499  ignore_unused_variable_warning(n);
    500500
    501501  for (NodeIt n(G); n != INVALID; ++n) {

  • test/hao_orlin_test.cc

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

  • test/maps_test.cc

    r808 r793  
    8181    NullMap<A,B> map1;
    8282    NullMap<A,B> map2 = map1;
    83     ::lemon::ignore_unused_variable_warning(map2);
     83    ignore_unused_variable_warning(map2);
    8484    map1 = nullMap<A,B>();
    8585  }
    … …  
    9292    ConstMap<A,B> map2 = B();
    9393    ConstMap<A,B> map3 = map1;
    94     ::lemon::ignore_unused_variable_warning(map2,map3);
     94    ignore_unused_variable_warning(map2,map3);
    9595
    9696    map1 = constMap<A>(B());
    … …  
    9999    ConstMap<A,C> map4(C(1));
    100100    ConstMap<A,C> map5 = map4;
    101     ::lemon::ignore_unused_variable_warning(map5);
     101    ignore_unused_variable_warning(map5);
    102102
    103103    map4 = constMap<A>(C(2));
    … …  
    121121    IdentityMap<A> map1;
    122122    IdentityMap<A> map2 = map1;
    123     ::lemon::ignore_unused_variable_warning(map2);
     123    ignore_unused_variable_warning(map2);
    124124
    125125    map1 = identityMap<A>();
    … …  
    182182    checkConcept<ReadMap<B,double>, CompMap>();
    183183    CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>());
    184     ::lemon::ignore_unused_variable_warning(map1);
     184    ignore_unused_variable_warning(map1);
    185185    CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
    186     ::lemon::ignore_unused_variable_warning(map2);
     186    ignore_unused_variable_warning(map2);
    187187
    188188    SparseMap<double, bool> m1(false); m1[3.14] = true;
    … …  
    197197    checkConcept<ReadMap<A,double>, CombMap>();
    198198    CombMap map1 = CombMap(DoubleMap(), DoubleMap());
    199     ::lemon::ignore_unused_variable_warning(map1);
     199    ignore_unused_variable_warning(map1);
    200200    CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
    201     ::lemon::ignore_unused_variable_warning(map2);
     201    ignore_unused_variable_warning(map2);
    202202
    203203    check(combineMap(constMap<B,int,2>(), identityMap<B>(), &binc)[B()] == 3,
    … …  
    211211    FunctorToMap<F> map1;
    212212    FunctorToMap<F> map2 = FunctorToMap<F>(F());
    213     ::lemon::ignore_unused_variable_warning(map2);
     213    ignore_unused_variable_warning(map2);
    214214
    215215    B b = functorToMap(F())[A()];
    216     ::lemon::ignore_unused_variable_warning(b);
     216    ignore_unused_variable_warning(b);
    217217
    218218    checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
    219219    MapToFunctor<ReadMap<A,B> > map =
    220220      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
    221     ::lemon::ignore_unused_variable_warning(map);
     221    ignore_unused_variable_warning(map);
    222222
    223223    check(functorToMap(&func)[A()] == 3,
    … …  
    237237      ConvertMap<ReadMap<double, int>, double> >();
    238238    ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));
    239     ::lemon::ignore_unused_variable_warning(map1);
     239    ignore_unused_variable_warning(map1);
    240240    ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
    241     ::lemon::ignore_unused_variable_warning(map2);
     241    ignore_unused_variable_warning(map2);
    242242
    243243  }

  • test/matching_test.cc

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

  • test/min_cost_arborescence_test.cc

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

  • test/preflow_test.cc

    r808 r797  
    8787  VType v;
    8888  bool b;
    89   ::lemon::ignore_unused_variable_warning(v,b);
     89  ignore_unused_variable_warning(v,b);
    9090
    9191  typedef Preflow<Digraph, CapMap>
    … …  
    116116  const_preflow_test.minCutMap(cut);
    117117
    118   ::lemon::ignore_unused_variable_warning(fm);
     118  ignore_unused_variable_warning(fm);
    119119}
    120120

  • test/suurballe_test.cc

    r808 r797  
    108108  int f;
    109109  VType c;
    110   ::lemon::ignore_unused_variable_warning(f,c);
     110  ignore_unused_variable_warning(f,c);
    111111
    112112  c = const_suurb_test.totalLength();
    … …  
    120120  Path<Digraph> p = const_suurb_test.path(k);
    121121
    122   ::lemon::ignore_unused_variable_warning(fm);
    123   ::lemon::ignore_unused_variable_warning(pm);
     122  ignore_unused_variable_warning(fm);
     123  ignore_unused_variable_warning(pm);
    124124}
    125125

  • test/time_measure_test.cc

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