Changeset 158:4f54d89fa9d2 in lemon-0.x for src/work/marci

Timestamp:

03/08/04 13:29:07 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

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

Message:

a lot of interesting and very useful wrapper graphs

File:

• src/work/marci/graph_wrapper.h (modified) (6 diffs)

src/work/marci/graph_wrapper.h

@@ -63 +63 @@
     public:
       NodeMap(const TrivGraphWrapper<Graph>& _G) : 
-        Graph::NodeMap<T>(*(_G.G)) { }
+        Graph::NodeMap<T>(_G.getGraph()) { }
       NodeMap(const TrivGraphWrapper<Graph>& _G, T a) : 
-        Graph::NodeMap<T>(*(_G.G), a) { }
+        Graph::NodeMap<T>(_G.getGraph(), a) { }
     };
     template<typename T> class EdgeMap : public Graph::EdgeMap<T> { 
     public:
       EdgeMap(const TrivGraphWrapper<Graph>& _G) : 
-        Graph::EdgeMap<T>(*(_G.G)) { }
+        Graph::EdgeMap<T>(_G.getGraph()) { }
       EdgeMap(const TrivGraphWrapper<Graph>& _G, T a) : 
-        Graph::EdgeMap<T>(*(_G.G), a) { }
+        Graph::EdgeMap<T>(_G.getGraph(), a) { }
     };
     
@@ -141 +141 @@
     public:
       NodeMap(const RevGraphWrapper<Graph>& _G) : 
-        Graph::NodeMap<T>(*(_G.G)) { }
+        Graph::NodeMap<T>(_G.getGraph()) { }
       NodeMap(const RevGraphWrapper<Graph>& _G, T a) : 
-        Graph::NodeMap<T>(*(_G.G), a) { }
+        Graph::NodeMap<T>(_G.getGraph(), a) { }
     };
     template<typename T> class EdgeMap : public Graph::EdgeMap<T> { 
     public:
       EdgeMap(const RevGraphWrapper<Graph>& _G) : 
-        Graph::EdgeMap<T>(*(_G.G)) { }
+        Graph::EdgeMap<T>(_G.getGraph()) { }
       EdgeMap(const RevGraphWrapper<Graph>& _G, T a) : 
-        Graph::EdgeMap<T>(*(_G.G), a) { }
+        Graph::EdgeMap<T>(_G.getGraph(), a) { }
     };
 
@@ -159 +159 @@
     RevGraphWrapper(Graph& _graph) : graph(&_graph) { }
   };
