COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changeset 938:70e2886211d5 in lemon-0.x for src


Ignore:
Timestamp:
10/05/04 11:41:05 (20 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1266
Message:

Many of ckeckCompileXYZ()'s are now in the corresponding skeleton headers.
(Tests for Symmetric Graphs are still to be moved)

Location:
src
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • src/lemon/skeletons/graph.h

    r921 r938  
    4646    /// like @ref ListGraph or
    4747    /// @ref SmartGraph will just refer to this structure.
     48    ///
     49    /// \todo A pages describing the concept of concept description would
     50    /// be nice.
    4851    class StaticGraph
    4952    {
    … …  
    443446    };
    444447
    445 
     448    struct DummyType {
     449      int value;
     450      DummyType() {}
     451      DummyType(int p) : value(p) {}
     452      DummyType& operator=(int p) { value = p; return *this;}
     453    };
     454   
     455    ///\brief Checks whether \c G meets the
     456    ///\ref lemon::skeleton::StaticGraph "StaticGraph" concept
     457    template<class Graph> void checkCompileStaticGraph(Graph &G)
     458    {
     459      typedef typename Graph::Node Node;
     460      typedef typename Graph::NodeIt NodeIt;
     461      typedef typename Graph::Edge Edge;
     462      typedef typename Graph::EdgeIt EdgeIt;
     463      typedef typename Graph::InEdgeIt InEdgeIt;
     464      typedef typename Graph::OutEdgeIt OutEdgeIt;
    446465 
     466      {
     467        Node i; Node j(i); Node k(INVALID);
     468        i=j;
     469        bool b; b=true;
     470        b=(i==INVALID); b=(i!=INVALID);
     471        b=(i==j); b=(i!=j); b=(i<j);
     472      }
     473      {
     474        NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);
     475        i=j;
     476        j=G.first(i);
     477        j=++i;
     478        bool b; b=true;
     479        b=(i==INVALID); b=(i!=INVALID);
     480        Node n(i);
     481        n=i;
     482        b=(i==j); b=(i!=j); b=(i<j);
     483        //Node ->NodeIt conversion
     484        NodeIt ni(G,n);
     485      }
     486      {
     487        Edge i; Edge j(i); Edge k(INVALID);
     488        i=j;
     489        bool b; b=true;
     490        b=(i==INVALID); b=(i!=INVALID);
     491        b=(i==j); b=(i!=j); b=(i<j);
     492      }
     493      {
     494        EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);
     495        i=j;
     496        j=G.first(i);
     497        j=++i;
     498        bool b; b=true;
     499        b=(i==INVALID); b=(i!=INVALID);
     500        Edge e(i);
     501        e=i;
     502        b=(i==j); b=(i!=j); b=(i<j);
     503        //Edge ->EdgeIt conversion
     504        EdgeIt ei(G,e);
     505      }
     506      {
     507        Node n;
     508        InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);
     509        i=j;
     510        j=G.first(i,n);
     511        j=++i;
     512        bool b; b=true;
     513        b=(i==INVALID); b=(i!=INVALID);
     514        Edge e(i);
     515        e=i;
     516        b=(i==j); b=(i!=j); b=(i<j);
     517        //Edge ->InEdgeIt conversion
     518        InEdgeIt ei(G,e);
     519      }
     520      {
     521        Node n;
     522        OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);
     523        i=j;
     524        j=G.first(i,n);
     525        j=++i;
     526        bool b; b=true;
     527        b=(i==INVALID); b=(i!=INVALID);
     528        Edge e(i);
     529        e=i;
     530        b=(i==j); b=(i!=j); b=(i<j);
     531        //Edge ->OutEdgeIt conversion
     532        OutEdgeIt ei(G,e);
     533      }
     534      {
     535        Node n,m;
     536        n=m=INVALID;
     537        Edge e;
     538        e=INVALID;
     539        n=G.tail(e);
     540        n=G.head(e);
     541      }
     542      // id tests
     543      { Node n; int i=G.id(n); i=i; }
     544      { Edge e; int i=G.id(e); i=i; }
     545      //NodeMap tests
     546      {
     547        Node k;
     548        typename Graph::template NodeMap<int> m(G);
     549        //Const map
     550        typename Graph::template NodeMap<int> const &cm = m;
     551        //Inicialize with default value
     552        typename Graph::template NodeMap<int> mdef(G,12);
     553        //Copy
     554        typename Graph::template NodeMap<int> mm(cm);
     555        //Copy from another type
     556        typename Graph::template NodeMap<double> dm(cm);
     557        //Copy to more complex type
     558        typename Graph::template NodeMap<DummyType> em(cm);
     559        int v;
     560        v=m[k]; m[k]=v; m.set(k,v);
     561        v=cm[k];
     562   
     563        m=cm; 
     564        dm=cm; //Copy from another type 
     565        em=cm; //Copy to more complex type
     566        {
     567          //Check the typedef's
     568          typename Graph::template NodeMap<int>::ValueType val;
     569          val=1;
     570          typename Graph::template NodeMap<int>::KeyType key;
     571          key = typename Graph::NodeIt(G);
     572        }
     573      } 
     574      { //bool NodeMap
     575        Node k;
     576        typename Graph::template NodeMap<bool> m(G);
     577        typename Graph::template NodeMap<bool> const &cm = m;  //Const map
     578        //Inicialize with default value
     579        typename Graph::template NodeMap<bool> mdef(G,12);
     580        typename Graph::template NodeMap<bool> mm(cm);   //Copy
     581        typename Graph::template NodeMap<int> dm(cm); //Copy from another type
     582        bool v;
     583        v=m[k]; m[k]=v; m.set(k,v);
     584        v=cm[k];
     585   
     586        m=cm; 
     587        dm=cm; //Copy from another type
     588        m=dm; //Copy to another type
     589
     590        {
     591          //Check the typedef's
     592          typename Graph::template NodeMap<bool>::ValueType val;
     593          val=true;
     594          typename Graph::template NodeMap<bool>::KeyType key;
     595          key= typename Graph::NodeIt(G);
     596        }
     597      }
     598      //EdgeMap tests
     599      {
     600        Edge k;
     601        typename Graph::template EdgeMap<int> m(G);
     602        typename Graph::template EdgeMap<int> const &cm = m;  //Const map
     603        //Inicialize with default value
     604        typename Graph::template EdgeMap<int> mdef(G,12);
     605        typename Graph::template EdgeMap<int> mm(cm);   //Copy
     606        typename Graph::template EdgeMap<double> dm(cm);//Copy from another type
     607        int v;
     608        v=m[k]; m[k]=v; m.set(k,v);
     609        v=cm[k];
     610   
     611        m=cm; 
     612        dm=cm; //Copy from another type
     613        {
     614          //Check the typedef's
     615          typename Graph::template EdgeMap<int>::ValueType val;
     616          val=1;
     617          typename Graph::template EdgeMap<int>::KeyType key;
     618          key= typename Graph::EdgeIt(G);
     619        }
     620      } 
     621      { //bool EdgeMap
     622        Edge k;
     623        typename Graph::template EdgeMap<bool> m(G);
     624        typename Graph::template EdgeMap<bool> const &cm = m;  //Const map
     625        //Inicialize with default value
     626        typename Graph::template EdgeMap<bool> mdef(G,12);
     627        typename Graph::template EdgeMap<bool> mm(cm);   //Copy
     628        typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
     629        bool v;
     630        v=m[k]; m[k]=v; m.set(k,v);
     631        v=cm[k];
     632   
     633        m=cm; 
     634        dm=cm; //Copy from another type
     635        m=dm; //Copy to another type
     636        {
     637          //Check the typedef's
     638          typename Graph::template EdgeMap<bool>::ValueType val;
     639          val=true;
     640          typename Graph::template EdgeMap<bool>::KeyType key;
     641          key= typename Graph::EdgeIt(G);
     642        }
     643      }
     644    }
     645   
    447646    /// An empty non-static graph class.
    448 
     647   
    449648    /// This class provides everything that \ref StaticGraph
    450649    /// with additional functionality which enables to build a
    … …  
    478677    };
    479678
     679   
     680    ///\brief Checks whether \c G meets the
     681    ///\ref lemon::skeleton::ExtendableGraph "ExtendableGraph" concept
     682    template<class Graph> void checkCompileExtendableGraph(Graph &G)
     683    {
     684      checkCompileStaticGraph(G);
     685
     686      typedef typename Graph::Node Node;
     687      typedef typename Graph::NodeIt NodeIt;
     688      typedef typename Graph::Edge Edge;
     689      typedef typename Graph::EdgeIt EdgeIt;
     690      typedef typename Graph::InEdgeIt InEdgeIt;
     691      typedef typename Graph::OutEdgeIt OutEdgeIt;
     692 
     693      Node n,m;
     694      n=G.addNode();
     695      m=G.addNode();
     696      Edge e;
     697      e=G.addEdge(n,m);
     698 
     699      //  G.clear();
     700    }
     701
     702
    480703    /// An empty erasable graph class.
    481704 
    … …  
    501724      void erase(Edge e) { }
    502725    };
    503 
     726   
     727    template<class Graph> void checkCompileGraphEraseEdge(Graph &G)
     728    {
     729      typename Graph::Edge e;
     730      G.erase(e);
     731    }
     732
     733    template<class Graph> void checkCompileGraphEraseNode(Graph &G)
     734    {
     735      typename Graph::Node n;
     736      G.erase(n);
     737    }
     738
     739    ///\brief Checks whether \c G meets the
     740    ///\ref lemon::skeleton::EresableGraph "EresableGraph" concept
     741    template<class Graph> void checkCompileErasableGraph(Graph &G)
     742    {
     743      checkCompileExtendableGraph(G);
     744      checkCompileGraphEraseNode(G);
     745      checkCompileGraphEraseEdge(G);
     746    }
     747
     748    ///Checks whether a graph has findEdge() member function.
     749   
     750    ///\todo findEdge() might be a global function.
     751    ///
     752    template<class Graph> void checkCompileGraphFindEdge(Graph &G)
     753    {
     754      typedef typename Graph::NodeIt Node;
     755      typedef typename Graph::NodeIt NodeIt;
     756
     757      G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G)));
     758      G.findEdge(Node(),Node(),G.findEdge(Node(),Node())); 
     759    }
     760 
    504761    // @}
    505762  } //namespace skeleton 

  • src/test/Makefile.am

    r937 r938  
    33EXTRA_DIST = preflow_graph.dim #input file for preflow_test.cc
    44
    5 noinst_HEADERS = test_tools.h graph_test.h
     5noinst_HEADERS = test_tools.h graph_test.h sym_graph_test.h
    66
    77check_PROGRAMS = \

  • src/test/graph_test.cc

    r937 r938  
    6868
    6969//Compile Graph
    70 template void lemon::checkCompileStaticGraph<skeleton::StaticGraph>
     70template void lemon::skeleton::checkCompileStaticGraph<skeleton::StaticGraph>
    7171(skeleton::StaticGraph &);
    7272
    73 template void lemon::checkCompileGraph<skeleton::ExtendableGraph>
     73template
     74void lemon::skeleton::checkCompileExtendableGraph<skeleton::ExtendableGraph>
    7475(skeleton::ExtendableGraph &);
    7576
    76 template void lemon::checkCompileErasableGraph<skeleton::ErasableGraph>
     77template
     78void lemon::skeleton::checkCompileErasableGraph<skeleton::ErasableGraph>
    7779(skeleton::ErasableGraph &);
    7880
    7981//Compile SmartGraph
    80 template void lemon::checkCompileGraph<SmartGraph>(SmartGraph &);
    81 template void lemon::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
     82template
     83void lemon::skeleton::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
     84template
     85void lemon::skeleton::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
    8286
    8387//Compile SymSmartGraph
    … …  
    8690
    8791//Compile ListGraph
    88 template void lemon::checkCompileGraph<ListGraph>(ListGraph &);
    89 template void lemon::checkCompileErasableGraph<ListGraph>(ListGraph &);
    90 template void lemon::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
     92template
     93void lemon::skeleton::checkCompileExtendableGraph<ListGraph>(ListGraph &);
     94template
     95void lemon::skeleton::checkCompileErasableGraph<ListGraph>(ListGraph &);
     96template
     97void lemon::skeleton::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
    9198
    9299
    … …  
    97104
    98105//Compile FullGraph
    99 template void lemon::checkCompileStaticGraph<FullGraph>(FullGraph &);
    100 template void lemon::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
     106template void lemon::skeleton::checkCompileStaticGraph<FullGraph>(FullGraph &);
     107template
     108void lemon::skeleton::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
    101109
    102110//Compile EdgeSet <ListGraph>
    103 template void lemon::checkCompileGraph<EdgeSet <ListGraph> >
     111template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <ListGraph> >
    104112(EdgeSet <ListGraph> &);
    105 template void lemon::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
     113template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
    106114(EdgeSet <ListGraph> &);
    107 template void lemon::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
     115template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
    108116(EdgeSet <ListGraph> &);
    109117
    110118//Compile EdgeSet <NodeSet>
    111 template void lemon::checkCompileGraph<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
    112 template void lemon::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
     119template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <NodeSet> >
    113120(EdgeSet <NodeSet> &);
    114 template void lemon::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
     121template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
     122(EdgeSet <NodeSet> &);
     123template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
    115124(EdgeSet <NodeSet> &);
    116125

  • src/test/graph_test.h

    r937 r938  
    2424//! \brief Some utility to  test graph classes.
    2525namespace lemon {
    26 
    27   struct DummyType {
    28     int value;
    29     DummyType() {}
    30     DummyType(int p) : value(p) {}
    31     DummyType& operator=(int p) { value = p; return *this;}
    32   };
    33 
    34 
    35   template<class Graph> void checkCompileStaticGraph(Graph &G)
    36     {
    37       typedef typename Graph::Node Node;
    38       typedef typename Graph::NodeIt NodeIt;
    39       typedef typename Graph::Edge Edge;
    40       typedef typename Graph::EdgeIt EdgeIt;
    41       typedef typename Graph::InEdgeIt InEdgeIt;
    42       typedef typename Graph::OutEdgeIt OutEdgeIt;
    43  
    44       {
    45         Node i; Node j(i); Node k(INVALID);
    46         i=j;
    47         bool b; b=true;
    48         b=(i==INVALID); b=(i!=INVALID);
    49         b=(i==j); b=(i!=j); b=(i<j);
    50       }
    51       {
    52         NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);
    53         i=j;
    54         j=G.first(i);
    55         j=++i;
    56         bool b; b=true;
    57         b=(i==INVALID); b=(i!=INVALID);
    58         Node n(i);
    59         n=i;
    60         b=(i==j); b=(i!=j); b=(i<j);
    61         //Node ->NodeIt conversion
    62         NodeIt ni(G,n);
    63       }
    64       {
    65         Edge i; Edge j(i); Edge k(INVALID);
    66         i=j;
    67         bool b; b=true;
    68         b=(i==INVALID); b=(i!=INVALID);
    69         b=(i==j); b=(i!=j); b=(i<j);
    70       }
    71       {
    72         EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);
    73         i=j;
    74         j=G.first(i);
    75         j=++i;
    76         bool b; b=true;
    77         b=(i==INVALID); b=(i!=INVALID);
    78         Edge e(i);
    79         e=i;
    80         b=(i==j); b=(i!=j); b=(i<j);
    81         //Edge ->EdgeIt conversion
    82         EdgeIt ei(G,e);
    83       }
    84       {
    85         Node n;
    86         InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);
    87         i=j;
    88         j=G.first(i,n);
    89         j=++i;
    90         bool b; b=true;
    91         b=(i==INVALID); b=(i!=INVALID);
    92         Edge e(i);
    93         e=i;
    94         b=(i==j); b=(i!=j); b=(i<j);
    95         //Edge ->InEdgeIt conversion
    96         InEdgeIt ei(G,e);
    97       }
    98       {
    99         Node n;
    100         OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);
    101         i=j;
    102         j=G.first(i,n);
    103         j=++i;
    104         bool b; b=true;
    105         b=(i==INVALID); b=(i!=INVALID);
    106         Edge e(i);
    107         e=i;
    108         b=(i==j); b=(i!=j); b=(i<j);
    109         //Edge ->OutEdgeIt conversion
    110         OutEdgeIt ei(G,e);
    111       }
    112       {
    113         Node n,m;
    114         n=m=INVALID;
    115         Edge e;
    116         e=INVALID;
    117         n=G.tail(e);
    118         n=G.head(e);
    119       }
    120       // id tests
    121       { Node n; int i=G.id(n); i=i; }
    122       { Edge e; int i=G.id(e); i=i; }
    123       //NodeMap tests
    124       {
    125         Node k;
    126         typename Graph::template NodeMap<int> m(G);
    127         //Const map
    128         typename Graph::template NodeMap<int> const &cm = m;
    129         //Inicialize with default value
    130         typename Graph::template NodeMap<int> mdef(G,12);
    131         //Copy
    132         typename Graph::template NodeMap<int> mm(cm);
    133         //Copy from another type
    134         typename Graph::template NodeMap<double> dm(cm);
    135         //Copy to more complex type
    136         typename Graph::template NodeMap<DummyType> em(cm);
    137         int v;
    138         v=m[k]; m[k]=v; m.set(k,v);
    139         v=cm[k];
    140    
    141         m=cm; 
    142         dm=cm; //Copy from another type 
    143         em=cm; //Copy to more complex type
    144         {
    145           //Check the typedef's
    146           typename Graph::template NodeMap<int>::ValueType val;
    147           val=1;
    148           typename Graph::template NodeMap<int>::KeyType key;
    149           key = typename Graph::NodeIt(G);
    150         }
    151       } 
    152       { //bool NodeMap
    153         Node k;
    154         typename Graph::template NodeMap<bool> m(G);
    155         typename Graph::template NodeMap<bool> const &cm = m;  //Const map
    156         //Inicialize with default value
    157         typename Graph::template NodeMap<bool> mdef(G,12);
    158         typename Graph::template NodeMap<bool> mm(cm);   //Copy
    159         typename Graph::template NodeMap<int> dm(cm); //Copy from another type
    160         bool v;
    161         v=m[k]; m[k]=v; m.set(k,v);
    162         v=cm[k];
    163    
    164         m=cm; 
    165         dm=cm; //Copy from another type
    166         m=dm; //Copy to another type
    167 
    168         {
    169           //Check the typedef's
    170           typename Graph::template NodeMap<bool>::ValueType val;
    171           val=true;
    172           typename Graph::template NodeMap<bool>::KeyType key;
    173           key= typename Graph::NodeIt(G);
    174         }
    175       }
    176       //EdgeMap tests
    177       {
    178         Edge k;
    179         typename Graph::template EdgeMap<int> m(G);
    180         typename Graph::template EdgeMap<int> const &cm = m;  //Const map
    181         //Inicialize with default value
    182         typename Graph::template EdgeMap<int> mdef(G,12);
    183         typename Graph::template EdgeMap<int> mm(cm);   //Copy
    184         typename Graph::template EdgeMap<double> dm(cm); //Copy from another type
    185         int v;
    186         v=m[k]; m[k]=v; m.set(k,v);
    187         v=cm[k];
    188    
    189         m=cm; 
    190         dm=cm; //Copy from another type
    191         {
    192           //Check the typedef's
    193           typename Graph::template EdgeMap<int>::ValueType val;
    194           val=1;
    195           typename Graph::template EdgeMap<int>::KeyType key;
    196           key= typename Graph::EdgeIt(G);
    197         }
    198       } 
    199       { //bool EdgeMap
    200         Edge k;
    201         typename Graph::template EdgeMap<bool> m(G);
    202         typename Graph::template EdgeMap<bool> const &cm = m;  //Const map
    203         //Inicialize with default value
    204         typename Graph::template EdgeMap<bool> mdef(G,12);
    205         typename Graph::template EdgeMap<bool> mm(cm);   //Copy
    206         typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
    207         bool v;
    208         v=m[k]; m[k]=v; m.set(k,v);
    209         v=cm[k];
    210    
    211         m=cm; 
    212         dm=cm; //Copy from another type
    213         m=dm; //Copy to another type
    214         {
    215           //Check the typedef's
    216           typename Graph::template EdgeMap<bool>::ValueType val;
    217           val=true;
    218           typename Graph::template EdgeMap<bool>::KeyType key;
    219           key= typename Graph::EdgeIt(G);
    220         }
    221       }
    222     }
    223 
    224   template<class Graph> void checkCompileGraph(Graph &G)
    225     {
    226       checkCompileStaticGraph(G);
    227 
    228       typedef typename Graph::Node Node;
    229       typedef typename Graph::NodeIt NodeIt;
    230       typedef typename Graph::Edge Edge;
    231       typedef typename Graph::EdgeIt EdgeIt;
    232       typedef typename Graph::InEdgeIt InEdgeIt;
    233       typedef typename Graph::OutEdgeIt OutEdgeIt;
    234  
    235       Node n,m;
    236       n=G.addNode();
    237       m=G.addNode();
    238       Edge e;
    239       e=G.addEdge(n,m);
    240  
    241       //  G.clear();
    242     }
    243 
    244   template<class Graph> void checkCompileGraphEraseEdge(Graph &G)
    245     {
    246       typename Graph::Edge e;
    247       G.erase(e);
    248     }
    249 
    250   template<class Graph> void checkCompileGraphEraseNode(Graph &G)
    251     {
    252       typename Graph::Node n;
    253       G.erase(n);
    254     }
    255 
    256   template<class Graph> void checkCompileErasableGraph(Graph &G)
    257     {
    258       checkCompileGraph(G);
    259       checkCompileGraphEraseNode(G);
    260       checkCompileGraphEraseEdge(G);
    261     }
    262 
    263   template<class Graph> void checkCompileGraphFindEdge(Graph &G)
    264     {
    265       typedef typename Graph::NodeIt Node;
    266       typedef typename Graph::NodeIt NodeIt;
    267 
    268       G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G)));
    269       G.findEdge(Node(),Node(),G.findEdge(Node(),Node())); 
    270     }
    27126
    27227  template<class Graph> void checkGraphNodeList(Graph &G, int nn)

  • src/test/graph_wrapper_test.cc

    r933 r938  
    3939//Compile GraphWrapper
    4040typedef GraphWrapper<Graph> GW;
    41 template void checkCompileStaticGraph<GW>(GW &);
     41template void lemon::skeleton::checkCompileStaticGraph<GW>(GW &);
    4242
    4343//Compile RevGraphWrapper
    4444typedef RevGraphWrapper<Graph> RevGW;
    45 template void checkCompileStaticGraph<RevGW>(RevGW &);
     45template void lemon::skeleton::checkCompileStaticGraph<RevGW>(RevGW &);
    4646
    4747//Compile SubGraphWrapper
    4848typedef SubGraphWrapper<Graph, Graph::NodeMap<bool>,
    4949                        Graph::EdgeMap<bool> > SubGW;
    50 template void checkCompileStaticGraph<SubGW>(SubGW &);
     50template void lemon::skeleton::checkCompileStaticGraph<SubGW>(SubGW &);
    5151
    5252//Compile NodeSubGraphWrapper
    5353typedef NodeSubGraphWrapper<Graph, Graph::NodeMap<bool> > NodeSubGW;
    54 template void checkCompileStaticGraph<NodeSubGW>(NodeSubGW &);
     54template void lemon::skeleton::checkCompileStaticGraph<NodeSubGW>(NodeSubGW &);
    5555
    5656//Compile EdgeSubGraphWrapper
    5757typedef EdgeSubGraphWrapper<Graph, Graph::EdgeMap<bool> > EdgeSubGW;
    58 template void checkCompileStaticGraph<EdgeSubGW>(EdgeSubGW &);
     58template void lemon::skeleton::checkCompileStaticGraph<EdgeSubGW>(EdgeSubGW &);
    5959
    6060//Compile UndirGraphWrapper
    … …  
    7070typedef SubBidirGraphWrapper<Graph, Graph::EdgeMap<bool>,
    7171                             Graph::EdgeMap<bool> > SubBDGW;
    72 template void checkCompileStaticGraph<SubBDGW>(SubBDGW &);
     72template void lemon::skeleton::checkCompileStaticGraph<SubBDGW>(SubBDGW &);
    7373
    7474//Compile BidirGraphWrapper
    7575typedef BidirGraphWrapper<Graph> BidirGW;
    76 template void checkCompileStaticGraph<BidirGW>(BidirGW &);
     76template void lemon::skeleton::checkCompileStaticGraph<BidirGW>(BidirGW &);
    7777
    7878//Compile BidirGraph
    7979typedef BidirGraph<Graph> BidirG;
    80 template void checkCompileStaticGraph<BidirG>(BidirG &);
     80template void lemon::skeleton::checkCompileStaticGraph<BidirG>(BidirG &);
    8181
    8282//Compile ResGraphWrapper
    8383typedef ResGraphWrapper<Graph, int, Graph::EdgeMap<int>,
    8484                        Graph::EdgeMap<int> > ResGW;
    85 template void checkCompileStaticGraph<ResGW>(ResGW &);
     85template void lemon::skeleton::checkCompileStaticGraph<ResGW>(ResGW &);
    8686
    8787//Compile ErasingFirstGraphWrapper
    8888typedef ErasingFirstGraphWrapper<Graph, Graph::NodeMap<Graph::Edge> > ErasingFirstGW;
    89 template void checkCompileStaticGraph<ErasingFirstGW>(ErasingFirstGW &);
     89template
     90void lemon::skeleton::checkCompileStaticGraph<ErasingFirstGW>(ErasingFirstGW &);
    9091
    9192

  • src/test/sym_graph_test.cc

    r937 r938  
    6767//Compile SymSmartGraph
    6868template void lemon::checkCompileSymGraph<SymSmartGraph>(SymSmartGraph &);
    69 template void lemon::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
     69template
     70void lemon::skeleton::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
    7071
    7172//Compile SymListGraph
    7273template void lemon::checkCompileSymGraph<SymListGraph>(SymListGraph &);
    7374template void lemon::checkCompileErasableSymGraph<SymListGraph>(SymListGraph &);
    74 template void lemon::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
     75template
     76void lemon::skeleton::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
    7577
    7678int main()

  • src/test/sym_graph_test.h

    r937 r938  
    2525//! \brief Some utility to test symmetric graph classes.
    2626namespace lemon {
     27 
     28  /// \e
    2729
     30  /// \todo This should go to lemon/skeleton/symgraph.h
     31  ///
    2832  template<class Graph> void checkCompileStaticSymGraph(Graph &G)
    2933    {
    … …  
    3741      typedef typename Graph::OutEdgeIt OutEdgeIt;
    3842
    39       checkCompileStaticGraph(G);
     43      lemon::skeleton::checkCompileStaticGraph(G);
    4044 
    4145      {
    … …  
    154158    {
    155159      checkCompileSymGraph(G);
    156       checkCompileGraphEraseNode(G);
     160      lemon::skeleton::checkCompileGraphEraseNode(G);
    157161      checkCompileSymGraphEraseSymEdge(G);
    158162    }
Note: See TracChangeset for help on using the changeset viewer.