Changeset 768:a5e9303a5511 in lemon-0.x for src/work/marci/bipartite_graph_wrapper.h

Timestamp:

08/23/04 13:06:00 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

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

Message:

stGraphWrapper modifications

File:

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

src/work/marci/bipartite_graph_wrapper.h

@@ -31 +31 @@
   template<typename Graph> 
   class BipartiteGraphWrapper : public GraphWrapper<Graph> {
-  protected:
+  public:
     typedef IterableBoolMap< typename Graph::template NodeMap<int> > 
     SFalseTTrueMap;
+  protected:
     SFalseTTrueMap* s_false_t_true_map;
 
@@ -47 +48 @@
     static const bool S_CLASS;
     static const bool T_CLASS;
+
+    /// This method is to reach the iterable maps of the bipartite graph or 
+    /// bipartite graph wrapper.
+    const SFalseTTrueMap& sFalseTTrueMap() const { 
+      return *s_false_t_true_map; 
+    }
     
     //bool S_CLASS;
@@ -212 +219 @@
   template<typename Graph>
   class BipartiteGraph : public BipartiteGraphWrapper<Graph> {
-    typedef IterableBoolMap< typename Graph::template NodeMap<int> > 
-    SFalseTTrueMap;
+//     typedef IterableBoolMap< typename Graph::template NodeMap<int> > 
+//     SFalseTTrueMap;
     typedef BipartiteGraphWrapper<Graph> Parent;
   protected:
     Graph gr;
     typename Graph::template NodeMap<int> bipartite_map;
-    SFalseTTrueMap s_false_t_true_map;
+    typename Parent::SFalseTTrueMap s_false_t_true_map;
   public:
     typedef typename Parent::Node Node;
@@ -259 +266 @@
   };
 
-
+  template<typename Graph, typename sIterableMap, typename tIterableMap>
+  class stGraphWrapper;
+
+  /// Easier stuff for bipartite graphs.
   template<typename Graph>
-  class stGraphWrapper;
+  class stBipartiteGraphWrapper : public 
+  stGraphWrapper<Graph, typename Graph::SFalseTTrueMap, 
+                 typename Graph::SFalseTTrueMap> {
+  public:
+    typedef stGraphWrapper<Graph, typename Graph::SFalseTTrueMap, 
+                           typename Graph::SFalseTTrueMap> Parent;
+    stBipartiteGraphWrapper(Graph& _graph) : 
+      Parent(_graph, _graph.sFalseTTrueMap(), _graph.sFalseTTrueMap()) { }
+  };
 
 //   template<typename Graph> 
@@ -288 +306 @@
   ///
   /// \author Marton Makai
-  template<typename Graph>
+  template<typename Graph, typename sIterableMap, typename tIterableMap>
   class stGraphWrapper : public GraphWrapper<Graph> {
+  protected:    
+    const sIterableMap* s_iterable_map;
+    const tIterableMap* t_iterable_map;
   public:
     class Node; 
     friend class Node;
 //GN, int
-//0 normalis, 1 s, 2, true, ez az iteralasi sorrend, 
+//0 normalis, 1 s, 2 t, ez az iteralasi sorrend, 
 //es a vege a false azaz (invalid, 3)    
     class NodeIt;
@@ -335 +356 @@
     static const bool T_CLASS=true;
 
-    stGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) , 
-                                    S_NODE(INVALID, 1), 
-                                    T_NODE(INVALID, 2) { }
+    // \bug not too nice constructor.
+    stGraphWrapper(Graph& _graph, 
+                   const sIterableMap& _s_iterable_map, 
+                   const tIterableMap& _t_iterable_map) : 
+      GraphWrapper<Graph>(_graph), 
+      s_iterable_map(&_s_iterable_map), 
+      t_iterable_map(&_t_iterable_map), 
+      S_NODE(INVALID, 1), 
+      T_NODE(INVALID, 2) { }
 
     
@@ -350 +377 @@
     protected:
       friend class GraphWrapper<Graph>;
-      friend class stGraphWrapper<Graph>;
+      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
       template <typename T> friend class NodeMap;
       friend class Edge;
@@ -381 +408 @@
     class NodeIt { 
       friend class GraphWrapper<Graph>;
-      friend class stGraphWrapper<Graph>;
+      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
       typename Graph::NodeIt n;
       int spec; 
@@ -389 +416 @@
         n(_n), spec(_spec) { }
       NodeIt(const Invalid& i) : n(i), spec(3) { }
-      NodeIt(const stGraphWrapper<Graph>& _G) : n(*(_G.graph)), spec(0) { 
+      NodeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G) 
+        : n(*(_G.graph)), spec(0) { 
         if (!_G.graph->valid(n)) spec=1;
       }
@@ -397 +425 @@
     class Edge : public Graph::Edge {
       friend class GraphWrapper<Graph>;
-      friend class stGraphWrapper<Graph>;
+      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
       template <typename T> friend class EdgeMap;
       int spec;
@@ -430 +458 @@
     class OutEdgeIt { 
       friend class GraphWrapper<Graph>;
-      friend class stGraphWrapper<Graph>;
+      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
       typename Graph::OutEdgeIt e;
       int spec;
@@ -441 +469 @@
       }
       OutEdgeIt(const Invalid& i) : e(i), spec(3), n(i) { }
-      OutEdgeIt(const stGraphWrapper<Graph>& _G, const Node& _n) {
+      OutEdgeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G, 
+                const Node& _n) {
         switch (_n.spec) {
           case 0 : 
@@ -474 +503 @@
     class InEdgeIt { 
       friend class GraphWrapper<Graph>;
-      friend class stGraphWrapper<Graph>;
+      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
       typename Graph::InEdgeIt e;
       int spec;
@@ -485 +514 @@
       }
       InEdgeIt(const Invalid& i) : e(i), spec(3), n(i) { }
-      InEdgeIt(const stGraphWrapper<Graph>& _G, const Node& _n) {
+      InEdgeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G, 
+               const Node& _n) {
         switch (_n.spec) {
           case 0 : 
@@ -518 +548 @@
     class EdgeIt { 
       friend class GraphWrapper<Graph>;
-      friend class stGraphWrapper<Graph>;
+      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
       typename Graph::EdgeIt e;
       int spec;
@@ -528 +558 @@
         e(_e), spec(_spec), n(_n) { }
       EdgeIt(const Invalid& i) : e(i), spec(3), n(i) { }
-      EdgeIt(const stGraphWrapper<Graph>& _G) : 
+      EdgeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G) : 
         e(*(_G.graph)), spec(0), n(INVALID) { 
         if (!_G.graph->valid(e)) {
@@ -719 +749 @@
       T s_value, t_value;
     public:
-      NodeMap(const stGraphWrapper<Graph>& _G) :  Parent(_G), 
-                                                  s_value(), 
-                                                  t_value() { }
-      NodeMap(const stGraphWrapper<Graph>& _G, T a) : Parent(_G, a), 
-                                                      s_value(a), 
-                                                      t_value(a) { }
+      NodeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G) : 
+        Parent(_G), 
+        s_value(), 
+        t_value() { }
+      NodeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G, T a) 
+        : Parent(_G, a), 
+          s_value(a), 
+          t_value(a) { }
       T operator[](const Node& n) const { 
         switch (n.spec) {
@@ -754 +786 @@
     /// 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>.
+    /// stGraphWrapper<Graph, sIterableMap, tIterableMap>.
     template<typename NM> class NodeMapWrapper { 
     public:
@@ -798 +830 @@
       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) { }
+      EdgeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G) 
+        : Parent(_G), 
+          node_value(_G) { }
+      EdgeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G, T a) 
+        : Parent(_G, a), 
+          node_value(_G, a) { }
       T operator[](const Edge& e) const { 
         switch (e.spec) {
@@ -830 +864 @@
 
     /// This class is to wrap an edge-map and a node-map of \c Graph 
-    /// to an edge-map of stGraphWrapper<Graph>.
+    /// to an edge-map of stGraphWrapper<Graph, sIterableMap, tIterableMap>.
     template<typename EM, typename NM> 
     class EdgeMapWrapper {