Changeset 777:a82713ed19f3 in lemon-0.x for src/hugo/graph_wrapper.h

Timestamp:

08/31/04 19:54:22 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

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

Message:

graph_wrapper.h is ready for hugo 0.2

File:

• src/hugo/graph_wrapper.h (modified) (5 diffs)

src/hugo/graph_wrapper.h

@@ -182 +182 @@
         Edge(typename Graph::EdgeIt(*(_gw.graph))), gw(&_gw) { }
       EdgeIt(const GraphWrapper<Graph>& _gw, const Edge& e) : 
-        Edge(w), gw(&_gw) { }
+        Edge(e), gw(&_gw) { }
       EdgeIt& operator++() { 
         *(static_cast<Edge*>(this))=
@@ -429 +429 @@
       OutEdgeIt(Invalid i) : Edge(i) { }
       OutEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _gw, const Node& n) : 
-        Edge(typename Graph::OutEdgeIt(*(_gw.graph)), n), gw(&_gw) { }
+        Edge(typename Graph::OutEdgeIt(*(_gw.graph), n)), gw(&_gw) { }
       OutEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _gw, 
              const Edge& e) : 
@@ -451 +451 @@
       InEdgeIt(Invalid i) : Edge(i) { }
       InEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _gw, const Node& n) : 
-        Edge(typename Graph::InEdgeIt(*(_gw.graph)), n), gw(&_gw) { }
+        Edge(typename Graph::InEdgeIt(*(_gw.graph), n)), gw(&_gw) { }
       InEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _gw, 
              const Edge& e) : 
@@ -2041 +2041 @@
 //     };
     typedef typename GraphWrapper<Graph>::Edge Edge;
-    class OutEdgeIt { 
+    class OutEdgeIt : public Edge { 
       friend class GraphWrapper<Graph>;
       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
-//      typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
-      typename Graph::OutEdgeIt e;
+      const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>* gw;
     public:
       OutEdgeIt() { }
-      OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
-      OutEdgeIt(const Invalid& i) : e(i) { }
-      OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G, 
-                const Node& _n) : 
-        e((*_G.first_out_edges)[_n]) { }
-      operator Edge() const { return Edge(typename Graph::Edge(e)); }
-    };
-    class InEdgeIt { 
-      friend class GraphWrapper<Graph>;
-      friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
-//      typedef typename Graph::InEdgeIt GraphInEdgeIt;
-      typename Graph::InEdgeIt e;
-    public:
-      InEdgeIt() { }
-      InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
-      InEdgeIt(const Invalid& i) : e(i) { }
-      InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G, 
-               const Node& _n) : 
-        e(*(_G.graph), typename Graph::Node(_n)) { }
-      operator Edge() const { return Edge(typename Graph::Edge(e)); }
-    };
+      //OutEdgeIt(const OutEdgeIt& e) : Edge(e), gw(e.gw) { }
+      OutEdgeIt(Invalid i) : Edge(i) { }
+      OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _gw, 
+                const Node& n) : 
+        Edge((*(_gw.first_out_edges))[n]), gw(&_gw) { }
+      OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _gw, 
+                const Edge& e) : 
+        Edge(e), gw(&_gw) { }
+      OutEdgeIt& operator++() { 
+        *(static_cast<Edge*>(this))=
+          ++(typename Graph::OutEdgeIt(*(gw->graph), *this));
+        return *this; 
+      }
+    };
+//     class InEdgeIt { 
+//       friend class GraphWrapper<Graph>;
+//       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
+// //      typedef typename Graph::InEdgeIt GraphInEdgeIt;
+//       typename Graph::InEdgeIt e;
+//     public:
+//       InEdgeIt() { }
+//       InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
+//       InEdgeIt(const Invalid& i) : e(i) { }
+//       InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G, 
+//             const Node& _n) : 
+//      e(*(_G.graph), typename Graph::Node(_n)) { }
+//       operator Edge() const { return Edge(typename Graph::Edge(e)); }
+//     };       
     //typedef typename Graph::SymEdgeIt SymEdgeIt;
-    class EdgeIt { 
-      friend class GraphWrapper<Graph>;
-      friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
-//      typedef typename Graph::EdgeIt GraphEdgeIt;
-      typename Graph::EdgeIt e;
-    public:
-      EdgeIt() { }
-      EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
-      EdgeIt(const Invalid& i) : e(i) { }
-      EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) : 
-        e(*(_G.graph)) { }
-      operator Edge() const { return Edge(typename Graph::Edge(e)); }
-    };
+//     class EdgeIt { 
+//       friend class GraphWrapper<Graph>;
+//       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
+// //      typedef typename Graph::EdgeIt GraphEdgeIt;
+//       typename Graph::EdgeIt e;
+//     public:
+//       EdgeIt() { }
+//       EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
+//       EdgeIt(const Invalid& i) : e(i) { }
+//       EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) : 
+//      e(*(_G.graph)) { }
+//       operator Edge() const { return Edge(typename Graph::Edge(e)); }
+//     };
 
     using GraphWrapper<Graph>::first;
@@ -2091 +2097 @@
       i=OutEdgeIt(*this, p); return i;
     }
-    InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
-      i=InEdgeIt(*this, p); return i;
-    }
-    EdgeIt& first(EdgeIt& i) const { 
-      i=EdgeIt(*this); return i;
-    }
-
-    using GraphWrapper<Graph>::next;
-//    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
-    OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }
-    InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
-    EdgeIt& next(EdgeIt& i) const { this->graph->next(i.e); return i; }    
+//     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
+//       i=InEdgeIt(*this, p); return i;
+//     }
+//     EdgeIt& first(EdgeIt& i) const { 
+//       i=EdgeIt(*this); return i;
+//     }
+
+//     using GraphWrapper<Graph>::next;
+// //    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
+//     OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }
+//     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
+//     EdgeIt& next(EdgeIt& i) const { this->graph->next(i.e); return i; }    
     
-    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)); }
-
-    void erase(const OutEdgeIt& e) const {
-      OutEdgeIt f=e;
-      this->next(f);
-      first_out_edges->set(this->tail(e), f.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)); }
+
+    void erase(const Edge& e) const {
+      Node n=tail(e);
+      typename Graph::OutEdgeIt f(*graph, n);
+      ++f;
+      first_out_edges->set(n, f);
     }
   };