COIN-OR::LEMON - Graph Library

Ticket #615: 0f291d5010f6.patch

File 0f291d5010f6.patch, 34.6 KB (added by Alpar Juttner, 3 years ago)
  • demo/graph_to_eps_demo.cc

    # HG changeset patch
    # User Alpar Juttner <alpar@cs.elte.hu>
    # Date 1540551630 -7200
    #      Fri Oct 26 13:00:30 2018 +0200
    # Node ID 0f291d5010f6a47d3038a9f0ee0f6bfb820fbd97
    # Parent  3c00344f49c951d5076dd2c4b7a2389603aba66c
    Kill unused typef warnings (#615)
    
    diff --git a/demo/graph_to_eps_demo.cc b/demo/graph_to_eps_demo.cc
    a b  
    4646  ListDigraph g;
    4747  typedef ListDigraph::Node Node;
    4848  typedef ListDigraph::NodeIt NodeIt;
     49  ignore_unused_warning<NodeIt>();
    4950  typedef ListDigraph::Arc Arc;
    5051  typedef dim2::Point<int> Point;
    5152
  • lemon/concept_check.h

    diff --git a/lemon/concept_check.h b/lemon/concept_check.h
    a b  
    2626#ifndef LEMON_CONCEPT_CHECK_H
    2727#define LEMON_CONCEPT_CHECK_H
    2828
    29 namespace lemon {
    30 
    31   /*
    32     "inline" is used for ignore_unused_variable_warning()
    33     and function_requires() to make sure there is no
    34     overtarget with g++.
    35   */
     29#include<lemon/core.h>
    3630
    37   template <class T> inline void ignore_unused_variable_warning(const T&) { }
    38   template <class T1, class T2>
    39   inline void ignore_unused_variable_warning(const T1&, const T2&) { }
    40   template <class T1, class T2, class T3>
    41   inline void ignore_unused_variable_warning(const T1&, const T2&,
    42                                              const T3&) { }
    43   template <class T1, class T2, class T3, class T4>
    44   inline void ignore_unused_variable_warning(const T1&, const T2&,
    45                                              const T3&, const T4&) { }
    46   template <class T1, class T2, class T3, class T4, class T5>
    47   inline void ignore_unused_variable_warning(const T1&, const T2&,
    48                                              const T3&, const T4&,
    49                                              const T5&) { }
    50   template <class T1, class T2, class T3, class T4, class T5, class T6>
    51   inline void ignore_unused_variable_warning(const T1&, const T2&,
    52                                              const T3&, const T4&,
    53                                              const T5&, const T6&) { }
     31namespace lemon {
    5432
    5533  ///\e
    5634  template <class Concept>
  • lemon/connectivity.h

    diff --git a/lemon/connectivity.h b/lemon/connectivity.h
    a b  
    266266    checkConcept<concepts::Digraph, Digraph>();
    267267
    268268    typedef typename Digraph::Node Node;
     269    ignore_unused_warning<Node>();
    269270    typedef typename Digraph::NodeIt NodeIt;
    270271
    271272    typename Digraph::Node source = NodeIt(digraph);
     
    334335
    335336    typedef typename Digraph::Node Node;
    336337    typedef typename Digraph::Arc Arc;
     338    ignore_unused_warning<Arc>();
    337339    typedef typename Digraph::NodeIt NodeIt;
    338340    typedef typename Digraph::ArcIt ArcIt;
     341    ignore_unused_warning<ArcIt>();
    339342
    340343    typedef std::vector<Node> Container;
    341344    typedef typename Container::iterator Iterator;
     
    13441347    checkConcept<concepts::WriteMap<typename Digraph::Node, int>, NodeMap>();
    13451348
    13461349    typedef typename Digraph::Node Node;
     1350    ignore_unused_warning<Node>();
    13471351    typedef typename Digraph::NodeIt NodeIt;
    13481352    typedef typename Digraph::Arc Arc;
     1353    ignore_unused_warning<Arc>();
    13491354
    13501355    TopologicalSortVisitor<Digraph, NodeMap>
    13511356      visitor(order, countNodes(digraph));
     
    15591564
    15601565    typedef typename Graph::NodeIt NodeIt;
    15611566    typedef typename Graph::ArcIt ArcIt;
     1567    ignore_unused_warning<ArcIt>();
    15621568
    15631569    bool bipartite = true;
    15641570
     
    16041610    checkConcept<concepts::WriteMap<typename Graph::Node, bool>, NodeMap>();
    16051611
    16061612    typedef typename Graph::Node Node;
     1613    ignore_unused_warning<Node>();
    16071614    typedef typename Graph::NodeIt NodeIt;
    16081615    typedef typename Graph::ArcIt ArcIt;
     1616    ignore_unused_warning<ArcIt>();
    16091617
    16101618    bool bipartite = true;
    16111619
  • lemon/core.h

    diff --git a/lemon/core.h b/lemon/core.h
    a b  
    5454
    5555namespace lemon {
    5656
     57
     58  // The contents of the ignore* stuff below was inspired by the
     59  // concept checking utility of the BOOST library
     60  // (http://www.boost.org).
     61
     62
     63  /*
     64    "inline" is used for ignore_unused_variable_warning()
     65    and function_requires() to make sure there is no
     66    overtarget with g++.
     67  */
     68
     69  template <class T> inline void ignore_unused_variable_warning(const T&) { }
     70  template <class T1, class T2>
     71  inline void ignore_unused_variable_warning(const T1&, const T2&) { }
     72  template <class T1, class T2, class T3>
     73  inline void ignore_unused_variable_warning(const T1&, const T2&,
     74                                             const T3&) { }
     75  template <class T1, class T2, class T3, class T4>
     76  inline void ignore_unused_variable_warning(const T1&, const T2&,
     77                                             const T3&, const T4&) { }
     78  template <class T1, class T2, class T3, class T4, class T5>
     79  inline void ignore_unused_variable_warning(const T1&, const T2&,
     80                                             const T3&, const T4&,
     81                                             const T5&) { }
     82  template <class T1, class T2, class T3, class T4, class T5, class T6>
     83  inline void ignore_unused_variable_warning(const T1&, const T2&,
     84                                             const T3&, const T4&,
     85                                             const T5&, const T6&) { }
     86
     87  template <typename T> inline void ignore_unused_warning() { }
     88 
    5789  /// \brief Dummy type to make it easier to create invalid iterators.
    5890  ///
    5991  /// Dummy type to make it easier to create invalid iterators.
     
    102134  typedef Digraph::ArcMap<int> IntArcMap;                               \
    103135  typedef Digraph::ArcMap<double> DoubleArcMap
    104136
     137#define DIGRAPH_TYPEDEFS_NOWARN(Digraph)                                \
     138  DIGRAPH_TYPEDEFS(Digraph);                                            \
     139  ignore_unused_warning<Node>();                                        \
     140  ignore_unused_warning<NodeIt>();                                      \
     141  ignore_unused_warning<Arc>();                                         \
     142  ignore_unused_warning<ArcIt>();                                       \
     143  ignore_unused_warning<InArcIt>();                                     \
     144  ignore_unused_warning<OutArcIt>();                                    \
     145  ignore_unused_warning<BoolNodeMap>();                                 \
     146  ignore_unused_warning<IntNodeMap>();                                  \
     147  ignore_unused_warning<DoubleNodeMap>();                               \
     148  ignore_unused_warning<BoolArcMap>();                                  \
     149  ignore_unused_warning<IntArcMap>();                                   \
     150  ignore_unused_warning<DoubleArcMap>()
    105151  ///Create convenience typedefs for the digraph types and iterators
    106152
    107153  ///\see DIGRAPH_TYPEDEFS
     
    122168  typedef typename Digraph::template ArcMap<int> IntArcMap;             \
    123169  typedef typename Digraph::template ArcMap<double> DoubleArcMap
    124170
     171#define TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph)                       \
     172  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);                                   \
     173  ignore_unused_warning<Node>();                                        \
     174  ignore_unused_warning<NodeIt>();                                      \
     175  ignore_unused_warning<Arc>();                                         \
     176  ignore_unused_warning<ArcIt>();                                       \
     177  ignore_unused_warning<InArcIt>();                                     \
     178  ignore_unused_warning<OutArcIt>();                                    \
     179  ignore_unused_warning<BoolNodeMap>();                                 \
     180  ignore_unused_warning<IntNodeMap>();                                  \
     181  ignore_unused_warning<DoubleNodeMap>();                               \
     182  ignore_unused_warning<BoolArcMap>();                                  \
     183  ignore_unused_warning<IntArcMap>();                                   \
     184  ignore_unused_warning<DoubleArcMap>()
     185
    125186  ///Create convenience typedefs for the graph types and iterators
    126187
    127188  ///This \c \#define creates the same convenient type definitions as defined
     
    141202  typedef Graph::EdgeMap<int> IntEdgeMap;                               \
    142203  typedef Graph::EdgeMap<double> DoubleEdgeMap
    143204
     205#define GRAPH_TYPEDEFS_NOWARN(Graph)                                    \
     206  GRAPH_TYPEDEFS(Graph);                                                \
     207  ignore_unused_warning<Node>();                                        \
     208  ignore_unused_warning<NodeIt>();                                      \
     209  ignore_unused_warning<Arc>();                                         \
     210  ignore_unused_warning<ArcIt>();                                       \
     211  ignore_unused_warning<InArcIt>();                                     \
     212  ignore_unused_warning<OutArcIt>();                                    \
     213  ignore_unused_warning<BoolNodeMap>();                                 \
     214  ignore_unused_warning<IntNodeMap>();                                  \
     215  ignore_unused_warning<DoubleNodeMap>();                               \
     216  ignore_unused_warning<BoolArcMap>();                                  \
     217  ignore_unused_warning<IntArcMap>();                                   \
     218  ignore_unused_warning<DoubleArcMap>();                                \
     219  ignore_unused_warning<Edge>();                                        \
     220  ignore_unused_warning<EdgeIt>();                                      \
     221  ignore_unused_warning<IncEdgeIt>();                                   \
     222  ignore_unused_warning<BoolEdgeMap>();                                 \
     223  ignore_unused_warning<IntEdgeMap>();                                  \
     224  ignore_unused_warning<DoubleEdgeMap>()                                \
     225 
     226
    144227  ///Create convenience typedefs for the graph types and iterators
    145228
    146229  ///\see GRAPH_TYPEDEFS
     
    156239  typedef typename Graph::template EdgeMap<int> IntEdgeMap;             \
    157240  typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
    158241
     242#define TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph)                           \
     243  TEMPLATE_GRAPH_TYPEDEFS(Graph);                                       \
     244  ignore_unused_warning<Node>();                                        \
     245  ignore_unused_warning<NodeIt>();                                      \
     246  ignore_unused_warning<Arc>();                                         \
     247  ignore_unused_warning<ArcIt>();                                       \
     248  ignore_unused_warning<InArcIt>();                                     \
     249  ignore_unused_warning<OutArcIt>();                                    \
     250  ignore_unused_warning<BoolNodeMap>();                                 \
     251  ignore_unused_warning<IntNodeMap>();                                  \
     252  ignore_unused_warning<DoubleNodeMap>();                               \
     253  ignore_unused_warning<BoolArcMap>();                                  \
     254  ignore_unused_warning<IntArcMap>();                                   \
     255  ignore_unused_warning<DoubleArcMap>();                                \
     256  ignore_unused_warning<Edge>();                                        \
     257  ignore_unused_warning<EdgeIt>();                                      \
     258  ignore_unused_warning<IncEdgeIt>();                                   \
     259  ignore_unused_warning<BoolEdgeMap>();                                 \
     260  ignore_unused_warning<IntEdgeMap>();                                  \
     261  ignore_unused_warning<DoubleEdgeMap>()                                \
     262
    159263  ///Create convenience typedefs for the bipartite graph types and iterators
    160264
    161265  ///This \c \#define creates the same convenient type definitions as
     
    180284  typedef BpGraph::BlueNodeMap<int> IntBlueNodeMap;                     \
    181285  typedef BpGraph::BlueNodeMap<double> DoubleBlueNodeMap
    182286
     287#define BPGRAPH_TYPEDEFS_NOWARN(BpGraph)                                \
     288  BPGRAPH_TYPEDEFS(BpGraph);                                            \
     289  ignore_unused_warning<Node>();                                        \
     290  ignore_unused_warning<NodeIt>();                                      \
     291  ignore_unused_warning<Arc>();                                         \
     292  ignore_unused_warning<ArcIt>();                                       \
     293  ignore_unused_warning<InArcIt>();                                     \
     294  ignore_unused_warning<OutArcIt>();                                    \
     295  ignore_unused_warning<BoolNodeMap>();                                 \
     296  ignore_unused_warning<IntNodeMap>();                                  \
     297  ignore_unused_warning<DoubleNodeMap>();                               \
     298  ignore_unused_warning<BoolArcMap>();                                  \
     299  ignore_unused_warning<IntArcMap>();                                   \
     300  ignore_unused_warning<DoubleArcMap>();                                \
     301  ignore_unused_warning<Edge>();                                        \
     302  ignore_unused_warning<EdgeIt>();                                      \
     303  ignore_unused_warning<IncEdgeIt>();                                   \
     304  ignore_unused_warning<BoolEdgeMap>();                                 \
     305  ignore_unused_warning<IntEdgeMap>();                                  \
     306  ignore_unused_warning<DoubleEdgeMap>();                               \
     307  ignore_unused_warning<RedNode>();                                     \
     308  ignore_unused_warning<RedNodeIt>();                                   \
     309  ignore_unused_warning<BoolRedNodeMap>();                              \
     310  ignore_unused_warning<IntRedNodeMap>();                               \
     311  ignore_unused_warning<DoubleRedNodeMap>();                            \
     312  ignore_unused_warning<BlueNode>();                                    \
     313  ignore_unused_warning<BlueNodeIt>();                                  \
     314  ignore_unused_warning<BoolBlueNodeMap>();                             \
     315  ignore_unused_warning<IntBlueNodeMap>();                              \
     316  ignore_unused_warning<DoubleBlueNodeMap>()                            \
     317
    183318  ///Create convenience typedefs for the bipartite graph types and iterators
    184319
    185320  ///\see BPGRAPH_TYPEDEFS
     
    199334  typedef typename BpGraph::template BlueNodeMap<int> IntBlueNodeMap;       \
    200335  typedef typename BpGraph::template BlueNodeMap<double> DoubleBlueNodeMap
    201336
     337 
     338#define TEMPLATE_BPGRAPH_TYPEDEFS_NOWARN(BpGraph)                       \
     339  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);                                   \
     340  ignore_unused_warning<Node>();                                        \
     341  ignore_unused_warning<NodeIt>();                                      \
     342  ignore_unused_warning<Arc>();                                         \
     343  ignore_unused_warning<ArcIt>();                                       \
     344  ignore_unused_warning<InArcIt>();                                     \
     345  ignore_unused_warning<OutArcIt>();                                    \
     346  ignore_unused_warning<BoolNodeMap>();                                 \
     347  ignore_unused_warning<IntNodeMap>();                                  \
     348  ignore_unused_warning<DoubleNodeMap>();                               \
     349  ignore_unused_warning<BoolArcMap>();                                  \
     350  ignore_unused_warning<IntArcMap>();                                   \
     351  ignore_unused_warning<DoubleArcMap>();                                \
     352  ignore_unused_warning<Edge>();                                        \
     353  ignore_unused_warning<EdgeIt>();                                      \
     354  ignore_unused_warning<IncEdgeIt>();                                   \
     355  ignore_unused_warning<BoolEdgeMap>();                                 \
     356  ignore_unused_warning<IntEdgeMap>();                                  \
     357  ignore_unused_warning<DoubleEdgeMap>();                               \
     358  ignore_unused_warning<RedNode>();                                     \
     359  ignore_unused_warning<RedNodeIt>();                                   \
     360  ignore_unused_warning<BoolRedNodeMap>();                              \
     361  ignore_unused_warning<IntRedNodeMap>();                               \
     362  ignore_unused_warning<DoubleRedNodeMap>();                            \
     363  ignore_unused_warning<BlueNode>();                                    \
     364  ignore_unused_warning<BlueNodeIt>();                                  \
     365  ignore_unused_warning<BoolBlueNodeMap>();                             \
     366  ignore_unused_warning<IntBlueNodeMap>();                              \
     367  ignore_unused_warning<DoubleBlueNodeMap>()                            \
     368
    202369  /// \brief Function to count the items in a graph.
    203370  ///
    204371  /// This function counts the items (nodes, arcs etc.) in a graph.
  • lemon/kruskal.h

    diff --git a/lemon/kruskal.h b/lemon/kruskal.h
    a b  
    4444      typedef typename In::value_type::second_type Value;
    4545      typedef typename Digraph::template NodeMap<int> IndexMap;
    4646      typedef typename Digraph::Node Node;
     47      ignore_unused_warning<Node>();
     48
    4749
    4850      IndexMap index(digraph);
    4951      UnionFind<IndexMap> uf(index);
     
    7375      typedef typename In::value_type::second_type Value;
    7476      typedef typename Graph::template NodeMap<int> IndexMap;
    7577      typedef typename Graph::Node Node;
     78      ignore_unused_warning<Node>();
    7679
    7780      IndexMap index(graph);
    7881      UnionFind<IndexMap> uf(index);
  • lemon/planarity.h

    diff --git a/lemon/planarity.h b/lemon/planarity.h
    a b  
    21002100    void drawing(const AuxGraph& graph,
    21012101                 const AuxEmbeddingMap& next,
    21022102                 PointMap& point_map) {
    2103       TEMPLATE_GRAPH_TYPEDEFS(AuxGraph);
     2103      TEMPLATE_GRAPH_TYPEDEFS_NOWARN(AuxGraph);
    21042104
    21052105      typename AuxGraph::template ArcMap<Arc> prev(graph);
    21062106
  • lemon/static_graph.h

    diff --git a/lemon/static_graph.h b/lemon/static_graph.h
    a b  
    145145    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
    146146    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
    147147      typedef typename Digraph::Node GNode;
     148      ignore_unused_warning<GNode>();
    148149      typedef typename Digraph::Arc GArc;
    149150
    150151      built = true;
  • test/bellman_ford_test.cc

    diff --git a/test/bellman_ford_test.cc b/test/bellman_ford_test.cc
    a b  
    168168
    169169template <typename Digraph, typename Value>
    170170void checkBellmanFord() {
    171   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     171  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    172172  typedef typename Digraph::template ArcMap<Value> LengthMap;
    173173
    174174  Digraph gr;
     
    227227}
    228228
    229229void checkBellmanFordNegativeCycle() {
    230   DIGRAPH_TYPEDEFS(SmartDigraph);
     230  DIGRAPH_TYPEDEFS_NOWARN(SmartDigraph);
    231231
    232232  SmartDigraph gr;
    233233  IntArcMap length(gr);
  • test/bfs_test.cc

    diff --git a/test/bfs_test.cc b/test/bfs_test.cc
    a b  
    180180
    181181template <class Digraph>
    182182void checkBfs() {
    183   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     183  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    184184
    185185  Digraph G;
    186186  Node s, t;
  • test/bpgraph_test.cc

    diff --git a/test/bpgraph_test.cc b/test/bpgraph_test.cc
    a b  
    2929
    3030template <class BpGraph>
    3131void checkBpGraphBuild() {
    32   TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
     32  TEMPLATE_BPGRAPH_TYPEDEFS_NOWARN(BpGraph);
    3333
    3434  BpGraph G;
    3535  checkGraphNodeList(G, 0);
     
    110110
    111111template <class BpGraph>
    112112void checkBpGraphErase() {
    113   TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
     113  TEMPLATE_BPGRAPH_TYPEDEFS_NOWARN(BpGraph);
    114114
    115115  BpGraph G;
    116116  RedNode
     
    159159
    160160template <class BpGraph>
    161161void checkBpGraphAlter() {
    162   TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
     162  TEMPLATE_BPGRAPH_TYPEDEFS_NOWARN(BpGraph);
    163163
    164164  BpGraph G;
    165165  RedNode
     
    211211
    212212template <class BpGraph>
    213213void checkBpGraphSnapshot() {
    214   TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
     214  TEMPLATE_BPGRAPH_TYPEDEFS_NOWARN(BpGraph);
    215215
    216216  BpGraph G;
    217217  RedNode
     
    296296
    297297template <typename BpGraph>
    298298void checkBpGraphValidity() {
    299   TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
     299  TEMPLATE_BPGRAPH_TYPEDEFS_NOWARN(BpGraph);
    300300  BpGraph g;
    301301
    302302  RedNode
     
    358358
    359359void checkFullBpGraph(int redNum, int blueNum) {
    360360  typedef FullBpGraph BpGraph;
    361   BPGRAPH_TYPEDEFS(BpGraph);
     361  BPGRAPH_TYPEDEFS_NOWARN(BpGraph);
    362362
    363363  BpGraph G(redNum, blueNum);
    364364  checkGraphNodeList(G, redNum + blueNum);
  • test/circulation_test.cc

    diff --git a/test/circulation_test.cc b/test/circulation_test.cc
    a b  
    126126int main (int, char*[])
    127127{
    128128  typedef ListDigraph Digraph;
    129   DIGRAPH_TYPEDEFS(Digraph);
     129  DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    130130
    131131  Digraph g;
    132132  IntArcMap lo(g), up(g);
  • test/dfs_test.cc

    diff --git a/test/dfs_test.cc b/test/dfs_test.cc
    a b  
    182182
    183183template <class Digraph>
    184184void checkDfs() {
    185   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     185  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    186186
    187187  Digraph G;
    188188  Node s, t;
  • test/digraph_test.cc

    diff --git a/test/digraph_test.cc b/test/digraph_test.cc
    a b  
    3030
    3131template <class Digraph>
    3232void checkDigraphBuild() {
    33   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     33  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    3434  Digraph G;
    3535
    3636  checkGraphNodeList(G, 0);
     
    8787
    8888template <class Digraph>
    8989void checkDigraphSplit() {
    90   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     90  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    9191
    9292  Digraph G;
    9393  Node n1 = G.addNode(), n2 = G.addNode(), n3 = G.addNode();
     
    119119
    120120template <class Digraph>
    121121void checkDigraphAlter() {
    122   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     122  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    123123
    124124  Digraph G;
    125125  Node n1 = G.addNode(), n2 = G.addNode(),
     
    199199
    200200template <class Digraph>
    201201void checkDigraphErase() {
    202   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     202  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    203203
    204204  Digraph G;
    205205  Node n1 = G.addNode(), n2 = G.addNode(),
     
    249249
    250250template <class Digraph>
    251251void checkDigraphSnapshot() {
    252   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     252  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    253253
    254254  Digraph G;
    255255  Node n1 = G.addNode(), n2 = G.addNode(), n3 = G.addNode();
     
    345345
    346346template <typename Digraph>
    347347void checkDigraphValidity() {
    348   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     348  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    349349  Digraph g;
    350350
    351351  Node
     
    367367
    368368template <typename Digraph>
    369369void checkDigraphValidityErase() {
    370   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     370  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    371371  Digraph g;
    372372
    373373  Node
     
    504504
    505505void checkFullDigraph(int num) {
    506506  typedef FullDigraph Digraph;
    507   DIGRAPH_TYPEDEFS(Digraph);
     507  DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    508508
    509509  Digraph G(num);
    510510  check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
  • test/dijkstra_test.cc

    diff --git a/test/dijkstra_test.cc b/test/dijkstra_test.cc
    a b  
    184184
    185185template <class Digraph>
    186186void checkDijkstra() {
    187   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     187  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    188188  typedef typename Digraph::template ArcMap<int> LengthMap;
    189189
    190190  Digraph G;
  • test/graph_test.cc

    diff --git a/test/graph_test.cc b/test/graph_test.cc
    a b  
    3131
    3232template <class Graph>
    3333void checkGraphBuild() {
    34   TEMPLATE_GRAPH_TYPEDEFS(Graph);
     34  TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph);
    3535
    3636  Graph G;
    3737  checkGraphNodeList(G, 0);
     
    9191
    9292template <class Graph>
    9393void checkGraphAlter() {
    94   TEMPLATE_GRAPH_TYPEDEFS(Graph);
     94  TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph);
    9595
    9696  Graph G;
    9797  Node n1 = G.addNode(), n2 = G.addNode(),
     
    171171
    172172template <class Graph>
    173173void checkGraphErase() {
    174   TEMPLATE_GRAPH_TYPEDEFS(Graph);
     174  TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph);
    175175
    176176  Graph G;
    177177  Node n1 = G.addNode(), n2 = G.addNode(),
     
    214214
    215215template <class Graph>
    216216void checkGraphSnapshot() {
    217   TEMPLATE_GRAPH_TYPEDEFS(Graph);
     217  TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph);
    218218
    219219  Graph G;
    220220  Node n1 = G.addNode(), n2 = G.addNode(), n3 = G.addNode();
     
    280280
    281281void checkFullGraph(int num) {
    282282  typedef FullGraph Graph;
    283   GRAPH_TYPEDEFS(Graph);
     283  GRAPH_TYPEDEFS_NOWARN(Graph);
    284284
    285285  Graph G(num);
    286286  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
     
    374374
    375375template <typename Graph>
    376376void checkGraphValidity() {
    377   TEMPLATE_GRAPH_TYPEDEFS(Graph);
     377  TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph);
    378378  Graph g;
    379379
    380380  Node
     
    398398
    399399template <typename Graph>
    400400void checkGraphValidityErase() {
    401   TEMPLATE_GRAPH_TYPEDEFS(Graph);
     401  TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph);
    402402  Graph g;
    403403
    404404  Node
     
    429429
    430430void checkGridGraph(int width, int height) {
    431431  typedef GridGraph Graph;
    432   GRAPH_TYPEDEFS(Graph);
     432  GRAPH_TYPEDEFS_NOWARN(Graph);
    433433  Graph G(width, height);
    434434
    435435  check(G.width() == width, "Wrong column number");
     
    511511}
    512512
    513513void checkHypercubeGraph(int dim) {
    514   GRAPH_TYPEDEFS(HypercubeGraph);
     514  GRAPH_TYPEDEFS_NOWARN(HypercubeGraph);
    515515
    516516  HypercubeGraph G(dim);
    517517  check(G.dimension() == dim, "Wrong dimension");
  • test/graph_test.h

    diff --git a/test/graph_test.h b/test/graph_test.h
    a b  
    268268  template <typename Graph>
    269269  void checkGraphNodeMap(const Graph& G) {
    270270    typedef typename Graph::Node Node;
     271    ignore_unused_warning<Node>();
    271272    typedef typename Graph::NodeIt NodeIt;
    272273
    273274    typedef typename Graph::template NodeMap<int> IntNodeMap;
     
    298299  template <typename Graph>
    299300  void checkGraphRedNodeMap(const Graph& G) {
    300301    typedef typename Graph::Node Node;
     302    ignore_unused_warning<Node>();
    301303    typedef typename Graph::RedNodeIt RedNodeIt;
    302304
    303305    typedef typename Graph::template RedNodeMap<int> IntRedNodeMap;
     
    328330  template <typename Graph>
    329331  void checkGraphBlueNodeMap(const Graph& G) {
    330332    typedef typename Graph::Node Node;
     333    ignore_unused_warning<Node>();
    331334    typedef typename Graph::BlueNodeIt BlueNodeIt;
    332335
    333336    typedef typename Graph::template BlueNodeMap<int> IntBlueNodeMap;
     
    358361  template <typename Graph>
    359362  void checkGraphArcMap(const Graph& G) {
    360363    typedef typename Graph::Arc Arc;
     364    ignore_unused_warning<Arc>();
    361365    typedef typename Graph::ArcIt ArcIt;
    362366
    363367    typedef typename Graph::template ArcMap<int> IntArcMap;
     
    388392  template <typename Graph>
    389393  void checkGraphEdgeMap(const Graph& G) {
    390394    typedef typename Graph::Edge Edge;
     395    ignore_unused_warning<Edge>();
    391396    typedef typename Graph::EdgeIt EdgeIt;
    392397
    393398    typedef typename Graph::template EdgeMap<int> IntEdgeMap;
  • test/graph_utils_test.cc

    diff --git a/test/graph_utils_test.cc b/test/graph_utils_test.cc
    a b  
    3131
    3232template <typename Digraph>
    3333void checkFindArcs() {
    34   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     34  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    3535
    3636  {
    3737    Digraph digraph;
     
    108108
    109109template <typename Graph>
    110110void checkFindEdges() {
    111   TEMPLATE_GRAPH_TYPEDEFS(Graph);
     111  TEMPLATE_GRAPH_TYPEDEFS_NOWARN(Graph);
    112112  Graph graph;
    113113  for (int i = 0; i < 10; ++i) {
    114114    graph.addNode();
     
    143143template <class Digraph>
    144144void checkDeg()
    145145{
    146   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     146  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    147147
    148148  const int nodeNum = 10;
    149149  const int arcNum = 100;
     
    171171template <class Digraph>
    172172void checkSnapDeg()
    173173{
    174   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     174  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    175175
    176176  Digraph g;
    177177  Node n1=g.addNode();
  • test/heap_test.cc

    diff --git a/test/heap_test.cc b/test/heap_test.cc
    a b  
    160160int main() {
    161161
    162162  typedef int Item;
     163  ignore_unused_warning<Item>();
    163164  typedef int Prio;
    164165  typedef RangeMap<int> ItemIntMap;
    165166
  • test/kruskal_test.cc

    diff --git a/test/kruskal_test.cc b/test/kruskal_test.cc
    a b  
    6363  typedef ListGraph::Node Node;
    6464  typedef ListGraph::Edge Edge;
    6565  typedef ListGraph::NodeIt NodeIt;
     66  ignore_unused_warning<NodeIt>();
    6667  typedef ListGraph::ArcIt ArcIt;
    67 
     68  ignore_unused_warning<ArcIt>();
     69 
    6870  ListGraph G;
    6971
    7072  Node s=G.addNode();
  • test/maps_test.cc

    diff --git a/test/maps_test.cc b/test/maps_test.cc
    a b  
    398398      check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
    399399
    400400    typedef ListDigraph Graph;
    401     DIGRAPH_TYPEDEFS(Graph);
     401    DIGRAPH_TYPEDEFS_NOWARN(Graph);
    402402    Graph gr;
    403403
    404404    Node n0 = gr.addNode();
     
    431431  // IdMap, RangeIdMap
    432432  {
    433433    typedef ListDigraph Graph;
    434     DIGRAPH_TYPEDEFS(Graph);
     434    DIGRAPH_TYPEDEFS_NOWARN(Graph);
    435435
    436436    checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
    437437    checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
     
    503503  // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
    504504  {
    505505    typedef ListGraph Graph;
    506     GRAPH_TYPEDEFS(Graph);
     506    GRAPH_TYPEDEFS_NOWARN(Graph);
    507507
    508508    checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
    509509    checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
     
    552552  // CrossRefMap
    553553  {
    554554    typedef ListDigraph Graph;
    555     DIGRAPH_TYPEDEFS(Graph);
     555    DIGRAPH_TYPEDEFS_NOWARN(Graph);
    556556
    557557    checkConcept<ReadWriteMap<Node, int>,
    558558                 CrossRefMap<Graph, Node, int> >();
     
    619619  // CrossRefMap
    620620  {
    621621    typedef SmartDigraph Graph;
    622     DIGRAPH_TYPEDEFS(Graph);
     622    DIGRAPH_TYPEDEFS_NOWARN(Graph);
    623623
    624624    checkConcept<ReadWriteMap<Node, int>,
    625625                 CrossRefMap<Graph, Node, int> >();
     
    846846  // mapFind(), mapFindIf(), mapCount(), mapCountIf()
    847847  // mapCopy(), mapCompare(), mapFill()
    848848  {
    849     DIGRAPH_TYPEDEFS(SmartDigraph);
     849    DIGRAPH_TYPEDEFS_NOWARN(SmartDigraph);
    850850
    851851    SmartDigraph g;
    852852    Node n1 = g.addNode();
  • test/max_flow_test.cc

    diff --git a/test/max_flow_test.cc b/test/max_flow_test.cc
    a b  
    130130          ::template SetFlowMap<FlowMap>
    131131          ::Create MaxFlowType;
    132132      typedef typename MF::Create MaxFlowType2;
     133      ignore_unused_warning<MaxFlowType2>();
    133134      MaxFlowType max_flow(me.g, me.cap, me.n, me.n);
    134135      const MaxFlowType& const_max_flow = max_flow;
    135136
     
    252253
    253254void checkInitPreflow()
    254255{
    255   DIGRAPH_TYPEDEFS(SmartDigraph);
     256  DIGRAPH_TYPEDEFS_NOWARN(SmartDigraph);
    256257
    257258  SmartDigraph g;
    258259  SmartDigraph::ArcMap<int> cap(g), iflow(g);
     
    277278template <typename MF, typename SF>
    278279void checkMaxFlowAlg(const char *input_lgf,  typename MF::Value expected) {
    279280  typedef SmartDigraph Digraph;
    280   DIGRAPH_TYPEDEFS(Digraph);
     281  DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    281282
    282283  typedef typename MF::Value Value;
    283284  typedef Digraph::ArcMap<Value> CapMap;
  • test/min_cost_arborescence_test.cc

    diff --git a/test/min_cost_arborescence_test.cc b/test/min_cost_arborescence_test.cc
    a b  
    133133
    134134int main() {
    135135  typedef SmartDigraph Digraph;
    136   DIGRAPH_TYPEDEFS(Digraph);
     136  DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    137137
    138138  typedef Digraph::ArcMap<double> CostMap;
    139139
  • test/min_cost_flow_test.cc

    diff --git a/test/min_cost_flow_test.cc b/test/min_cost_flow_test.cc
    a b  
    208208                const SM& supply, const FM& flow,
    209209                SupplyType type = EQ )
    210210{
    211   TEMPLATE_DIGRAPH_TYPEDEFS(GR);
     211  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(GR);
    212212
    213213  for (ArcIt e(gr); e != INVALID; ++e) {
    214214    if (flow[e] < lower[e] || flow[e] > upper[e]) return false;
     
    237237                     const CM& cost, const SM& supply, const FM& flow,
    238238                     const PM& pi, SupplyType type )
    239239{
    240   TEMPLATE_DIGRAPH_TYPEDEFS(GR);
     240  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(GR);
    241241
    242242  bool opt = true;
    243243  for (ArcIt e(gr); opt && e != INVALID; ++e) {
     
    271271                    const CM& cost, const SM& supply, const PM& pi,
    272272                    typename CM::Value total )
    273273{
    274   TEMPLATE_DIGRAPH_TYPEDEFS(GR);
     274  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(GR);
    275275
    276276  typename CM::Value dual_cost = 0;
    277277  SM red_supply(gr);
  • test/min_mean_cycle_test.cc

    diff --git a/test/min_mean_cycle_test.cc b/test/min_mean_cycle_test.cc
    a b  
    175175  // Run various tests
    176176  {
    177177    typedef SmartDigraph GR;
    178     DIGRAPH_TYPEDEFS(GR);
     178    DIGRAPH_TYPEDEFS_NOWARN(GR);
    179179
    180180    GR gr;
    181181    IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);
  • test/suurballe_test.cc

    diff --git a/test/suurballe_test.cc b/test/suurballe_test.cc
    a b  
    139139                typename Digraph::Node s, typename Digraph::Node t,
    140140                int value )
    141141{
    142   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     142  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    143143  for (ArcIt e(gr); e != INVALID; ++e)
    144144    if (!(flow[e] == 0 || flow[e] == 1)) return false;
    145145
     
    164164                      const FlowMap& flow, const PotentialMap& pi )
    165165{
    166166  // Check the "Complementary Slackness" optimality condition
    167   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     167  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    168168  bool opt = true;
    169169  for (ArcIt e(gr); e != INVALID; ++e) {
    170170    typename CostMap::Value red_cost =
     
    181181bool checkPath( const Digraph& gr, const Path& path,
    182182                typename Digraph::Node s, typename Digraph::Node t)
    183183{
    184   TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     184  TEMPLATE_DIGRAPH_TYPEDEFS_NOWARN(Digraph);
    185185  Node n = s;
    186186  for (int i = 0; i < path.length(); ++i) {
    187187    if (gr.source(path.nth(i)) != n) return false;
     
    193193
    194194int main()
    195195{
    196   DIGRAPH_TYPEDEFS(ListDigraph);
     196  DIGRAPH_TYPEDEFS_NOWARN(ListDigraph);
    197197
    198198  // Read the test digraph
    199199  ListDigraph digraph;
  • test/time_measure_test.cc

    diff --git a/test/time_measure_test.cc b/test/time_measure_test.cc
    a b  
    1717 */
    1818
    1919#include <lemon/time_measure.h>
    20 #include <lemon/concept_check.h>
     20#include <lemon/core.h>
    2121
    2222using namespace lemon;
    2323
  • test/tsp_test.cc

    diff --git a/test/tsp_test.cc b/test/tsp_test.cc
    a b  
    125125// Tests a TSP algorithm on small graphs
    126126template <typename TSP>
    127127void tspTestSmall(const std::string &alg_name) {
    128   GRAPH_TYPEDEFS(FullGraph);
     128  GRAPH_TYPEDEFS_NOWARN(FullGraph);
    129129
    130130  for (int n = 0; n <= 5; ++n) {
    131131    FullGraph g(n);
     
    164164// Tests a TSP algorithm on random graphs
    165165template <typename TSP>
    166166void tspTestRandom(const std::string &alg_name) {
    167   GRAPH_TYPEDEFS(FullGraph);
     167  GRAPH_TYPEDEFS_NOWARN(FullGraph);
    168168
    169169  FullGraph g(20);
    170170  FullGraph::NodeMap<dim2::Point<double> > pos(g);
     
    259259};
    260260
    261261int main() {
    262   GRAPH_TYPEDEFS(FullGraph);
     262  GRAPH_TYPEDEFS_NOWARN(FullGraph);
    263263
    264264  // metricCostTest();
    265265
  • tools/dimacs-to-lgf.cc

    diff --git a/tools/dimacs-to-lgf.cc b/tools/dimacs-to-lgf.cc
    a b  
    4848  typedef SmartDigraph Digraph;
    4949
    5050  typedef Digraph::Arc Arc;
     51  ignore_unused_warning<Arc>();
    5152  typedef Digraph::Node Node;
    5253  typedef Digraph::ArcIt ArcIt;
     54  ignore_unused_warning<ArcIt>();
    5355  typedef Digraph::NodeIt NodeIt;
     56  ignore_unused_warning<NodeIt>();
    5457  typedef Digraph::ArcMap<double> DoubleArcMap;
    5558  typedef Digraph::NodeMap<double> DoubleNodeMap;
    5659