Changeset 917:ffb8f0cbcb57 in lemon-0.x

Timestamp:

09/28/04 19:00:18 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

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

Message:

merge_node_graph_wrapper::nodemap

Location:

src/work/marci

Files:

• merge_node_graph_wrapper.h (modified) (8 diffs)
• merge_node_graph_wrapper_test.cc (modified) (1 diff)

src/work/marci/merge_node_graph_wrapper.h

@@ -1 +1 @@
 /* -*- C++ -*-
- * src/hugo/graph_wrapper.h - Part of HUGOlib, a generic C++ optimization library
+ * src/hugo/merge_node_graph_wrapper.h - Part of HUGOlib, a generic C++ optimization library
  *
  * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
@@ -15 +15 @@
  */
 
+#ifndef HUGO_MERGE_NODE_GRAPH_WRAPPER_H
+#define HUGO_MERGE_NODE_GRAPH_WRAPPER_H
+
 #include <hugo/invalid.h>
 #include <hugo/maps.h>
@@ -21 +24 @@
 #include <iostream>
 
-#ifndef HUGO_MERGE_NODE_GRAPH_WRAPPER_H
-#define HUGO_MERGE_NODE_GRAPH_WRAPPER_H
-
 namespace hugo {
 
-  template <typename Graph1, typename Graph2> 
+  template <typename Graph1, typename Graph2, typename Enable=void> 
   class MergeNodeGraphWrapper : 
     public GraphWrapper<Graph1>, public GraphWrapper<Graph2> {
@@ -38 +38 @@
     friend class Node;
     friend class NodeIt;
+    template<typename Value> class NodeMap;
 
     MergeNodeGraphWrapper(Graph1& _graph1, Graph2& _graph2) : 
@@ -44 +45 @@
     class Node : public Graph1Node, public Graph2Node {
       friend class MergeNodeGraphWrapper<Graph1, Graph2>;
-      //template<typename T> friend class NodeMap;
+      template<typename Value> friend class NodeMap;
     protected:
       bool backward; //true, iff backward
@@ -81 +82 @@
       NodeIt(const MergeNodeGraphWrapper<Graph1, Graph2>& _gw) : 
         Node(typename Graph1::NodeIt(*_gw.Parent1::graph), 
-             typename Graph2::NodeIt(),
+             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<Node*>(this)=
+//          Node(Graph1Node(INVALID), 
+//               typename Graph2::NodeIt(*_gw.Parent2::graph), 
+//               true);
+          *static_cast<Graph2Node*>(this)=
+            typename Graph2::NodeIt(*_gw.Parent2::graph);
+          backward=true;
         }
       }
@@ -98 +102 @@
             ++(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<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 {
@@ -117 +124 @@
     }
 
+    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 {
+        if (!n.backward) 
+          return ParentMap1::operator[](n);
+        else 
+          return ParentMap2::operator[](n);
+      }
+      void set(const Node& n, const Value& value) {
+        if (!n.backward) 
+          ParentMap1::set(n, value);
+        else 
+          ParentMap2::set(n, value);
+      }
+      using ParentMap1::operator[];
+      using ParentMap2::operator[];
+    };
+    
   };
 

src/work/marci/merge_node_graph_wrapper_test.cc

@@ -11 +11 @@
 
 int main() {
-  SmartGraph g;
-  ListGraph h;
-  typedef MergeNodeGraphWrapper<SmartGraph, ListGraph> GW;
+  typedef SmartGraph Graph1;
+  typedef ListGraph Graph2;
+  Graph1 g;
+  Graph2 h;
+  typedef MergeNodeGraphWrapper<Graph1, Graph2> GW;
   GW gw(g, h);
-  g.addNode();
-  g.addNode();
-  g.addNode();
-  h.addNode();
-  h.addNode();
+  Graph1::Node n1=g.addNode();
+  Graph1::Node n2=g.addNode();
+  Graph1::Node n3=g.addNode();
+  Graph2::Node n4=h.addNode();
+  Graph2::Node n5=h.addNode();
   //GW::NodeIt n(gw)
   for (GW::NodeIt n(gw); n!=INVALID; ++n) { 
     cout << gw.id(n) << endl;
   }
+
+  GW::NodeMap<int> nm(gw);
+  int i=0;
+  for (GW::NodeIt n(gw); n!=INVALID; ++n) { 
+    ++i;
+    nm.set(n, i);
+  }
+  for (Graph1::NodeIt n(g); n!=INVALID; ++n) { 
+    cout << nm[n] << endl;
+  }
+  for (Graph2::NodeIt n(h); n!=INVALID; ++n) { 
+    cout << nm[n] << endl;
+  }
 }