[Lemon-commits] [lemon_svn] alpar: r1266 - in hugo/trunk/src: lemon/skeletons test
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:44:16 CET 2006
Author: alpar
Date: Tue Oct 5 11:41:05 2004
New Revision: 1266
Modified:
hugo/trunk/src/lemon/skeletons/graph.h
hugo/trunk/src/test/Makefile.am
hugo/trunk/src/test/graph_test.cc
hugo/trunk/src/test/graph_test.h
hugo/trunk/src/test/graph_wrapper_test.cc
hugo/trunk/src/test/sym_graph_test.cc
hugo/trunk/src/test/sym_graph_test.h
Log:
Many of ckeckCompileXYZ()'s are now in the corresponding skeleton headers.
(Tests for Symmetric Graphs are still to be moved)
Modified: hugo/trunk/src/lemon/skeletons/graph.h
==============================================================================
--- hugo/trunk/src/lemon/skeletons/graph.h (original)
+++ hugo/trunk/src/lemon/skeletons/graph.h Tue Oct 5 11:41:05 2004
@@ -45,6 +45,9 @@
/// feature, the documentation of a real graph imlementation
/// like @ref ListGraph or
/// @ref SmartGraph will just refer to this structure.
+ ///
+ /// \todo A pages describing the concept of concept description would
+ /// be nice.
class StaticGraph
{
public:
@@ -442,10 +445,206 @@
};
};
-
+ struct DummyType {
+ int value;
+ DummyType() {}
+ DummyType(int p) : value(p) {}
+ DummyType& operator=(int p) { value = p; return *this;}
+ };
+
+ ///\brief Checks whether \c G meets the
+ ///\ref lemon::skeleton::StaticGraph "StaticGraph" concept
+ template<class Graph> void checkCompileStaticGraph(Graph &G)
+ {
+ typedef typename Graph::Node Node;
+ typedef typename Graph::NodeIt NodeIt;
+ typedef typename Graph::Edge Edge;
+ typedef typename Graph::EdgeIt EdgeIt;
+ typedef typename Graph::InEdgeIt InEdgeIt;
+ typedef typename Graph::OutEdgeIt OutEdgeIt;
+ {
+ Node i; Node j(i); Node k(INVALID);
+ i=j;
+ bool b; b=true;
+ b=(i==INVALID); b=(i!=INVALID);
+ b=(i==j); b=(i!=j); b=(i<j);
+ }
+ {
+ NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);
+ i=j;
+ j=G.first(i);
+ j=++i;
+ bool b; b=true;
+ b=(i==INVALID); b=(i!=INVALID);
+ Node n(i);
+ n=i;
+ b=(i==j); b=(i!=j); b=(i<j);
+ //Node ->NodeIt conversion
+ NodeIt ni(G,n);
+ }
+ {
+ Edge i; Edge j(i); Edge k(INVALID);
+ i=j;
+ bool b; b=true;
+ b=(i==INVALID); b=(i!=INVALID);
+ b=(i==j); b=(i!=j); b=(i<j);
+ }
+ {
+ EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);
+ i=j;
+ j=G.first(i);
+ j=++i;
+ bool b; b=true;
+ b=(i==INVALID); b=(i!=INVALID);
+ Edge e(i);
+ e=i;
+ b=(i==j); b=(i!=j); b=(i<j);
+ //Edge ->EdgeIt conversion
+ EdgeIt ei(G,e);
+ }
+ {
+ Node n;
+ InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);
+ i=j;
+ j=G.first(i,n);
+ j=++i;
+ bool b; b=true;
+ b=(i==INVALID); b=(i!=INVALID);
+ Edge e(i);
+ e=i;
+ b=(i==j); b=(i!=j); b=(i<j);
+ //Edge ->InEdgeIt conversion
+ InEdgeIt ei(G,e);
+ }
+ {
+ Node n;
+ OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);
+ i=j;
+ j=G.first(i,n);
+ j=++i;
+ bool b; b=true;
+ b=(i==INVALID); b=(i!=INVALID);
+ Edge e(i);
+ e=i;
+ b=(i==j); b=(i!=j); b=(i<j);
+ //Edge ->OutEdgeIt conversion
+ OutEdgeIt ei(G,e);
+ }
+ {
+ Node n,m;
+ n=m=INVALID;
+ Edge e;
+ e=INVALID;
+ n=G.tail(e);
+ n=G.head(e);
+ }
+ // id tests
+ { Node n; int i=G.id(n); i=i; }
+ { Edge e; int i=G.id(e); i=i; }
+ //NodeMap tests
+ {
+ Node k;
+ typename Graph::template NodeMap<int> m(G);
+ //Const map
+ typename Graph::template NodeMap<int> const &cm = m;
+ //Inicialize with default value
+ typename Graph::template NodeMap<int> mdef(G,12);
+ //Copy
+ typename Graph::template NodeMap<int> mm(cm);
+ //Copy from another type
+ typename Graph::template NodeMap<double> dm(cm);
+ //Copy to more complex type
+ typename Graph::template NodeMap<DummyType> em(cm);
+ int v;
+ v=m[k]; m[k]=v; m.set(k,v);
+ v=cm[k];
+
+ m=cm;
+ dm=cm; //Copy from another type
+ em=cm; //Copy to more complex type
+ {
+ //Check the typedef's
+ typename Graph::template NodeMap<int>::ValueType val;
+ val=1;
+ typename Graph::template NodeMap<int>::KeyType key;
+ key = typename Graph::NodeIt(G);
+ }
+ }
+ { //bool NodeMap
+ Node k;
+ typename Graph::template NodeMap<bool> m(G);
+ typename Graph::template NodeMap<bool> const &cm = m; //Const map
+ //Inicialize with default value
+ typename Graph::template NodeMap<bool> mdef(G,12);
+ typename Graph::template NodeMap<bool> mm(cm); //Copy
+ typename Graph::template NodeMap<int> dm(cm); //Copy from another type
+ bool v;
+ v=m[k]; m[k]=v; m.set(k,v);
+ v=cm[k];
+
+ m=cm;
+ dm=cm; //Copy from another type
+ m=dm; //Copy to another type
+
+ {
+ //Check the typedef's
+ typename Graph::template NodeMap<bool>::ValueType val;
+ val=true;
+ typename Graph::template NodeMap<bool>::KeyType key;
+ key= typename Graph::NodeIt(G);
+ }
+ }
+ //EdgeMap tests
+ {
+ Edge k;
+ typename Graph::template EdgeMap<int> m(G);
+ typename Graph::template EdgeMap<int> const &cm = m; //Const map
+ //Inicialize with default value
+ typename Graph::template EdgeMap<int> mdef(G,12);
+ typename Graph::template EdgeMap<int> mm(cm); //Copy
+ typename Graph::template EdgeMap<double> dm(cm);//Copy from another type
+ int v;
+ v=m[k]; m[k]=v; m.set(k,v);
+ v=cm[k];
+
+ m=cm;
+ dm=cm; //Copy from another type
+ {
+ //Check the typedef's
+ typename Graph::template EdgeMap<int>::ValueType val;
+ val=1;
+ typename Graph::template EdgeMap<int>::KeyType key;
+ key= typename Graph::EdgeIt(G);
+ }
+ }
+ { //bool EdgeMap
+ Edge k;
+ typename Graph::template EdgeMap<bool> m(G);
+ typename Graph::template EdgeMap<bool> const &cm = m; //Const map
+ //Inicialize with default value
+ typename Graph::template EdgeMap<bool> mdef(G,12);
+ typename Graph::template EdgeMap<bool> mm(cm); //Copy
+ typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
+ bool v;
+ v=m[k]; m[k]=v; m.set(k,v);
+ v=cm[k];
+
+ m=cm;
+ dm=cm; //Copy from another type
+ m=dm; //Copy to another type
+ {
+ //Check the typedef's
+ typename Graph::template EdgeMap<bool>::ValueType val;
+ val=true;
+ typename Graph::template EdgeMap<bool>::KeyType key;
+ key= typename Graph::EdgeIt(G);
+ }
+ }
+ }
+
/// An empty non-static graph class.
-
+
/// This class provides everything that \ref StaticGraph
/// with additional functionality which enables to build a
/// graph from scratch.
@@ -477,6 +676,30 @@
void clear() { }
};
+
+ ///\brief Checks whether \c G meets the
+ ///\ref lemon::skeleton::ExtendableGraph "ExtendableGraph" concept
+ template<class Graph> void checkCompileExtendableGraph(Graph &G)
+ {
+ checkCompileStaticGraph(G);
+
+ typedef typename Graph::Node Node;
+ typedef typename Graph::NodeIt NodeIt;
+ typedef typename Graph::Edge Edge;
+ typedef typename Graph::EdgeIt EdgeIt;
+ typedef typename Graph::InEdgeIt InEdgeIt;
+ typedef typename Graph::OutEdgeIt OutEdgeIt;
+
+ Node n,m;
+ n=G.addNode();
+ m=G.addNode();
+ Edge e;
+ e=G.addEdge(n,m);
+
+ // G.clear();
+ }
+
+
/// An empty erasable graph class.
/// This class is an extension of \ref ExtendableGraph. It also makes it
@@ -500,7 +723,41 @@
///
void erase(Edge e) { }
};
+
+ template<class Graph> void checkCompileGraphEraseEdge(Graph &G)
+ {
+ typename Graph::Edge e;
+ G.erase(e);
+ }
+
+ template<class Graph> void checkCompileGraphEraseNode(Graph &G)
+ {
+ typename Graph::Node n;
+ G.erase(n);
+ }
+
+ ///\brief Checks whether \c G meets the
+ ///\ref lemon::skeleton::EresableGraph "EresableGraph" concept
+ template<class Graph> void checkCompileErasableGraph(Graph &G)
+ {
+ checkCompileExtendableGraph(G);
+ checkCompileGraphEraseNode(G);
+ checkCompileGraphEraseEdge(G);
+ }
+
+ ///Checks whether a graph has findEdge() member function.
+
+ ///\todo findEdge() might be a global function.
+ ///
+ template<class Graph> void checkCompileGraphFindEdge(Graph &G)
+ {
+ typedef typename Graph::NodeIt Node;
+ typedef typename Graph::NodeIt NodeIt;
+ G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G)));
+ G.findEdge(Node(),Node(),G.findEdge(Node(),Node()));
+ }
+
// @}
} //namespace skeleton
} //namespace lemon
Modified: hugo/trunk/src/test/Makefile.am
==============================================================================
--- hugo/trunk/src/test/Makefile.am (original)
+++ hugo/trunk/src/test/Makefile.am Tue Oct 5 11:41:05 2004
@@ -2,7 +2,7 @@
EXTRA_DIST = preflow_graph.dim #input file for preflow_test.cc
-noinst_HEADERS = test_tools.h graph_test.h
+noinst_HEADERS = test_tools.h graph_test.h sym_graph_test.h
check_PROGRAMS = \
bfs_test \
Modified: hugo/trunk/src/test/graph_test.cc
==============================================================================
--- hugo/trunk/src/test/graph_test.cc (original)
+++ hugo/trunk/src/test/graph_test.cc Tue Oct 5 11:41:05 2004
@@ -67,27 +67,34 @@
}
//Compile Graph
-template void lemon::checkCompileStaticGraph<skeleton::StaticGraph>
+template void lemon::skeleton::checkCompileStaticGraph<skeleton::StaticGraph>
(skeleton::StaticGraph &);
-template void lemon::checkCompileGraph<skeleton::ExtendableGraph>
+template
+void lemon::skeleton::checkCompileExtendableGraph<skeleton::ExtendableGraph>
(skeleton::ExtendableGraph &);
-template void lemon::checkCompileErasableGraph<skeleton::ErasableGraph>
+template
+void lemon::skeleton::checkCompileErasableGraph<skeleton::ErasableGraph>
(skeleton::ErasableGraph &);
//Compile SmartGraph
-template void lemon::checkCompileGraph<SmartGraph>(SmartGraph &);
-template void lemon::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
+template
+void lemon::skeleton::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
//Compile SymSmartGraph
//template void hugo::checkCompileGraph<SymSmartGraph>(SymSmartGraph &);
//template void hugo::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
//Compile ListGraph
-template void lemon::checkCompileGraph<ListGraph>(ListGraph &);
-template void lemon::checkCompileErasableGraph<ListGraph>(ListGraph &);
-template void lemon::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
+template
+void lemon::skeleton::checkCompileExtendableGraph<ListGraph>(ListGraph &);
+template
+void lemon::skeleton::checkCompileErasableGraph<ListGraph>(ListGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
//Compile SymListGraph
@@ -96,22 +103,24 @@
//template void hugo::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
//Compile FullGraph
-template void lemon::checkCompileStaticGraph<FullGraph>(FullGraph &);
-template void lemon::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
+template void lemon::skeleton::checkCompileStaticGraph<FullGraph>(FullGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
//Compile EdgeSet <ListGraph>
-template void lemon::checkCompileGraph<EdgeSet <ListGraph> >
+template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <ListGraph> >
(EdgeSet <ListGraph> &);
-template void lemon::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
+template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
(EdgeSet <ListGraph> &);
-template void lemon::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
+template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
(EdgeSet <ListGraph> &);
//Compile EdgeSet <NodeSet>
-template void lemon::checkCompileGraph<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
-template void lemon::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
+template void lemon::skeleton::checkCompileExtendableGraph<EdgeSet <NodeSet> >
(EdgeSet <NodeSet> &);
-template void lemon::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
+template void lemon::skeleton::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
+(EdgeSet <NodeSet> &);
+template void lemon::skeleton::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
(EdgeSet <NodeSet> &);
Modified: hugo/trunk/src/test/graph_test.h
==============================================================================
--- hugo/trunk/src/test/graph_test.h (original)
+++ hugo/trunk/src/test/graph_test.h Tue Oct 5 11:41:05 2004
@@ -24,251 +24,6 @@
//! \brief Some utility to test graph classes.
namespace lemon {
- struct DummyType {
- int value;
- DummyType() {}
- DummyType(int p) : value(p) {}
- DummyType& operator=(int p) { value = p; return *this;}
- };
-
-
- template<class Graph> void checkCompileStaticGraph(Graph &G)
- {
- typedef typename Graph::Node Node;
- typedef typename Graph::NodeIt NodeIt;
- typedef typename Graph::Edge Edge;
- typedef typename Graph::EdgeIt EdgeIt;
- typedef typename Graph::InEdgeIt InEdgeIt;
- typedef typename Graph::OutEdgeIt OutEdgeIt;
-
- {
- Node i; Node j(i); Node k(INVALID);
- i=j;
- bool b; b=true;
- b=(i==INVALID); b=(i!=INVALID);
- b=(i==j); b=(i!=j); b=(i<j);
- }
- {
- NodeIt i; NodeIt j(i); NodeIt k(INVALID); NodeIt l(G);
- i=j;
- j=G.first(i);
- j=++i;
- bool b; b=true;
- b=(i==INVALID); b=(i!=INVALID);
- Node n(i);
- n=i;
- b=(i==j); b=(i!=j); b=(i<j);
- //Node ->NodeIt conversion
- NodeIt ni(G,n);
- }
- {
- Edge i; Edge j(i); Edge k(INVALID);
- i=j;
- bool b; b=true;
- b=(i==INVALID); b=(i!=INVALID);
- b=(i==j); b=(i!=j); b=(i<j);
- }
- {
- EdgeIt i; EdgeIt j(i); EdgeIt k(INVALID); EdgeIt l(G);
- i=j;
- j=G.first(i);
- j=++i;
- bool b; b=true;
- b=(i==INVALID); b=(i!=INVALID);
- Edge e(i);
- e=i;
- b=(i==j); b=(i!=j); b=(i<j);
- //Edge ->EdgeIt conversion
- EdgeIt ei(G,e);
- }
- {
- Node n;
- InEdgeIt i; InEdgeIt j(i); InEdgeIt k(INVALID); InEdgeIt l(G,n);
- i=j;
- j=G.first(i,n);
- j=++i;
- bool b; b=true;
- b=(i==INVALID); b=(i!=INVALID);
- Edge e(i);
- e=i;
- b=(i==j); b=(i!=j); b=(i<j);
- //Edge ->InEdgeIt conversion
- InEdgeIt ei(G,e);
- }
- {
- Node n;
- OutEdgeIt i; OutEdgeIt j(i); OutEdgeIt k(INVALID); OutEdgeIt l(G,n);
- i=j;
- j=G.first(i,n);
- j=++i;
- bool b; b=true;
- b=(i==INVALID); b=(i!=INVALID);
- Edge e(i);
- e=i;
- b=(i==j); b=(i!=j); b=(i<j);
- //Edge ->OutEdgeIt conversion
- OutEdgeIt ei(G,e);
- }
- {
- Node n,m;
- n=m=INVALID;
- Edge e;
- e=INVALID;
- n=G.tail(e);
- n=G.head(e);
- }
- // id tests
- { Node n; int i=G.id(n); i=i; }
- { Edge e; int i=G.id(e); i=i; }
- //NodeMap tests
- {
- Node k;
- typename Graph::template NodeMap<int> m(G);
- //Const map
- typename Graph::template NodeMap<int> const &cm = m;
- //Inicialize with default value
- typename Graph::template NodeMap<int> mdef(G,12);
- //Copy
- typename Graph::template NodeMap<int> mm(cm);
- //Copy from another type
- typename Graph::template NodeMap<double> dm(cm);
- //Copy to more complex type
- typename Graph::template NodeMap<DummyType> em(cm);
- int v;
- v=m[k]; m[k]=v; m.set(k,v);
- v=cm[k];
-
- m=cm;
- dm=cm; //Copy from another type
- em=cm; //Copy to more complex type
- {
- //Check the typedef's
- typename Graph::template NodeMap<int>::ValueType val;
- val=1;
- typename Graph::template NodeMap<int>::KeyType key;
- key = typename Graph::NodeIt(G);
- }
- }
- { //bool NodeMap
- Node k;
- typename Graph::template NodeMap<bool> m(G);
- typename Graph::template NodeMap<bool> const &cm = m; //Const map
- //Inicialize with default value
- typename Graph::template NodeMap<bool> mdef(G,12);
- typename Graph::template NodeMap<bool> mm(cm); //Copy
- typename Graph::template NodeMap<int> dm(cm); //Copy from another type
- bool v;
- v=m[k]; m[k]=v; m.set(k,v);
- v=cm[k];
-
- m=cm;
- dm=cm; //Copy from another type
- m=dm; //Copy to another type
-
- {
- //Check the typedef's
- typename Graph::template NodeMap<bool>::ValueType val;
- val=true;
- typename Graph::template NodeMap<bool>::KeyType key;
- key= typename Graph::NodeIt(G);
- }
- }
- //EdgeMap tests
- {
- Edge k;
- typename Graph::template EdgeMap<int> m(G);
- typename Graph::template EdgeMap<int> const &cm = m; //Const map
- //Inicialize with default value
- typename Graph::template EdgeMap<int> mdef(G,12);
- typename Graph::template EdgeMap<int> mm(cm); //Copy
- typename Graph::template EdgeMap<double> dm(cm); //Copy from another type
- int v;
- v=m[k]; m[k]=v; m.set(k,v);
- v=cm[k];
-
- m=cm;
- dm=cm; //Copy from another type
- {
- //Check the typedef's
- typename Graph::template EdgeMap<int>::ValueType val;
- val=1;
- typename Graph::template EdgeMap<int>::KeyType key;
- key= typename Graph::EdgeIt(G);
- }
- }
- { //bool EdgeMap
- Edge k;
- typename Graph::template EdgeMap<bool> m(G);
- typename Graph::template EdgeMap<bool> const &cm = m; //Const map
- //Inicialize with default value
- typename Graph::template EdgeMap<bool> mdef(G,12);
- typename Graph::template EdgeMap<bool> mm(cm); //Copy
- typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
- bool v;
- v=m[k]; m[k]=v; m.set(k,v);
- v=cm[k];
-
- m=cm;
- dm=cm; //Copy from another type
- m=dm; //Copy to another type
- {
- //Check the typedef's
- typename Graph::template EdgeMap<bool>::ValueType val;
- val=true;
- typename Graph::template EdgeMap<bool>::KeyType key;
- key= typename Graph::EdgeIt(G);
- }
- }
- }
-
- template<class Graph> void checkCompileGraph(Graph &G)
- {
- checkCompileStaticGraph(G);
-
- typedef typename Graph::Node Node;
- typedef typename Graph::NodeIt NodeIt;
- typedef typename Graph::Edge Edge;
- typedef typename Graph::EdgeIt EdgeIt;
- typedef typename Graph::InEdgeIt InEdgeIt;
- typedef typename Graph::OutEdgeIt OutEdgeIt;
-
- Node n,m;
- n=G.addNode();
- m=G.addNode();
- Edge e;
- e=G.addEdge(n,m);
-
- // G.clear();
- }
-
- template<class Graph> void checkCompileGraphEraseEdge(Graph &G)
- {
- typename Graph::Edge e;
- G.erase(e);
- }
-
- template<class Graph> void checkCompileGraphEraseNode(Graph &G)
- {
- typename Graph::Node n;
- G.erase(n);
- }
-
- template<class Graph> void checkCompileErasableGraph(Graph &G)
- {
- checkCompileGraph(G);
- checkCompileGraphEraseNode(G);
- checkCompileGraphEraseEdge(G);
- }
-
- template<class Graph> void checkCompileGraphFindEdge(Graph &G)
- {
- typedef typename Graph::NodeIt Node;
- typedef typename Graph::NodeIt NodeIt;
-
- G.findEdge(NodeIt(G),++NodeIt(G),G.findEdge(NodeIt(G),++NodeIt(G)));
- G.findEdge(Node(),Node(),G.findEdge(Node(),Node()));
- }
-
template<class Graph> void checkGraphNodeList(Graph &G, int nn)
{
typename Graph::NodeIt n(G);
Modified: hugo/trunk/src/test/graph_wrapper_test.cc
==============================================================================
--- hugo/trunk/src/test/graph_wrapper_test.cc (original)
+++ hugo/trunk/src/test/graph_wrapper_test.cc Tue Oct 5 11:41:05 2004
@@ -38,24 +38,24 @@
//Compile GraphWrapper
typedef GraphWrapper<Graph> GW;
-template void checkCompileStaticGraph<GW>(GW &);
+template void lemon::skeleton::checkCompileStaticGraph<GW>(GW &);
//Compile RevGraphWrapper
typedef RevGraphWrapper<Graph> RevGW;
-template void checkCompileStaticGraph<RevGW>(RevGW &);
+template void lemon::skeleton::checkCompileStaticGraph<RevGW>(RevGW &);
//Compile SubGraphWrapper
typedef SubGraphWrapper<Graph, Graph::NodeMap<bool>,
Graph::EdgeMap<bool> > SubGW;
-template void checkCompileStaticGraph<SubGW>(SubGW &);
+template void lemon::skeleton::checkCompileStaticGraph<SubGW>(SubGW &);
//Compile NodeSubGraphWrapper
typedef NodeSubGraphWrapper<Graph, Graph::NodeMap<bool> > NodeSubGW;
-template void checkCompileStaticGraph<NodeSubGW>(NodeSubGW &);
+template void lemon::skeleton::checkCompileStaticGraph<NodeSubGW>(NodeSubGW &);
//Compile EdgeSubGraphWrapper
typedef EdgeSubGraphWrapper<Graph, Graph::EdgeMap<bool> > EdgeSubGW;
-template void checkCompileStaticGraph<EdgeSubGW>(EdgeSubGW &);
+template void lemon::skeleton::checkCompileStaticGraph<EdgeSubGW>(EdgeSubGW &);
//Compile UndirGraphWrapper
/// \bug UndirGraphWrapper cannot pass the StaticGraph test
@@ -69,24 +69,25 @@
//Compile SubBidirGraphWrapper
typedef SubBidirGraphWrapper<Graph, Graph::EdgeMap<bool>,
Graph::EdgeMap<bool> > SubBDGW;
-template void checkCompileStaticGraph<SubBDGW>(SubBDGW &);
+template void lemon::skeleton::checkCompileStaticGraph<SubBDGW>(SubBDGW &);
//Compile BidirGraphWrapper
typedef BidirGraphWrapper<Graph> BidirGW;
-template void checkCompileStaticGraph<BidirGW>(BidirGW &);
+template void lemon::skeleton::checkCompileStaticGraph<BidirGW>(BidirGW &);
//Compile BidirGraph
typedef BidirGraph<Graph> BidirG;
-template void checkCompileStaticGraph<BidirG>(BidirG &);
+template void lemon::skeleton::checkCompileStaticGraph<BidirG>(BidirG &);
//Compile ResGraphWrapper
typedef ResGraphWrapper<Graph, int, Graph::EdgeMap<int>,
Graph::EdgeMap<int> > ResGW;
-template void checkCompileStaticGraph<ResGW>(ResGW &);
+template void lemon::skeleton::checkCompileStaticGraph<ResGW>(ResGW &);
//Compile ErasingFirstGraphWrapper
typedef ErasingFirstGraphWrapper<Graph, Graph::NodeMap<Graph::Edge> > ErasingFirstGW;
-template void checkCompileStaticGraph<ErasingFirstGW>(ErasingFirstGW &);
+template
+void lemon::skeleton::checkCompileStaticGraph<ErasingFirstGW>(ErasingFirstGW &);
int main()
Modified: hugo/trunk/src/test/sym_graph_test.cc
==============================================================================
--- hugo/trunk/src/test/sym_graph_test.cc (original)
+++ hugo/trunk/src/test/sym_graph_test.cc Tue Oct 5 11:41:05 2004
@@ -66,12 +66,14 @@
//Compile SymSmartGraph
template void lemon::checkCompileSymGraph<SymSmartGraph>(SymSmartGraph &);
-template void lemon::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
//Compile SymListGraph
template void lemon::checkCompileSymGraph<SymListGraph>(SymListGraph &);
template void lemon::checkCompileErasableSymGraph<SymListGraph>(SymListGraph &);
-template void lemon::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
+template
+void lemon::skeleton::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
int main()
{
Modified: hugo/trunk/src/test/sym_graph_test.h
==============================================================================
--- hugo/trunk/src/test/sym_graph_test.h (original)
+++ hugo/trunk/src/test/sym_graph_test.h Tue Oct 5 11:41:05 2004
@@ -24,7 +24,11 @@
//! \file
//! \brief Some utility to test symmetric graph classes.
namespace lemon {
+
+ /// \e
+ /// \todo This should go to lemon/skeleton/symgraph.h
+ ///
template<class Graph> void checkCompileStaticSymGraph(Graph &G)
{
typedef typename Graph::Node Node;
@@ -36,7 +40,7 @@
typedef typename Graph::InEdgeIt InEdgeIt;
typedef typename Graph::OutEdgeIt OutEdgeIt;
- checkCompileStaticGraph(G);
+ lemon::skeleton::checkCompileStaticGraph(G);
{
SymEdge i; SymEdge j(i); SymEdge k(INVALID);
@@ -153,7 +157,7 @@
template<class Graph> void checkCompileErasableSymGraph(Graph &G)
{
checkCompileSymGraph(G);
- checkCompileGraphEraseNode(G);
+ lemon::skeleton::checkCompileGraphEraseNode(G);
checkCompileSymGraphEraseSymEdge(G);
}
More information about the Lemon-commits
mailing list