Changeset 2111:ea1fa1bc3f6d in lemon-0.x for lemon/concept/graph_component.h

Timestamp:

06/28/06 17:06:24 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Removing concepts for extendable and erasable graphs
Renaming StaticGraph? to Graph

File:

• lemon/concept/graph_component.h (modified) (4 diffs)

lemon/concept/graph_component.h

@@ -459 +459 @@
     /// core clear functions for the graph structure.
     /// The most of the base graphs should be conform to this concept.
-    class ClearableGraphComponent : virtual public BaseGraphComponent {
+    class BaseClearableGraphComponent : virtual public BaseGraphComponent {
     public:
 
@@ -647 +647 @@
     /// This class provides beside the core graph features
     /// iterator based iterable interface for the graph structure.
-    /// This concept is part of the StaticGraphConcept.
+    /// This concept is part of the GraphConcept.
     class IterableGraphComponent : virtual public BaseGraphComponent {
 
@@ -818 +818 @@
     /// This class provides beside the core graph features
     /// map interface for the graph structure.
-    /// This concept is part of the StaticGraphConcept.
+    /// This concept is part of the GraphConcept.
     class MappableGraphComponent : virtual public BaseGraphComponent {
     public:
@@ -931 +931 @@
     };
 
-    /// \brief An empty extendable extended graph class.
-    ///
-    /// This class provides beside the core graph features
-    /// item addition interface for the graph structure.
-    /// The difference between this class and the 
-    /// \c BaseExtendableGraphComponent is that it should
-    /// notify the item alteration observers.
-    class ExtendableGraphComponent : virtual public BaseGraphComponent {
-    public:
-
-      typedef ExtendableGraphComponent Graph;
-
-      typedef BaseGraphComponent::Node Node;
-      typedef BaseGraphComponent::Edge Edge;
-
-      /// \brief Add a node to the graph.
-      ///
-      /// Add a node to the graph and notify the observers.
-      Node addNode() {
-        return INVALID;
+
+//     /// Skeleton class which describes an edge with direction in \ref
+//     /// UGraph "undirected graph".
+    template <typename UGraph>
+    class UGraphEdge : public UGraph::UEdge {
+      typedef typename UGraph::UEdge UEdge;
+      typedef typename UGraph::Node Node;
+    public:
+
+      /// \e
+      UGraphEdge() {}
+
+      /// \e
+      UGraphEdge(const UGraphEdge& e) : UGraph::UEdge(e) {}
+
+      /// \e
+      UGraphEdge(Invalid) {}
+
+      /// \brief Directed edge from undirected edge and a source node.
+      ///
+      /// Constructs a directed edge from undirected edge and a source node.
+      ///
+      /// \note You have to specify the graph for this constructor.
+      UGraphEdge(const UGraph &g,
+                     UEdge u_edge, Node n) {
+        ignore_unused_variable_warning(u_edge);
+        ignore_unused_variable_warning(g);
+        ignore_unused_variable_warning(n);
       }
+
+      /// \e
+      UGraphEdge& operator=(UGraphEdge) { return *this; }
+
+      /// \e
+      bool operator==(UGraphEdge) const { return true; }
+      /// \e
+      bool operator!=(UGraphEdge) const { return false; }
+
+      /// \e
+      bool operator<(UGraphEdge) const { return false; }
+
+      template <typename Edge>
+      struct Constraints {
+        void constraints() {
+          const_constraints();
+        }
+        void const_constraints() const {
+          /// \bug This should be is_base_and_derived ...
+          UEdge ue = e;
+          ue = e;
+
+          Edge e_with_source(graph,ue,n);
+          ignore_unused_variable_warning(e_with_source);
+        }
+        Edge e;
+        UEdge ue;
+        UGraph graph;
+        Node n;
+      };
+    };
     
-      /// \brief Add an edge to the graph.
-      ///
-      /// Add an edge to the graph and notify the observers.
-      Edge addEdge(const Node&, const Node&) {
-        return INVALID;
-      }
-
-      template <typename _Graph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<BaseGraphComponent, _Graph >();
-          typename _Graph::Node node_a, node_b;
-          node_a = graph.addNode();
-          node_b = graph.addNode();
-          typename _Graph::Edge edge;
-          edge = graph.addEdge(node_a, node_b);      
-        }
-        _Graph& graph;
-      };
-    };
-
-    /// \brief An empty erasable extended graph class.
-    ///
-    /// This class provides beside the core graph features
-    /// item erase interface for the graph structure.
-    /// The difference between this class and the 
-    /// \c BaseErasableGraphComponent is that it should
-    /// notify the item alteration observers.
-    class ErasableGraphComponent : virtual public BaseGraphComponent {
-    public:
-
-      typedef ErasableGraphComponent Graph;
-
-      typedef BaseGraphComponent::Node Node;
-      typedef BaseGraphComponent::Edge Edge;
-
-      /// \brief Erase the Node and notify the node alteration observers.
-      ///
-      ///  Erase the Node and notify the node alteration observers.
-      void erase(const Node&) {}    
-
-      /// \brief Erase the Edge and notify the edge alteration observers.
-      ///
-      ///  Erase the Edge and notify the edge alteration observers.
-      void erase(const Edge&) {}
-
-      template <typename _Graph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<BaseGraphComponent, _Graph >();
-          typename _Graph::Node node;
-          graph.erase(node);
-          typename _Graph::Edge edge;
-          graph.erase(edge);      
-        }
-
-        _Graph& graph;
-      };
+
+    struct BaseIterableUGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+
+        typedef typename Graph::UEdge UEdge;
+        typedef typename Graph::Edge Edge;
+        typedef typename Graph::Node Node;
+
+        void constraints() {
+          checkConcept<BaseIterableGraphComponent, Graph>();
+          checkConcept<GraphItem<>, UEdge>();
+          //checkConcept<UGraphEdge<Graph>, Edge>();
+
+          graph.first(ue);
+          graph.next(ue);
+
+          const_constraints();
+        }
+        void const_constraints() {
+          Node n;
+          n = graph.target(ue);
+          n = graph.source(ue);
+          n = graph.oppositeNode(n0, ue);
+
+          bool b;
+          b = graph.direction(e);
+          Edge e = graph.direct(UEdge(), true);
+          e = graph.direct(UEdge(), n);
+ 
+          ignore_unused_variable_warning(b);
+        }
+
+        Graph graph;
+        Edge e;
+        Node n0;
+        UEdge ue;
+      };
+
+    };
+
+
+    struct IterableUGraphConcept {
+
+      template <typename Graph>
+      struct Constraints {
+        void constraints() {
+          /// \todo we don't need the iterable component to be base iterable
+          /// Don't we really???
+          //checkConcept< BaseIterableUGraphConcept, Graph > ();
+
+          checkConcept<IterableGraphComponent, Graph> ();
+
+          typedef typename Graph::UEdge UEdge;
+          typedef typename Graph::UEdgeIt UEdgeIt;
+          typedef typename Graph::IncEdgeIt IncEdgeIt;
+
+          checkConcept<GraphIterator<Graph, UEdge>, UEdgeIt>();
+          checkConcept<GraphIncIterator<Graph, UEdge>, IncEdgeIt>();
+        }
+      };
+
+    };
+
+    struct MappableUGraphConcept {
+
+      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 UEdgeMap<int> IntMap;
+          checkConcept<GraphMap<Graph, typename Graph::UEdge, int>,
+            IntMap >();
+
+          typedef typename Graph::template UEdgeMap<bool> BoolMap;
+          checkConcept<GraphMap<Graph, typename Graph::UEdge, bool>,
+            BoolMap >();
+
+          typedef typename Graph::template UEdgeMap<Dummy> DummyMap;
+          checkConcept<GraphMap<Graph, typename Graph::UEdge, Dummy>,
+            DummyMap >();
+        }
+      };
+
     };