+
+
+  template<typename Graph>
+  class UndirGraphWrapper {
+    Graph* graph;
+  
+  public:
+    typedef Graph BaseGraph;
+
+    typedef typename Graph::NodeIt NodeIt;
+    typedef typename Graph::EachNodeIt EachNodeIt;
+
+    //typedef typename Graph::EdgeIt EdgeIt;
+    //typedef typename Graph::OutEdgeIt OutEdgeIt;
+    //typedef typename Graph::InEdgeIt InEdgeIt;
+    //typedef typename Graph::SymEdgeIt SymEdgeIt;
+    //typedef typename Graph::EachEdgeIt EachEdgeIt;
+
+    //private:
+    typedef typename Graph::EdgeIt GraphEdgeIt;
+    typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
+    typedef typename Graph::InEdgeIt GraphInEdgeIt;
+    //public:
+
+    class EdgeIt {
+      friend class UndirGraphWrapper<Graph>;
+      bool out_or_in; //true iff out
+      GraphOutEdgeIt out;
+      GraphInEdgeIt in;
+    public:
+      EdgeIt() : out_or_in(true), out(), in() { }
+      operator GraphEdgeIt() const {
+        if (out_or_in) return(out); else return(in);
+      }
+    };
+
+    class OutEdgeIt : public EdgeIt {
+      friend class UndirGraphWrapper<Graph>;
+      //bool out_or_in; //true iff out
+      //GraphOutEdgeIt out;
+      //GraphInEdgeIt in;
+    public:
+      OutEdgeIt() : EdgeIt() { }
+      OutEdgeIt(const UndirGraphWrapper& _G, const NodeIt& n) : EdgeIt() { 
+        _G.graph->getFirst(out, n);
+        if (!(_G.graph->valid(out))) {
+          out_or_in=false;
+          _G.graph->getFirst(in, n);
+        }
+      }
+    };
+
+    OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const {
+      e.out_or_in=true;
+      graph->getFirst(e.out, n);
+      if (!(graph->valid(e.out))) {
+        e.out_or_in=false;
+        graph->getFirst(e.in, n);
+      }
+      return e;
+    }
+
+    OutEdgeIt& next(OutEdgeIt& e) const {
+      if (e.out_or_in) {
+        NodeIt n=graph->tail(e.out);
+        graph->next(e.out);
+        if (!graph->valid(e.out)) {
+          e.out_or_in=false;
+          graph->getFirst(e.in, n);
+        }
+      } else {
+        graph->next(e.in);
+      }
+      return e;
+    }
+
+    NodeIt aNode(const OutEdgeIt& e) const { 
+      if (e.out_or_in) return graph->tail(e); else return graph->head(e); }
+    NodeIt bNode(const OutEdgeIt& e) const { 
+      if (e.out_or_in) return graph->head(e); else return graph->tail(e); }
+
+    typedef OutEdgeIt InEdgeIt; 
+
+    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
+//     template<typename I, typename P> I& getFirst(I& i, const P& p) const { 
+//       return graph->getFirst(i, p); }
+    
+    template<typename I> I getNext(const I& i) const { 
+      return graph->getNext(i); }
+    template<typename I> I& next(I &i) const { return graph->next(i); }    
+
+    template< typename It > It first() const { 
+      It e; getFirst(e); return e; }
+
+    template< typename It > It first(const NodeIt& v) const { 
+      It e; getFirst(e, v); return e; }
+
+    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
+    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
+
+    template<typename I> bool valid(const I& i) const 
+      { return graph->valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+
+    int nodeNum() const { return graph->nodeNum(); }
+    int edgeNum() const { return graph->edgeNum(); }
+  
+//     template<typename I> NodeIt aNode(const I& e) const { 
+//       return graph->aNode(e); }
+//     template<typename I> NodeIt bNode(const I& e) const { 
+//       return graph->bNode(e); }
+  
+    NodeIt addNode() const { return graph->addNode(); }
+    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const { 
+      return graph->addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) const { graph->erase(i); }
+  
+    void clear() const { graph->clear(); }
+    
+    template<typename T> class NodeMap : public Graph::NodeMap<T> { 
+    public:
+      NodeMap(const UndirGraphWrapper<Graph>& _G) : 
+        Graph::NodeMap<T>(_G.getGraph()) { }
+      NodeMap(const UndirGraphWrapper<Graph>& _G, T a) : 
+        Graph::NodeMap<T>(_G.getGraph(), a) { }
+    };
+    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { 
+    public:
+      EdgeMap(const UndirGraphWrapper<Graph>& _G) : 
+        Graph::EdgeMap<T>(_G.getGraph()) { }
+      EdgeMap(const UndirGraphWrapper<Graph>& _G, T a) : 
+        Graph::EdgeMap<T>(_G.getGraph(), a) { }
+    };
+    
+    void setGraph(Graph& _graph) { graph = &_graph; }
+    Graph& getGraph() const { return (*graph); }
+  
+    //TrivGraphWrapper() : graph(0) { }
+    UndirGraphWrapper(Graph& _graph) : graph(&_graph) { }
+  };
+
 
 
@@ -248 +392 @@
 //     ResGraphWrapper(const ResGraphWrapper& res_graph_wrapper) : 
 //       G(res_graph_wrapper.G), flow(res_graph_wrapper.flow), capacity(res_graph_wrapper.capacity) { }
+    void setGraph(Graph& _graph) { graph = &_graph; }
+    Graph& getGraph() const { return (*graph); }
     class EdgeIt; 
     class OutEdgeIt; 
@@ -500 +646 @@
     public:
       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) 
-        : Graph::NodeMap<T>(*(_G.G)) { }
+        : Graph::NodeMap<T>(_G.getGraph()) { }
       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, 
-              T a) : Graph::NodeMap<T>(*(_G.G), a) { }
+              T a) : Graph::NodeMap<T>(_G.getGraph(), a) { }
     };
 
@@ -519 +665 @@
       typename Graph::EdgeMap<T> forward_map, backward_map; 
     public:
-      EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : forward_map(*(_G.G)), backward_map(*(_G.G)) { }
-      EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : forward_map(*(_G.G), a), backward_map(*(_G.G), a) { }
+      EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : forward_map(_G.getGraph()), backward_map(_G.getGraph()) { }
+      EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : forward_map(_G.getGraph(), a), backward_map(_G.getGraph(), a) { }
       void set(EdgeIt e, T a) { 
         if (e.out_or_in)