Changeset 1022:567f392d1d2e in lemon-0.x for src/lemon/concept/undir_graph.h

Timestamp:

11/28/04 17:30:10 (20 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1412

Message:

UndirGraph? implementation nearly complete

File:

• src/lemon/concept/undir_graph.h (modified) (1 diff)

src/lemon/concept/undir_graph.h

@@ -32 +32 @@
 
     /// \todo to be done
-    class BaseIterableUndirGraph;
 
-    template <typename Graph>
     struct BaseIterableUndirGraphConcept {
-      typedef typename Graph::UndirEdge UndirEdge;
-      typedef typename Graph::Edge Edge;
-      typedef typename Graph::Node Node;
 
-      void constraints() {
-        checkConcept<BaseIterableGraphComponent, Graph>();
-        checkConcept<GraphItem<'u'>, UndirEdge >();
+      template <typename Graph>
+      struct Constraints {
 
-        /// \bug this should be base_and_derived:
-        UndirEdge ue = e;
-        ue = e;
+        typedef typename Graph::UndirEdge UndirEdge;
+        typedef typename Graph::Edge Edge;
+        typedef typename Graph::Node Node;
 
-        Node n;
-        n = graph.target(ue);
-        n = graph.source(ue);
+        void constraints() {
+          checkConcept<BaseIterableGraphComponent, Graph>();
+          checkConcept<GraphItem<'u'>, UndirEdge >();
 
-        graph.first(ue);
-        graph.next(ue);
-      }
-      const Graph &graph;
-      Edge e;
+          /// \bug this should be base_and_derived:
+          UndirEdge ue = e;
+          ue = e;
+
+          Node n;
+          n = graph.target(ue);
+          n = graph.source(ue);
+
+          graph.first(ue);
+          graph.next(ue);
+        }
+        const Graph &graph;
+        Edge e;
+      };
+
     };
 
-    template <typename Graph>
+
     struct IterableUndirGraphConcept {
-      void constraints() {
-        /// \todo we don't need the iterable component should base iterable     
-        //      checkConcept< BaseIterableUndirGraph, Graph > ();
-        checkConcept< IterableGraphComponent, Graph > ();
 
-        typedef typename Graph::UndirEdge UndirEdge;
-        typedef typename Graph::UndirEdgeIt UndirEdgeIt;
-        typedef typename Graph::UndirIncEdgeIt UndirIncEdgeIt;
+      template <typename Graph>
+      struct Constraints {
+        void constraints() {
+          /// \todo we don't need the iterable component to be base iterable
+          /// Don't we really???
+          //checkConcept< BaseIterableUndirGraphConcept, Graph > ();
 
-        checkConcept< GraphIterator<Graph, UndirEdge>, UndirEdgeIt >();
+          checkConcept<IterableGraphComponent, Graph> ();
 
-        checkConcept<
-          GraphIncIterator<Graph, UndirEdge>,
-          UndirIncEdgeIt >();
-      }
+          typedef typename Graph::UndirEdge UndirEdge;
+          typedef typename Graph::UndirEdgeIt UndirEdgeIt;
+          typedef typename Graph::UndirIncEdgeIt UndirIncEdgeIt;
+
+          checkConcept<GraphIterator<Graph, UndirEdge>, UndirEdgeIt>();
+          checkConcept<GraphIncIterator<Graph, UndirEdge>, UndirIncEdgeIt>();
+        }
+      };
+
+    };
+
+    struct MappableUndirGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+
+        struct Dummy {
+          int value;
+          Dummy() : value(0) {}
+          Dummy(int _v) : value(_v) {}
+        };
+
+        void constraints() {
+          checkConcept<MappableGraphComponent, Graph>();
+
+          typedef typename Graph::template UndirEdgeMap<int> IntMap;
+          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, int>,
+            IntMap >();
+
+          typedef typename Graph::template UndirEdgeMap<bool> BoolMap;
+          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, bool>,
+            BoolMap >();
+
+          typedef typename Graph::template UndirEdgeMap<Dummy> DummyMap;
+          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, Dummy>,
+            DummyMap >();
+        }
+      };
+
+    };
+
+    struct ExtendableUndirGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+        void constraints() {
+          node_a = graph.addNode();
+          uedge = graph.addEdge(node_a, node_b);
+        }
+        typename Graph::Node node_a, node_b;
+        typename Graph::UndirEdge uedge;
+        Graph graph;
+      };
+
+    };
+
+    struct ErasableUndirGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+        void constraints() {
+          graph.erase(n);
+          graph.erase(e);
+        }
+        Graph graph;
+        typename Graph::Node n;
+        typename Graph::UndirEdge e;
+      };
+
+    };
+
+    class UndirGraph {
+    public:
+
+      template <typename Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<BaseIterableUndirGraphConcept, Graph>();
+          checkConcept<IterableUndirGraphConcept, Graph>();
+          checkConcept<MappableUndirGraphConcept, Graph>();
+        }
+      };
+
+    };
+
+    class ExtendableUndirGraph : public UndirGraph {
+    public:
+
+      template <typename Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<BaseIterableUndirGraphConcept, Graph>();
+          checkConcept<IterableUndirGraphConcept, Graph>();
+          checkConcept<MappableUndirGraphConcept, Graph>();
+
+          checkConcept<UndirGraph, Graph>();
+          checkConcept<ExtendableUndirGraphConcept, Graph>();
+          checkConcept<ClearableGraphComponent, Graph>();
+        }
+      };
+
+    };
+
+    class ErasableUndirGraph : public ExtendableUndirGraph {
+    public:
+
+      template <typename Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<ExtendableUndirGraph, Graph>();
+          checkConcept<ErasableUndirGraphConcept, Graph>();
+        }
+      };
+
     };