Changeset 2031:080d51024ac5 in lemon-0.x for lemon/graph_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/graph_adaptor.h (modified) (25 diffs)

lemon/graph_adaptor.h

@@ -20 +20 @@
 #define LEMON_GRAPH_ADAPTOR_H
 
-///\ingroup graph_adaptors
-///\file
-///\brief Several graph adaptors.
+/// \ingroup graph_adaptors
+/// \file
+/// \brief Several graph adaptors.
 ///
-///This file contains several useful graph adaptor functions.
+/// This file contains several useful graph adaptor functions.
 ///
-///\author Marton Makai
+/// \author Marton Makai and Balazs Dezso
 
 #include <lemon/bits/invalid.h>
@@ -62 +62 @@
   public:
     typedef _Graph Graph;
+    typedef GraphAdaptorBase Adaptor;
     typedef Graph ParentGraph;
 
@@ -116 +117 @@
     int id(const Edge& e) const { return graph->id(e); }
 
+    Node fromNodeId(int id) const {
+      return graph->fromNodeId(id);
+    }
+
+    Edge fromEdgeId(int id) const {
+      return graph->fromEdgeId(id);
+    }
+
     int maxNodeId() const {
       return graph->maxNodeId();
@@ -137 +146 @@
     
     template <typename _Value>
-    class NodeMap : public _Graph::template NodeMap<_Value> {
+    class NodeMap : public Graph::template NodeMap<_Value> {
     public:
-      typedef typename _Graph::template NodeMap<_Value> Parent;
-      explicit NodeMap(const GraphAdaptorBase<_Graph>& ga) 
-        : Parent(*ga.graph) { }
-      NodeMap(const GraphAdaptorBase<_Graph>& ga, const _Value& value)
+
+      typedef typename Graph::template NodeMap<_Value> Parent;
+
+      explicit NodeMap(const Adaptor& ga) 
+        : Parent(*ga.graph) {}
+
+      NodeMap(const Adaptor& ga, const _Value& 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;
+      }
+      
     };
 
     template <typename _Value>
-    class EdgeMap : public _Graph::template EdgeMap<_Value> {
+    class EdgeMap : public Graph::template EdgeMap<_Value> {
     public:
-      typedef typename _Graph::template EdgeMap<_Value> Parent;
-      explicit EdgeMap(const GraphAdaptorBase<_Graph>& ga) 
-        : Parent(*ga.graph) { }
-      EdgeMap(const GraphAdaptorBase<_Graph>& ga, const _Value& value)
-        : Parent(*ga.graph, value) { }
+      
+      typedef typename Graph::template EdgeMap<_Value> Parent;
+      
+      explicit EdgeMap(const Adaptor& ga) 
+        : Parent(*ga.graph) {}
+
+      EdgeMap(const Adaptor& 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;
+      }
+
     };
 
@@ -256 +293 @@
   public:
     typedef _Graph Graph;
+    typedef SubGraphAdaptorBase Adaptor;
     typedef GraphAdaptorBase<_Graph> Parent;
   protected:
@@ -378 +416 @@
       return edge;
     }
+
+    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;
+      }
+    };
+
   };
 
@@ -385 +476 @@
   public:
     typedef _Graph Graph;
+    typedef SubGraphAdaptorBase Adaptor;
     typedef GraphAdaptorBase<_Graph> Parent;
   protected:
@@ -497 +589 @@
       return edge;
     }
+
+    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;
+      }
+    };
+
   };
 
@@ -567 +712 @@
   public:
     typedef _Graph Graph;
-    typedef GraphAdaptorExtender<
-      SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent;
+    typedef GraphAdaptorExtender< SubGraphAdaptorBase<_Graph, NodeFilterMap, 
+                                                      EdgeFilterMap, checked> >
+    Parent;
+
   protected:
     SubGraphAdaptor() { }
   public:
+
     SubGraphAdaptor(_Graph& _graph, NodeFilterMap& _node_filter_map, 
                     EdgeFilterMap& _edge_filter_map) { 
@@ -578 +726 @@
       setEdgeFilterMap(_edge_filter_map);
     }
+
   };
 
@@ -636 +785 @@
                            ConstMap<typename Graph::Edge,bool>, checked> {
   public:
+
     typedef SubGraphAdaptor<Graph, NodeFilterMap, 
-                            ConstMap<typename Graph::Edge,bool> > Parent;
+                            ConstMap<typename Graph::Edge,bool>, checked > 
+    Parent;
+
   protected:
     ConstMap<typename Graph::Edge, bool> const_true_map;
@@ -646 +798 @@
 
   public:
+
     NodeSubGraphAdaptor(Graph& _graph, NodeFilterMap& _node_filter_map) : 
       Parent(), const_true_map(true) { 
@@ -652 +805 @@
       Parent::setEdgeFilterMap(const_true_map);
     }
+
   };
 
@@ -821 +975 @@
 
   public:
+
     EdgeSubGraphAdaptor(Graph& _graph, EdgeFilterMap& _edge_filter_map) : 
       Parent(), const_true_map(true) { 
@@ -827 +982 @@
       Parent::setEdgeFilterMap(_edge_filter_map);
     }
+
   };
 
