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

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)

File:

• src/lemon/skeletons/graph.h (modified) (4 diffs)

src/lemon/skeletons/graph.h

@@ -46 +46 @@
     /// 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
     {
@@ -443 +446 @@
     };
 
-
+    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
@@ -478 +677 @@
     };
 
+    
+    ///\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.
   
@@ -501 +724 @@
       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