Changeset 2031:080d51024ac5 in lemon-0.x for lemon/ugraph_adaptor.h

Timestamp:

04/03/06 11:45:23 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Correcting the structure of the graph's and adaptor's map.
The template assign operators and map iterators can be used for adaptors also.

Some bugfix in the adaptors

New class SwapBpUGraphAdaptor which swaps the two nodeset of the graph.

File:

• lemon/ugraph_adaptor.h (modified) (14 diffs)

lemon/ugraph_adaptor.h

@@ -102 +102 @@
     typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
     int edgeNum() const { return graph->edgeNum(); }
+    int uEdgeNum() const { return graph->uEdgeNum(); }
 
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
@@ -119 +120 @@
 
     void erase(const Node& i) const { graph->erase(i); }
-    void erase(const Edge& i) const { graph->erase(i); }
+    void erase(const UEdge& i) const { graph->erase(i); }
   
     void clear() const { graph->clear(); }
     
-    int id(const Node& v) const { return graph->id(v); }
-    int id(const UEdge& e) const { return graph->id(e); }
-
     bool direction(const Edge& e) const { return graph->direction(e); }
     Edge direct(const UEdge& e, bool d) const { return graph->direct(e, d); }
+
+    int id(const Node& v) const { return graph->id(v); }
+    int id(const Edge& e) const { return graph->id(e); }
+    int id(const UEdge& e) const { return graph->id(e); }
+
+    Node fromNodeId(int id) const {
+      return graph->fromNodeId(id);
+    }
+
+    Edge fromEdgeId(int id) const {
+      return graph->fromEdgeId(id);
+    }
+
+    UEdge fromUEdgeId(int id) const {
+      return graph->fromUEdgeId(id);
+    }
 
     int maxNodeId() const {
@@ -174 +188 @@
       template <typename CMap>
       NodeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        Node it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
-        return *this;
-      }
+        Parent::operator=(cmap);
+        return *this;
+      }
+
     };
 
@@ -199 +209 @@
       template <typename CMap>
       EdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        Edge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
+        Parent::operator=(cmap);
         return *this;
       }
@@ -224 +229 @@
       template <typename CMap>
       UEdgeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<UEdge, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        UEdge it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
-        return *this;
+        Parent::operator=(cmap);
+        return *this;
       }
     };
@@ -255 +255 @@
   public:
     typedef _UGraph Graph;
+    typedef SubUGraphAdaptorBase Adaptor;
     typedef UGraphAdaptorBase<_UGraph> Parent;
   protected:
@@ -417 +418 @@
       return uedge;
     }
+
+    template <typename _Value>
+    class NodeMap 
+      : public SubMapExtender<Adaptor, 
+                              typename Parent::template NodeMap<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, typename Parent::
+                             template NodeMap<_Value> > Parent;
+    
+      NodeMap(const Graph& graph) 
+        : Parent(graph) {}
+      NodeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
+    
+      NodeMap& operator=(const NodeMap& cmap) {
+        return operator=<NodeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      NodeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
+
+    template <typename _Value>
+    class EdgeMap 
+      : public SubMapExtender<Adaptor, 
+                              typename Parent::template EdgeMap<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, typename Parent::
+                             template EdgeMap<_Value> > Parent;
+    
+      EdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      EdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
+    
+      EdgeMap& operator=(const EdgeMap& cmap) {
+        return operator=<EdgeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      EdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
+
+    template <typename _Value>
+    class UEdgeMap 
+      : public SubMapExtender<Adaptor, 
+                              typename Parent::template UEdgeMap<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, typename Parent::
+                             template UEdgeMap<_Value> > Parent;
+    
+      UEdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      UEdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
+    
+      UEdgeMap& operator=(const UEdgeMap& cmap) {
+        return operator=<UEdgeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      UEdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
+
   };
 
@@ -424 +504 @@
   public:
     typedef _UGraph Graph;
+    typedef SubUGraphAdaptorBase Adaptor;
     typedef UGraphAdaptorBase<_UGraph> Parent;
   protected:
@@ -560 +641 @@
       return uedge;
     }
+
+    template <typename _Value>
+    class NodeMap 
+      : public SubMapExtender<Adaptor, 
+                              typename Parent::template NodeMap<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, typename Parent::
+                             template NodeMap<_Value> > Parent;
+    
+      NodeMap(const Graph& graph) 
+        : Parent(graph) {}
+      NodeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
+    
+      NodeMap& operator=(const NodeMap& cmap) {
+        return operator=<NodeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      NodeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
+
+    template <typename _Value>
+    class EdgeMap 
+      : public SubMapExtender<Adaptor, 
+                              typename Parent::template EdgeMap<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, typename Parent::
+                             template EdgeMap<_Value> > Parent;
+    
+      EdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      EdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
+    
+      EdgeMap& operator=(const EdgeMap& cmap) {
+        return operator=<EdgeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      EdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
+
+    template <typename _Value>
+    class UEdgeMap 
+      : public SubMapExtender<Adaptor, 
+                              typename Parent::template UEdgeMap<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, typename Parent::
+                             template UEdgeMap<_Value> > Parent;
+    
+      UEdgeMap(const Graph& graph) 
+        : Parent(graph) {}
+      UEdgeMap(const Graph& graph, const _Value& value) 
+        : Parent(graph, value) {}
+    
+      UEdgeMap& operator=(const UEdgeMap& cmap) {
+        return operator=<UEdgeMap>(cmap);
+      }
+    
+      template <typename CMap>
+      UEdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+    };
   };
 
@@ -679 +838 @@
   }
 
-
   /// \brief An adaptor for hiding undirected edges from an undirected graph.
   ///
@@ -705 +863 @@
 
   public:
+
     EdgeSubUGraphAdaptor(Graph& _graph, UEdgeFilterMap& _uedge_filter_map) : 
       Parent(), const_true_map(true) { 
@@ -711 +870 @@
       Parent::setUEdgeFilterMap(_uedge_filter_map);
     }
+
   };
 
@@ -838 +998 @@
     class NodeMap : public _UGraph::template NodeMap<_Value> {
     public:
+
       typedef typename _UGraph::template NodeMap<_Value> Parent;
+
       explicit NodeMap(const DirUGraphAdaptorBase& ga) 
-        : Parent(*ga.graph) { }
+        : Parent(*ga.graph) {}
+
       NodeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
-        : Parent(*ga.graph, value) { }
+        : Parent(*ga.graph, value) {}
+
+      NodeMap& operator=(const NodeMap& cmap) {
+        return operator=<NodeMap>(cmap);
+      }
+
+      template <typename CMap>
+      NodeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+
     };
 
@@ -848 +1022 @@
     class EdgeMap : public _UGraph::template UEdgeMap<_Value> {
     public:
+
       typedef typename _UGraph::template UEdgeMap<_Value> Parent;
+
       explicit EdgeMap(const DirUGraphAdaptorBase& ga) 
         : Parent(*ga.graph) { }
+
       EdgeMap(const DirUGraphAdaptorBase& ga, const _Value& value)
         : Parent(*ga.graph, value) { }
+
+      EdgeMap& operator=(const EdgeMap& cmap) {
+        return operator=<EdgeMap>(cmap);
+      }
+
+      template <typename CMap>
+      EdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
     };