Changeset 1002:ea3ecb3c9846 in lemon-0.x

Timestamp:

11/17/04 20:37:54 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

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

Message:

MergeNodeGraphWrapper? with factory

File:

• src/work/marci/merge_node_graph_wrapper.h (modified) (5 diffs)

src/work/marci/merge_node_graph_wrapper.h

@@ -26 +26 @@
 namespace lemon {
 
-  template <typename Graph1, typename Graph2, typename Enable=void> 
-  class MergeNodeGraphWrapper : 
-    public GraphWrapper<Graph1>, public GraphWrapper<Graph2> {
-    typedef GraphWrapper<Graph1> Parent1;
-    typedef GraphWrapper<Graph2> Parent2;
-    typedef typename GraphWrapper<Graph1>::Node Graph1Node;
-    typedef typename GraphWrapper<Graph2>::Node Graph2Node;
+  template <typename _Graph1, typename _Graph2, typename Enable=void>
+  class MergeNodeGraphWrapperBase : 
+    public GraphWrapperBase<_Graph1>, public GraphWrapperBase<_Graph2> {
   public:
-    class Node;
-    class NodeIt;
-    friend class Node;
-    friend class NodeIt;
-    template<typename Value> class NodeMap;
-
-    MergeNodeGraphWrapper(Graph1& _graph1, Graph2& _graph2) : 
-      Parent1(_graph1), Parent2(_graph2) { }
+    typedef _Graph1 Graph1;
+    typedef _Graph2 Graph2;
+    typedef GraphWrapperBase<_Graph1> Parent1;
+    typedef GraphWrapperBase<_Graph2> Parent2;
+    typedef typename Parent1::Node Graph1Node;
+    typedef typename Parent2::Node Graph2Node;
+  protected:
+    MergeNodeGraphWrapperBase() { }
+  public:
+    template <typename _Value> class NodeMap;
 
     class Node : public Graph1Node, public Graph2Node {
-      friend class MergeNodeGraphWrapper<Graph1, Graph2>;
-      template<typename Value> friend class NodeMap;
+      friend class MergeNodeGraphWrapperBase<_Graph1, _Graph2>;
+      template <typename Value> friend class NodeMap;
     protected:
       bool backward; //true, iff backward
@@ -73 +71 @@
     };
 
-    class NodeIt : public Node {
-      friend class MergeNodeGraphWrapper<Graph1, Graph2>;
-    protected:
-      const MergeNodeGraphWrapper<Graph1, Graph2>* gw;
-    public:
-      NodeIt() { }
-      NodeIt(Invalid i) : Node(i) { }
-      NodeIt(const MergeNodeGraphWrapper<Graph1, Graph2>& _gw) : 
-        Node(typename Graph1::NodeIt(*_gw.Parent1::graph), 
-             typename Graph2::Node(),
-             false), gw(&_gw) { 
-        if (*static_cast<Graph1Node*>(this)==INVALID) {
-//        *static_cast<Node*>(this)=
-//          Node(Graph1Node(INVALID), 
-//               typename Graph2::NodeIt(*_gw.Parent2::graph), 
-//               true);
-          *static_cast<Graph2Node*>(this)=
-            typename Graph2::NodeIt(*_gw.Parent2::graph);
-          backward=true;
+    //typedef void Edge;
+    class Edge { };
+    
+    void first(Node& i) const {
+      Parent1::graph->first(*static_cast<Graph1Node*>(&i));
+      i.backward=false;
+      if (*static_cast<Graph1Node*>(&i)==INVALID) {
+        Parent2::graph->first(*static_cast<Graph2Node*>(&i));
+        i.backward=true;
+      }
+    }
+    void next(Node& i) const {
+      if (!(i.backward)) {
+        Parent1::graph->next(*static_cast<Graph1Node*>(&i));
+        if (*static_cast<Graph1Node*>(&i)==INVALID) {
+          Parent2::graph->first(*static_cast<Graph2Node*>(&i));
+          i.backward=true;
         }
+      } else {
+        Parent2::graph->next(*static_cast<Graph2Node*>(&i));
       }
-      NodeIt(const MergeNodeGraphWrapper<Graph1, Graph2>& _gw, 
-             const Node& n) : 
-        Node(n), gw(&_gw) { }
-      NodeIt& operator++() { 
-        if (!this->backward) {
-          *(static_cast<Graph1Node*>(this))=
-            ++(typename Graph1::NodeIt(*gw->Parent1::graph, *this));
-          if (*static_cast<Graph1Node*>(this)==INVALID) {
-//          *static_cast<Node*>(this)=
-//            Node(typename Graph1::Node(INVALID), 
-//                 typename Graph2::NodeIt(*gw->Parent2::graph), true);
-            *static_cast<Graph2Node*>(this)=
-              typename Graph2::NodeIt(*gw->Parent2::graph);
-            backward=true;
-          }
-        } else {
-          *(static_cast<Graph2Node*>(this))=
-            ++(typename Graph2::NodeIt(*gw->Parent2::graph, *this));
-        }
-        return *this;
-      }
-    };
+    }
 
     int id(const Node& n) const { 
@@ -124 +101 @@
     }
 
-    template <typename Value> 
-    class NodeMap : public Parent1::template NodeMap<Value>, 
-                    public Parent2::template NodeMap<Value> { 
-      typedef typename Parent1::template NodeMap<Value> ParentMap1;
-      typedef typename Parent2::template NodeMap<Value> ParentMap2;
+    template <typename _Value> 
+    class NodeMap : public Parent1::template NodeMap<_Value>, 
+                    public Parent2::template NodeMap<_Value> { 
+      typedef typename Parent1::template NodeMap<_Value> ParentMap1;
+      typedef typename Parent2::template NodeMap<_Value> ParentMap2;
     public:
-      NodeMap(const MergeNodeGraphWrapper<Graph1, Graph2>& gw) : 
-        ParentMap1(gw), 
-        ParentMap2(gw) { }
-      NodeMap(const MergeNodeGraphWrapper<Graph1, Graph2>& gw, 
-              const Value& value)
-        : ParentMap1(gw, value), 
-          ParentMap2(gw, value) { }
-      NodeMap(const NodeMap& copy)
-        : ParentMap1(copy), 
-          ParentMap2(copy) { }
-      template <typename TT>
-      NodeMap(const NodeMap<TT>& copy)
-        : ParentMap1(copy),
-          ParentMap2(copy) { }
-      NodeMap& operator=(const NodeMap& copy) {
-        ParentMap1::operator=(copy);
-        ParentMap2::operator=(copy);
-        return *this;
-      }
-      template <typename TT>
-      NodeMap& operator=(const NodeMap<TT>& copy) {
-        ParentMap1::operator=(copy);
-        ParentMap2::operator=(copy);
-        return *this;
-      }
-      Value operator[](const Node& n) const {
+      typedef _Value Value;
+      typedef Node Key;
+      NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw) : 
+        ParentMap1(gw), ParentMap2(gw) { }
+      NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw, 
+              const _Value& value) : 
+        ParentMap1(gw, value), ParentMap2(gw, value) { }
+//       NodeMap(const NodeMap& copy)
+//      : ParentMap1(copy), 
+//        ParentMap2(copy) { }
+//       template <typename TT>
+//       NodeMap(const NodeMap<TT>& copy)
+//      : ParentMap1(copy),
+//        ParentMap2(copy) { }
+//       NodeMap& operator=(const NodeMap& copy) {
+//      ParentMap1::operator=(copy);
+//      ParentMap2::operator=(copy);
+//      return *this;
+//       }
+//       template <typename TT>
+//       NodeMap& operator=(const NodeMap<TT>& copy) {
+//      ParentMap1::operator=(copy);
+//      ParentMap2::operator=(copy);
+//      return *this;
+//       }
+      _Value operator[](const Node& n) const {
         if (!n.backward) 
           return ParentMap1::operator[](n);
@@ -161 +138 @@
           return ParentMap2::operator[](n);
       }
-      void set(const Node& n, const Value& value) {
+      void set(const Node& n, const _Value& value) {
         if (!n.backward) 
           ParentMap1::set(n, value);
@@ -170 +147 @@
       using ParentMap2::operator[];
     };
-    
+
+  };
+
+
+  template <typename _Graph1, typename _Graph2, typename Enable=void>
+  class MergeNodeGraphWrapper : public 
+  IterableGraphExtender<MergeNodeGraphWrapperBase<_Graph1, _Graph2, Enable> > {
+  public:
+    typedef _Graph1 Graph1;
+    typedef _Graph2 Graph2;
+    typedef IterableGraphExtender<
+      MergeNodeGraphWrapperBase<_Graph1, _Graph2, Enable> > Parent;
+  protected:
+    MergeNodeGraphWrapper() { }
+  public:
+    MergeNodeGraphWrapper(_Graph1& _graph1, _Graph2& _graph2) { 
+      Parent::Parent1::setGraph(_graph1);
+      Parent::Parent2::setGraph(_graph2);
+    }
   };