[Lemon-commits] [lemon_svn] klao: r1275 - hugo/branches/graph_factory/src/lemon/skeletons
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:44:18 CET 2006
Author: klao
Date: Wed Oct 6 17:30:09 2004
New Revision: 1275
Modified:
hugo/branches/graph_factory/src/lemon/skeletons/graph.h
Log:
Complete the port -r1259:1266
Bug fix in GraphBase
Modified: hugo/branches/graph_factory/src/lemon/skeletons/graph.h
==============================================================================
--- hugo/branches/graph_factory/src/lemon/skeletons/graph.h (original)
+++ hugo/branches/graph_factory/src/lemon/skeletons/graph.h Wed Oct 6 17:30:09 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,40 @@
///
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()));
+ }
@@ -566,21 +822,21 @@
class Edge : public BaseGraphItem {};
// Graph operation
- void first(Node &n) const { return n; }
- void first(Edge &e) const { return e; }
+ void firstNode(Node &n) const { }
+ void firstEdge(Edge &e) const { }
- void firstOut(Edge &e, Node) const { return e; }
- void firstIn(Edge &e, Node) const { return e; }
+ void firstOutEdge(Edge &e, Node) const { }
+ void firstInEdge(Edge &e, Node) const { }
- void next(Node &n) const { return n; }
- void next(Edge &e) const { return e; }
+ void nextNode(Node &n) const { }
+ void nextEdge(Edge &e) const { }
// Question: isn't it reasonable if this methods have a Node
// parameter? Like this:
// Edge& nextOut(Edge &e, Node) const { return e; }
- void nextOut(Edge &e) const { return e; }
- void nextIn(Edge &e) const { return e; }
+ void nextOutEdge(Edge &e) const { }
+ void nextInEdge(Edge &e) const { }
Node head(Edge) const { return Node(); }
Node tail(Edge) const { return Node(); }
@@ -622,7 +878,6 @@
}
};
-
// @}
} //namespace skeleton
} //namespace lemon
More information about the Lemon-commits
mailing list