@@ -849 +1005 @@
   public:
     typedef _Graph Graph;
+    typedef UndirGraphAdaptorBase Adaptor;
     typedef UGraphBaseExtender<GraphAdaptorBase<_Graph> > Parent;
 
@@ -860 +1017 @@
     typedef typename Parent::Edge Edge;
 
+  private:
     
     template <typename _Value>
-    class EdgeMap {
+    class EdgeMapBase {
     private:
       
@@ -874 +1032 @@
       typedef Edge Key;
       
-      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g) :
-        forward_map(*(_g.graph)), backward_map(*(_g.graph)) {}
-
-      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g, const Value& a) 
-        : forward_map(*(_g.graph), a), backward_map(*(_g.graph), a) {}
+      EdgeMapBase(const Adaptor& adaptor) :
+        forward_map(*adaptor.graph), backward_map(*adaptor.graph) {}
+
+      EdgeMapBase(const Adaptor& adaptor, const Value& v) 
+        : forward_map(*adaptor.graph, v), backward_map(*adaptor.graph, v) {}
       
       void set(const Edge& e, const Value& a) { 
@@ -909 +1067 @@
 
     };
+
+  public:
+
+    template <typename _Value>
+    class EdgeMap 
+      : public SubMapExtender<Adaptor, EdgeMapBase<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, EdgeMapBase<_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 _Graph::template EdgeMap<_Value> {
+    class UEdgeMap : public Graph::template EdgeMap<_Value> {
     public:
-
-      typedef typename _Graph::template EdgeMap<_Value> Parent; 
-
-      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) 
-        : Parent(*(g.graph)) {}
-
-      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, const _Value& a) 
-        : Parent(*(g.graph), a) {}
-      
+      
+      typedef typename Graph::template EdgeMap<_Value> Parent;
+      
+      explicit UEdgeMap(const Adaptor& ga) 
+        : Parent(*ga.graph) {}
+
+      UEdgeMap(const Adaptor& ga, const _Value& value)
+        : Parent(*ga.graph, value) {}
+
+      UEdgeMap& operator=(const UEdgeMap& cmap) {
+        return operator=<UEdgeMap>(cmap);
+      }
+
+      template <typename CMap>
+      UEdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+
     };
       
@@ -934 +1128 @@
 
     typedef _Graph Graph;
+    typedef UndirGraphAdaptorBase Adaptor;
     typedef UGraphBaseExtender<GraphAdaptorBase<_Graph> > Parent;
 
@@ -1034 +1229 @@
     NotifierProxy edge_notifier_proxy;
 
-  public:
-    
+  private:
     
     template <typename _Value>
-    class EdgeMap {
+    class EdgeMapBase {
     private:
       
@@ -1050 +1244 @@
       typedef Edge Key;
       
-      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g) :
-        forward_map(*(_g.graph)), backward_map(*(_g.graph)) {}
-
-      EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g, const Value& a) 
-        : forward_map(*(_g.graph), a), backward_map(*(_g.graph), a) {}
+      EdgeMapBase(const Adaptor& adaptor) :
+        forward_map(*adaptor.graph), backward_map(*adaptor.graph) {}
+
+      EdgeMapBase(const Adaptor& adaptor, const Value& v) 
+        : forward_map(*adaptor.graph, v), backward_map(*adaptor.graph, v) {}
       
       void set(const Edge& e, const Value& a) { 
@@ -1064 +1258 @@
       }
 
-      typename MapTraits<MapImpl>::ConstReturnValue 
-      operator[](const Edge& e) const { 
+      typename MapTraits<MapImpl>::ConstReturnValue operator[](Edge e) const { 
         if (Parent::direction(e)) {
           return forward_map[e]; 
@@ -1073 +1266 @@
       }
 
-      typename MapTraits<MapImpl>::ReturnValue 
-      operator[](const Edge& e) { 
+      typename MapTraits<MapImpl>::ReturnValue operator[](Edge e) { 
         if (Parent::direction(e)) {
           return forward_map[e]; 
@@ -1087 +1279 @@
 
     };
+
+  public:
+
+    template <typename _Value>
+    class EdgeMap 
+      : public SubMapExtender<Adaptor, EdgeMapBase<_Value> > 
+    {
+    public:
+      typedef Adaptor Graph;
+      typedef SubMapExtender<Adaptor, EdgeMapBase<_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 _Graph::template EdgeMap<_Value> {
+    class UEdgeMap : public Graph::template EdgeMap<_Value> {
     public:
-
-      typedef typename _Graph::template EdgeMap<_Value> Parent; 
-
-      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) 
-        : Parent(*(g.graph)) {}
-
-      UEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, const _Value& a) 
-        : Parent(*(g.graph), a) {}
-      
+      
+      typedef typename Graph::template EdgeMap<_Value> Parent;
+      
+      explicit UEdgeMap(const Adaptor& ga) 
+        : Parent(*ga.graph) {}
+
+      UEdgeMap(const Adaptor& ga, const _Value& value)
+        : Parent(*ga.graph, value) {}
+
+      UEdgeMap& operator=(const UEdgeMap& cmap) {
+        return operator=<UEdgeMap>(cmap);
+      }
+
+      template <typename CMap>
+      UEdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+
     };