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 / [983:8b2d4e5d96e4:971:a26b90a17c81] in lemon-1.2


Ignore:
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • lemon/concept_check.h

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

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

  • lemon/concepts/graph.h

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

  • lemon/concepts/graph_components.h

    r983 r970  
    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

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

  • lemon/concepts/maps.h

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

    r983 r954  
    7676      template <typename CPath>
    7777      Path& operator=(const CPath& cpath) {
    78         ::lemon::ignore_unused_variable_warning(cpath);
     78        ignore_unused_variable_warning(cpath);
    7979        return *this;
    8080      }
    … …  
    136136          e = (i < ii);
    137137
    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);
     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);
    144144        }
    145145      };
    … …  
    163163          e = (i != INVALID);
    164164
    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);
     165          ignore_unused_variable_warning(l);
     166          ignore_unused_variable_warning(e);
     167          ignore_unused_variable_warning(id);
     168          ignore_unused_variable_warning(ed);
    169169        }
    170170        _Path& p;
    … …  
    189189          e = (i != INVALID);
    190190
    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);
     191          ignore_unused_variable_warning(l);
     192          ignore_unused_variable_warning(e);
     193          ignore_unused_variable_warning(id);
     194          ignore_unused_variable_warning(ed);
    195195        }
    196196        _Path& p;

  • lemon/core.h

    r983 r964  
    3636#ifdef _MSC_VER
    3737#pragma warning( disable : 4250 4355 4503 4800 4996 )
    38 #endif
    39 
    40 #ifdef __GNUC__
    41 #define GCC_VERSION (__GNUC__ * 10000                   \
    42                      + __GNUC_MINOR__ * 100             \
    43                      + __GNUC_PATCHLEVEL__)
    44 #endif
    45 
    46 #if GCC_VERSION >= 40800
    47 // Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8
    48 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
    4938#endif
    5039

  • lemon/cplex.cc

    r974 r956  
    4141    int status;
    4242    _cnt = new int;
    43     (*_cnt) = 1;
    4443    _env = CPXopenCPLEX(&status);
    4544    if (_env == 0) {

  • lemon/graph_to_eps.h

    r981 r964  
    223223  using T::_copyright;
    224224
    225   using T::NodeTextColorType;
     225  using typename T::NodeTextColorType;
    226226  using T::CUST_COL;
    227227  using T::DIST_COL;

  • test/adaptors_test.cc

    r983 r964  
    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

    r983 r970  
    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

    r983 r970  
    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>
    … …  
    105105  const_circ_test.barrierMap(bar);
    106106
    107   ::lemon::ignore_unused_variable_warning(fm);
     107  ignore_unused_variable_warning(fm);
    108108}
    109109

  • test/connectivity_test.cc

    r983 r964  
    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

    r983 r970  
    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

    r983 r965  
    6565      a3 = G.addArc(n2, n3),
    6666      a4 = G.addArc(n2, n3);
    67   ::lemon::ignore_unused_variable_warning(a2,a3,a4);
     67  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   ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
     96  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   ::lemon::ignore_unused_variable_warning(a1,a2,a3,a5);
     130  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   ::lemon::ignore_unused_variable_warning(a2,a3,a4,a5);
     210  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   ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
     258  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   ::lemon::ignore_unused_variable_warning(e2);
     359  ignore_unused_variable_warning(e2);
    360360
    361361  check(g.valid(n1), "Wrong validity check");

  • test/dijkstra_test.cc

    r983 r970  
    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

    r983 r964  
    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

    r983 r964  
    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

    r983 r970  
    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

    r983 r964  
    6767  Edge e2 = G.addEdge(n2, n1),
    6868       e3 = G.addEdge(n2, n3);
    69   ::lemon::ignore_unused_variable_warning(e2,e3);
     69  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   ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
     102  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   ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
     182  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   ::lemon::ignore_unused_variable_warning(e1,e2,e3);
     223  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   ::lemon::ignore_unused_variable_warning(e2);
     388  ignore_unused_variable_warning(e2);
    389389
    390390  check(g.valid(n1), "Wrong validity check");
    … …  
    525525
    526526  Node n = G.nodeFromId(dim);
    527   ::lemon::ignore_unused_variable_warning(n);
     527  ignore_unused_variable_warning(n);
    528528
    529529  for (NodeIt n(G); n != INVALID; ++n) {

  • test/hao_orlin_test.cc

    r983 r970  
    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/lp_test.cc

    r980 r955  
    199199      c = c <= 4;
    200200      LP::Constr c2;
    201 #if ( __GNUC__ == 4 ) && ( __GNUC_MINOR__ == 3 )
    202       c2 = ( -3 <= v ) <= 4;
    203 #else
    204201      c2 = -3 <= v <= 4;
    205 #endif
    206 
    207202    }
    208203
    … …  
    246241  {
    247242    LP::DualExpr e,f,g;
    248     LP::Row p1 = INVALID, p2 = INVALID;
     243    LP::Row p1 = INVALID, p2 = INVALID, p3 = INVALID,
     244      p4 = INVALID, p5 = INVALID;
    249245
    250246    e[p1]=2;

  • test/maps_test.cc

    r983 r964  
    104104    NullMap<A,B> map1;
    105105    NullMap<A,B> map2 = map1;
    106     ::lemon::ignore_unused_variable_warning(map2);
     106    ignore_unused_variable_warning(map2);
    107107    map1 = nullMap<A,B>();
    108108  }
    … …  
    115115    ConstMap<A,B> map2 = B();
    116116    ConstMap<A,B> map3 = map1;
    117     ::lemon::ignore_unused_variable_warning(map2,map3);
     117    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     ::lemon::ignore_unused_variable_warning(map5);
     124    ignore_unused_variable_warning(map5);
    125125
    126126    map4 = constMap<A>(C(2));
    … …  
    144144    IdentityMap<A> map1;
    145145    IdentityMap<A> map2 = map1;
    146     ::lemon::ignore_unused_variable_warning(map2);
     146    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     ::lemon::ignore_unused_variable_warning(map1);
     207    ignore_unused_variable_warning(map1);
    208208    CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
    209     ::lemon::ignore_unused_variable_warning(map2);
     209    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     ::lemon::ignore_unused_variable_warning(map1);
     222    ignore_unused_variable_warning(map1);
    223223    CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
    224     ::lemon::ignore_unused_variable_warning(map2);
     224    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     ::lemon::ignore_unused_variable_warning(map2);
     236    ignore_unused_variable_warning(map2);
    237237
    238238    B b = functorToMap(F())[A()];
    239     ::lemon::ignore_unused_variable_warning(b);
     239    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     ::lemon::ignore_unused_variable_warning(map);
     244    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     ::lemon::ignore_unused_variable_warning(map1);
     262    ignore_unused_variable_warning(map1);
    263263    ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
    264     ::lemon::ignore_unused_variable_warning(map2);
     264    ignore_unused_variable_warning(map2);
    265265
    266266  }

  • test/matching_test.cc

    r983 r970  
    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

    r983 r970  
    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

    r983 r970  
    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>
    … …  
    121121  const_preflow_test.minCutMap(cut);
    122122
    123   ::lemon::ignore_unused_variable_warning(fm);
     123  ignore_unused_variable_warning(fm);
    124124}
    125125

  • test/suurballe_test.cc

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

  • test/time_measure_test.cc

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