Changeset 902:309d81806228 in lemon-0.x for src/work/marci/bipartite_graph_wrapper.h

Timestamp:

09/22/04 14:25:50 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

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

Message:

correction to 0.2

File:

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

src/work/marci/bipartite_graph_wrapper.h

@@ -72 +72 @@
     class InEdgeIt;
     friend class InEdgeIt;
-    class ClassNodeIt {
+    class ClassNodeIt : public Node {
       friend class BipartiteGraphWrapper<Graph>;
     protected:
-      Node n;
+      const BipartiteGraphWrapper<Graph>* gw;
     public:
       ClassNodeIt() { }
-      ClassNodeIt(const Invalid& i) : n(i) { }
-      ClassNodeIt(const BipartiteGraphWrapper<Graph>& _G, bool _class) { 
-        _G.s_false_t_true_map->first(n, _class); 
+      ClassNodeIt(Invalid i) : Node(i) { }
+      ClassNodeIt(const BipartiteGraphWrapper<Graph>& _gw, bool _class) : 
+        Node(), gw(&_gw) { 
+        _gw.s_false_t_true_map->first(*this, _class); 
       }
       //FIXME needed in new concept, important here
-      ClassNodeIt(const Node& _n) : n(_n) { }
-      operator Node() const { return n; }
+      ClassNodeIt(const BipartiteGraphWrapper<Graph>& _gw, const Node& n) : 
+        Node(n), gw(&_gw) { }
+      ClassNodeIt& operator++() { 
+        gw->s_false_t_true_map->next(*this);
+        return *this; 
+      }
     };
 //     class SNodeIt {
@@ -106 +111 @@
 //       operator Node() const { return n; }
 //     };
-    class OutEdgeIt { 
-      friend class BipartiteGraphWrapper<Graph>;
-    protected:
-      typename Graph::OutEdgeIt e;
-    public:
-      OutEdgeIt() { }
-      OutEdgeIt(const Invalid& i) : e(i) { }
-      OutEdgeIt(const BipartiteGraphWrapper<Graph>& _G, const Node& _n) {
-        if (!(*(_G.s_false_t_true_map))[_n]) 
-          e=typename Graph::OutEdgeIt(*(_G.graph), typename Graph::Node(_n));
-        else 
-          e=INVALID;
-      }
-      operator Edge() const { return Edge(typename Graph::Edge(e)); }
-    };
-    class InEdgeIt { 
-      friend class BipartiteGraphWrapper<Graph>;
-    protected:
-      typename Graph::InEdgeIt e;
-    public:
-      InEdgeIt() { }
-      InEdgeIt(const Invalid& i) : e(i) { }
-      InEdgeIt(const BipartiteGraphWrapper<Graph>& _G, const Node& _n) {
-        if ((*(_G.s_false_t_true_map))[_n]) 
-          e=typename Graph::InEdgeIt(*(_G.graph), typename Graph::Node(_n));
-        else 
-          e=INVALID;
-      }
-      operator Edge() const { return Edge(typename Graph::Edge(e)); }
-    };
+//     class OutEdgeIt { 
+//       friend class BipartiteGraphWrapper<Graph>;
+//     protected:
+//       typename Graph::OutEdgeIt e;
+//     public:
+//       OutEdgeIt() { }
+//       OutEdgeIt(const Invalid& i) : e(i) { }
+//       OutEdgeIt(const BipartiteGraphWrapper<Graph>& _G, const Node& _n) {
+//      if (!(*(_G.s_false_t_true_map))[_n]) 
+//        e=typename Graph::OutEdgeIt(*(_G.graph), typename Graph::Node(_n));
+//      else 
+//        e=INVALID;
+//       }
+//       operator Edge() const { return Edge(typename Graph::Edge(e)); }
+//     };
+//     class InEdgeIt { 
+//       friend class BipartiteGraphWrapper<Graph>;
+//     protected:
+//       typename Graph::InEdgeIt e;
+//     public:
+//       InEdgeIt() { }
+//       InEdgeIt(const Invalid& i) : e(i) { }
+//       InEdgeIt(const BipartiteGraphWrapper<Graph>& _G, const Node& _n) {
+//      if ((*(_G.s_false_t_true_map))[_n]) 
+//        e=typename Graph::InEdgeIt(*(_G.graph), typename Graph::Node(_n));
+//      else 
+//        e=INVALID;
+//       }
+//       operator Edge() const { return Edge(typename Graph::Edge(e)); }
+//     };
 
     using GraphWrapper<Graph>::first;
     ClassNodeIt& first(ClassNodeIt& n, bool _class) const { 
-      n=ClassNodeIt(*this, _class) ; return n; }
+      n=ClassNodeIt(*this, _class); return n;
+    }
 //    SNodeIt& first(SNodeIt& n) const { n=SNodeIt(*this); return n; }
 //    TNodeIt& first(TNodeIt& n) const { n=TNodeIt(*this); return n; }
-    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
-      i=OutEdgeIt(*this, p); return i;
-    }
-    InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
-      i=InEdgeIt(*this, p); return i;
-    }
-
-    using GraphWrapper<Graph>::next;
-    ClassNodeIt& next(ClassNodeIt& n) const { 
-      this->s_false_t_true_map->next(n.n); return n; 
-    }
+//     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
+//       i=OutEdgeIt(*this, p); return i;
+//     }
+//     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
+//       i=InEdgeIt(*this, p); return i;
+//     }
+
+//     using GraphWrapper<Graph>::next;
+//     ClassNodeIt& next(ClassNodeIt& n) const { 
+//       this->s_false_t_true_map->next(n.n); return n; 
+//     }
 //     SNodeIt& next(SNodeIt& n) const { 
 //       this->s_false_t_true_map->next(n); return n; 
@@ -159 +165 @@
 //       this->s_false_t_true_map->next(n); return n; 
 //     }
-    OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }
-    InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
-
-    Node tail(const Edge& e) { 
-      if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
-        return Node(this->graph->tail(e));
-      else
-        return Node(this->graph->head(e));      
-    }
-    Node head(const Edge& e) { 
-      if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
-        return Node(this->graph->head(e));
-      else
-        return Node(this->graph->tail(e));      
-    }
-
-    Node aNode(const OutEdgeIt& e) const { 
-      return Node(this->graph->aNode(e.e)); 
-    }
-    Node aNode(const InEdgeIt& e) const { 
-      return Node(this->graph->aNode(e.e)); 
-    }
-    Node bNode(const OutEdgeIt& e) const { 
-      return Node(this->graph->bNode(e.e)); 
-    }
-    Node bNode(const InEdgeIt& e) const { 
-      return Node(this->graph->bNode(e.e)); 
-    }
+//     OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }
+//     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
+
+//     Node tail(const Edge& e) { 
+//       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
+//      return Node(this->graph->tail(e));
+//       else
+//      return Node(this->graph->head(e));      
+//     }
+//     Node head(const Edge& e) { 
+//       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
+//      return Node(this->graph->head(e));
+//       else
+//      return Node(this->graph->tail(e));      
+//     }
+
+//     Node aNode(const OutEdgeIt& e) const { 
+//       return Node(this->graph->aNode(e.e)); 
+//     }
+//     Node aNode(const InEdgeIt& e) const { 
+//       return Node(this->graph->aNode(e.e)); 
+//     }
+//     Node bNode(const OutEdgeIt& e) const { 
+//       return Node(this->graph->bNode(e.e)); 
+//     }
+//     Node bNode(const InEdgeIt& e) const { 
+//       return Node(this->graph->bNode(e.e)); 
+//     }
 
     /// Returns true iff \c n is in S.