Changeset 510:72143568cadc in lemon-0.x for src/work/marci/bipartite_graph_wrapper.h

Timestamp:

05/03/04 12:04:27 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

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

Message:

matching, flows

File:

• src/work/marci/bipartite_graph_wrapper.h (modified) (9 diffs)

src/work/marci/bipartite_graph_wrapper.h

@@ -311 +311 @@
 //invalid, 3, invalid)
     template <typename T> class NodeMap;
-    template <typename T, typename Parent> class EdgeMap;
+    template <typename T> class EdgeMap;
 
 //    template <typename T> friend class NodeMap;
@@ -386 +386 @@
       friend class GraphWrapper<Graph>;
       friend class stGraphWrapper<Graph>;
-      template <typename T, typename Parent> friend class EdgeMap;
+      template <typename T> friend class EdgeMap;
       int spec;
       typename Graph::Node n;
@@ -413 +413 @@
       friend std::ostream& operator<< (std::ostream& os, const Edge& i);
       int getSpec() const { return spec; }
+      typename Graph::Node getNode() const { return n; }
     };
 
@@ -703 +704 @@
     template<typename T> class NodeMap : public GraphWrapper<Graph>::template NodeMap<T> { 
       typedef typename GraphWrapper<Graph>::template NodeMap<T> Parent;
+    protected:
       T s_value, t_value;
     public:
@@ -715 +717 @@
         case 0: 
           return Parent::operator[](n);
-          break;
         case 1:
           return s_value;
-          break;
         case 2: 
         default:
           return t_value;
-          break;
         }
       }
@@ -741 +740 @@
     };
 
-    template<typename T, 
-             typename Parent=
-             typename GraphWrapper<Graph>::template EdgeMap<T> > 
-    class EdgeMap : public Parent { 
-      //typedef typename GraphWrapper<Graph>::template EdgeMap<T> Parent;
+    /// This class is to wrap a node-map of \c Graph and two variables 
+    /// storing values for \c S_NODE and \c T_NODE to a node-map of 
+    /// stGraphWrapper<Graph>.
+    template<typename NM> class NodeMapWrapper { 
+    public:
+      typedef Node KeyType;
+      typedef typename NM::ValueType ValueType;
+    protected:
+      NM* nm;
+      ValueType* s_value, t_value;
+    public:
+      NodeMapWrapper(NM& _nm, ValueType& _s_value, ValueType& _t_value) : 
+        nm(&_nm), s_value(&_s_value), t_value(&_t_value) { }
+      ValueType operator[](const Node& n) const { 
+        switch (n.getSpec()) {
+        case 0: 
+          return (*nm)[n];
+        case 1:
+          return *s_value;
+        case 2: 
+        default:
+          return *t_value;
+        }
+      }
+      void set(const Node& n, ValueType t) { 
+        switch (n.getSpec()) {
+        case 0: 
+          nm->set(n, t);
+          break;
+        case 1:
+          *s_value=t;
+          break;
+        case 2:
+        default:
+          *t_value=t;
+          break;
+        }
+      }
+    };
+
+    template<typename T> 
+    class EdgeMap : public GraphWrapper<Graph>::template EdgeMap<T> { 
+      typedef typename GraphWrapper<Graph>::template EdgeMap<T> Parent;
+    protected:
       typename GraphWrapper<Graph>::template NodeMap<T> node_value;
     public:
@@ -756 +794 @@
         case 0: 
           return Parent::operator[](e);
-          break;
         case 1:
           return node_value[e.n];
-          break;
         case 2:
         default:
           return node_value[e.n];
-          break;
         }
       }
@@ -782 +817 @@
     };
 
-//     template<typename T> class EdgeMap : public GraphWrapper<Graph>::template EdgeMap<T> { 
-//       typedef typename GraphWrapper<Graph>::template EdgeMap<T> Parent;
-//       typename GraphWrapper<Graph>::template NodeMap<T> node_value;
-//     public:
-//       EdgeMap(const stGraphWrapper<Graph>& _G) : Parent(_G), 
-//                                               node_value(_G) { }
-//       EdgeMap(const stGraphWrapper<Graph>& _G, T a) : Parent(_G, a), 
-//                                                    node_value(_G, a) { }
-//       T operator[](const Edge& e) const { 
-//      switch (e.spec) {
-//      case 0: 
-//        return Parent::operator[](e);
-//        break;
-//      case 1:
-//        return node_value[e.n];
-//        break;
-//      case 2:
-//      default:
-//        return node_value[e.n];
-//        break;
-//      }
-//       }
-//       void set(const Edge& e, T t) { 
-//      switch (e.spec) {
-//      case 0: 
-//        GraphWrapper<Graph>::template EdgeMap<T>::set(e, t);
-//        break;
-//      case 1:
-//        node_value.set(e.n, t);
-//        break;
-//      case 2:
-//      default:
-//        node_value.set(e.n, t);
-//        break;
-//      }
-//       }
-//     };
+    /// This class is to wrap an edge-map and a node-map of \c Graph 
+    /// to an edge-map of stGraphWrapper<Graph>.
+    template<typename EM, typename NM> 
+    class EdgeMapWrapper {
+    public: 
+      typedef Edge KeyType;
+      typedef typename EM::ValueType ValueType;
+    protected:
+      EM* em;
+      NM* nm;
+    public:
+      EdgeMapWrapper(EM& _em, NM& _nm) : em(&_em), nm(&_nm) { }
+      ValueType operator[](const Edge& e) const { 
+        switch (e.getSpec()) {
+        case 0: 
+          return (*em)[e];
+        case 1:
+          return (*nm)[e.getNode()];
+        case 2:
+        default:
+          return (*nm)[e.getNode()];
+        }
+      }
+      void set(const Edge& e, ValueType t) { 
+        switch (e.getSpec()) {
+        case 0: 
+          em->set(e, t);
+          break;
+        case 1:
+          nm->set(e.getNode(), t);
+          break;
+        case 2:
+        default:
+          nm->set(e.getNode(), t);
+          break;
+        }
+      }
+    };
+
 
 //  template<typename G> 
@@ -841 +878 @@
 
 
-#endif //HUGO_GRAPH_WRAPPER_H
-
+#endif //HUGO_BIPARTITE_GRAPH_WRAPPER_H
+