[Lemon-commits] [lemon_svn] marci: r1392 - hugo/trunk/src/work/marci

[Lemon SVN]

Author: marci
Date: Wed Nov 17 20:37:54 2004
New Revision: 1392

Modified:
   hugo/trunk/src/work/marci/merge_node_graph_wrapper.h

Log:
MergeNodeGraphWrapper with factory


Modified: hugo/trunk/src/work/marci/merge_node_graph_wrapper.h
==============================================================================
--- hugo/trunk/src/work/marci/merge_node_graph_wrapper.h	(original)
+++ hugo/trunk/src/work/marci/merge_node_graph_wrapper.h	Wed Nov 17 20:37:54 2004
@@ -25,26 +25,24 @@
 
 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
     public:
@@ -72,49 +70,28 @@
       }
     };
 
-    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;
       }
-      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));
+    }
+    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;
 	}
-	return *this;
+      } else {
+	Parent2::graph->next(*static_cast<Graph2Node*>(&i));
       }
-    };
+    }
 
     int id(const Node& n) const { 
       if (!n.backward) 
@@ -123,44 +100,44 @@
 	return this->Parent2::graph->id(n);
     }
 
-    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);
 	else 
 	  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);
 	else 
@@ -169,7 +146,25 @@
       using ParentMap1::operator[];
       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);
+    }
   };
 
 } //namespace lemon