COIN-OR::LEMON - Graph Library

Changeset 982:3e711ee55d31 in lemon-1.2


Ignore:
Timestamp:
08/07/13 06:29:34 (6 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Children:
983:8b2d4e5d96e4, 986:552e3d1242c6
Phase:
public
Message:

Add explicit namespace to ignore_unused_variable_warning() usages (#294)

Files:
25 edited

Legend:

Unmodified
Added
Removed
  • lemon/concept_check.h

    r963 r982  
    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

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

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

    r969 r982  
    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        }
     
    369369
    370370          nid = digraph.maxNodeId();
    371           ignore_unused_variable_warning(nid);
     371          ::lemon::ignore_unused_variable_warning(nid);
    372372          eid = digraph.maxArcId();
    373           ignore_unused_variable_warning(eid);
     373          ::lemon::ignore_unused_variable_warning(eid);
    374374        }
    375375
     
    424424          edge = graph.edgeFromId(ueid);
    425425          ueid = graph.maxEdgeId();
    426           ignore_unused_variable_warning(ueid);
     426          ::lemon::ignore_unused_variable_warning(ueid);
    427427        }
    428428
     
    497497          _GraphItemIt it3 = it1;
    498498          _GraphItemIt it4 = INVALID;
    499           ignore_unused_variable_warning(it3);
    500           ignore_unused_variable_warning(it4);
     499          ::lemon::ignore_unused_variable_warning(it3);
     500          ::lemon::ignore_unused_variable_warning(it4);
    501501
    502502          it2 = ++it1;
     
    588588          _GraphIncIt it3 = it1;
    589589          _GraphIncIt it4 = INVALID;
    590           ignore_unused_variable_warning(it3);
    591           ignore_unused_variable_warning(it4);
     590          ::lemon::ignore_unused_variable_warning(it3);
     591          ::lemon::ignore_unused_variable_warning(it4);
    592592
    593593          it2 = ++it1;
     
    771771            n = digraph.baseNode(oait);
    772772            n = digraph.runningNode(oait);
    773             ignore_unused_variable_warning(n);
     773            ::lemon::ignore_unused_variable_warning(n);
    774774          }
    775775        }
     
    954954            = digraph.notifier(typename _Digraph::Arc());
    955955
    956           ignore_unused_variable_warning(nn);
    957           ignore_unused_variable_warning(en);
     956          ::lemon::ignore_unused_variable_warning(nn);
     957          ::lemon::ignore_unused_variable_warning(en);
    958958        }
    959959
     
    997997          typename _Graph::EdgeNotifier& uen
    998998            = graph.notifier(typename _Graph::Edge());
    999           ignore_unused_variable_warning(uen);
     999          ::lemon::ignore_unused_variable_warning(uen);
    10001000        }
    10011001
     
    10711071          // m3 = cmap;
    10721072
    1073           ignore_unused_variable_warning(m1);
    1074           ignore_unused_variable_warning(m2);
    1075           // ignore_unused_variable_warning(m3);
     1073          ::lemon::ignore_unused_variable_warning(m1);
     1074          ::lemon::ignore_unused_variable_warning(m2);
     1075          // ::lemon::ignore_unused_variable_warning(m3);
    10761076        }
    10771077
  • lemon/concepts/heap.h

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

    r963 r982  
    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

    r953 r982  
    6767      template <typename CPath>
    6868      Path& operator=(const CPath& cpath) {
    69         ignore_unused_variable_warning(cpath);
     69        ::lemon::ignore_unused_variable_warning(cpath);
    7070        return *this;
    7171      }
     
    127127          e = (i < ii);
    128128
    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);
     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);
    135135        }
    136136      };
     
    154154          e = (i != INVALID);
    155155
    156           ignore_unused_variable_warning(l);
    157           ignore_unused_variable_warning(e);
    158           ignore_unused_variable_warning(id);
    159           ignore_unused_variable_warning(ed);
     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);
    160160        }
    161161        _Path& p;
     
    180180          e = (i != INVALID);
    181181
    182           ignore_unused_variable_warning(l);
    183           ignore_unused_variable_warning(e);
    184           ignore_unused_variable_warning(id);
    185           ignore_unused_variable_warning(ed);
     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);
    186186        }
    187187        _Path& p;
  • test/adaptors_test.cc

    r963 r982  
    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/bfs_test.cc

    r969 r982  
    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

    r969 r982  
    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>
     
    100100  const_circ_test.barrierMap(bar);
    101101 
    102   ignore_unused_variable_warning(fm);
     102  ::lemon::ignore_unused_variable_warning(fm);
    103103}
    104104
  • test/connectivity_test.cc

    r963 r982  
    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

    r969 r982  
    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

    r963 r982  
    6161      a3 = G.addArc(n2, n3),
    6262      a4 = G.addArc(n2, n3);
    63   ignore_unused_variable_warning(a2,a3,a4);
     63  ::lemon::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   ignore_unused_variable_warning(a1,a2,a3,a4);
     92  ::lemon::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   ignore_unused_variable_warning(a1,a2,a3,a5);
     126  ::lemon::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   ignore_unused_variable_warning(a2,a3,a4,a5);
     206  ::lemon::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   ignore_unused_variable_warning(a1,a2,a3,a4);
     254  ::lemon::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   ignore_unused_variable_warning(e2);
     343  ::lemon::ignore_unused_variable_warning(e2);
    344344
    345345  check(g.valid(n1), "Wrong validity check");
  • test/dijkstra_test.cc

    r969 r982  
    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

    r963 r982  
    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

    r963 r982  
    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/gomory_hu_test.cc

    r969 r982  
    5151  Value v;
    5252  int d;
    53   ignore_unused_variable_warning(v,d);
     53  ::lemon::ignore_unused_variable_warning(v,d);
    5454
    5555  GomoryHu<Graph, CapMap> gh_test(g, cap);
  • test/graph_test.cc

    r963 r982  
    6464  Edge e2 = G.addEdge(n2, n1),
    6565       e3 = G.addEdge(n2, n3);
    66   ignore_unused_variable_warning(e2,e3);
     66  ::lemon::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   ignore_unused_variable_warning(e1,e3,e4,e5);
     99  ::lemon::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   ignore_unused_variable_warning(e1,e3,e4,e5);
     179  ::lemon::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   ignore_unused_variable_warning(e1,e2,e3);
     220  ::lemon::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   ignore_unused_variable_warning(e2);
     369  ::lemon::ignore_unused_variable_warning(e2);
    370370
    371371  check(g.valid(n1), "Wrong validity check");
     
    497497
    498498  Node n = G.nodeFromId(dim);
    499   ignore_unused_variable_warning(n);
     499  ::lemon::ignore_unused_variable_warning(n);
    500500
    501501  for (NodeIt n(G); n != INVALID; ++n) {
  • test/hao_orlin_test.cc

    r969 r982  
    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

    r963 r982  
    7979    NullMap<A,B> map1;
    8080    NullMap<A,B> map2 = map1;
    81     ignore_unused_variable_warning(map2);
     81    ::lemon::ignore_unused_variable_warning(map2);
    8282    map1 = nullMap<A,B>();
    8383  }
     
    9090    ConstMap<A,B> map2 = B();
    9191    ConstMap<A,B> map3 = map1;
    92     ignore_unused_variable_warning(map2,map3);
     92    ::lemon::ignore_unused_variable_warning(map2,map3);
    9393
    9494    map1 = constMap<A>(B());
     
    9797    ConstMap<A,C> map4(C(1));
    9898    ConstMap<A,C> map5 = map4;
    99     ignore_unused_variable_warning(map5);
     99    ::lemon::ignore_unused_variable_warning(map5);
    100100
    101101    map4 = constMap<A>(C(2));
     
    119119    IdentityMap<A> map1;
    120120    IdentityMap<A> map2 = map1;
    121     ignore_unused_variable_warning(map2);
     121    ::lemon::ignore_unused_variable_warning(map2);
    122122
    123123    map1 = identityMap<A>();
     
    180180    checkConcept<ReadMap<B,double>, CompMap>();
    181181    CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>());
    182     ignore_unused_variable_warning(map1);
     182    ::lemon::ignore_unused_variable_warning(map1);
    183183    CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
    184     ignore_unused_variable_warning(map2);
     184    ::lemon::ignore_unused_variable_warning(map2);
    185185
    186186    SparseMap<double, bool> m1(false); m1[3.14] = true;
     
    195195    checkConcept<ReadMap<A,double>, CombMap>();
    196196    CombMap map1 = CombMap(DoubleMap(), DoubleMap());
    197     ignore_unused_variable_warning(map1);
     197    ::lemon::ignore_unused_variable_warning(map1);
    198198    CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
    199     ignore_unused_variable_warning(map2);
     199    ::lemon::ignore_unused_variable_warning(map2);
    200200
    201201    check(combineMap(constMap<B,int,2>(), identityMap<B>(), &binc)[B()] == 3,
     
    209209    FunctorToMap<F> map1;
    210210    FunctorToMap<F> map2 = FunctorToMap<F>(F());
    211     ignore_unused_variable_warning(map2);
     211    ::lemon::ignore_unused_variable_warning(map2);
    212212
    213213    B b = functorToMap(F())[A()];
    214     ignore_unused_variable_warning(b);
     214    ::lemon::ignore_unused_variable_warning(b);
    215215
    216216    checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
    217217    MapToFunctor<ReadMap<A,B> > map =
    218218      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
    219     ignore_unused_variable_warning(map);
     219    ::lemon::ignore_unused_variable_warning(map);
    220220
    221221    check(functorToMap(&func)[A()] == 3,
     
    235235      ConvertMap<ReadMap<double, int>, double> >();
    236236    ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));
    237     ignore_unused_variable_warning(map1);
     237    ::lemon::ignore_unused_variable_warning(map1);
    238238    ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
    239     ignore_unused_variable_warning(map2);
     239    ::lemon::ignore_unused_variable_warning(map2);
    240240
    241241  }
  • test/matching_test.cc

    r969 r982  
    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

    r969 r982  
    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/preflow_test.cc

    r969 r982  
    8787  VType v;
    8888  bool b;
    89   ignore_unused_variable_warning(v,b);
     89  ::lemon::ignore_unused_variable_warning(v,b);
    9090
    9191  typedef Preflow<Digraph, CapMap>
     
    116116  const_preflow_test.minCutMap(cut);
    117117 
    118   ignore_unused_variable_warning(fm);
     118  ::lemon::ignore_unused_variable_warning(fm);
    119119}
    120120
  • test/suurballe_test.cc

    r969 r982  
    108108  int f;
    109109  VType c;
    110   ignore_unused_variable_warning(f,c);
     110  ::lemon::ignore_unused_variable_warning(f,c);
    111111
    112112  c = const_suurb_test.totalLength();
     
    120120  Path<Digraph> p = const_suurb_test.path(k);
    121121 
    122   ignore_unused_variable_warning(fm);
    123   ignore_unused_variable_warning(pm);
     122  ::lemon::ignore_unused_variable_warning(fm);
     123  ::lemon::ignore_unused_variable_warning(pm);
    124124}
    125125
  • test/time_measure_test.cc

    r963 r982  
    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.