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

lemon/bits/graph_adaptor_extender.h

@@ -34 +34 @@
   ///
   /// \brief Extender for the GraphAdaptors
-  template <typename Base>
-  class GraphAdaptorExtender : public Base {
+  template <typename _Graph>
+  class GraphAdaptorExtender : public _Graph {
   public:
 
-    typedef Base Parent;
-    typedef GraphAdaptorExtender Graph;
+    typedef _Graph Parent;
+    typedef _Graph Graph;
+    typedef GraphAdaptorExtender Adaptor;
 
     // Base extensions
@@ -72 +73 @@
 
     class NodeIt : public Node { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -79 +80 @@
       NodeIt(Invalid i) : Node(i) { }
 
-      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node) 
+      explicit NodeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Adaptor& _graph, const Node& node) 
         : Node(node), graph(&_graph) {}
 
@@ -95 +96 @@
 
     class EdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -102 +103 @@
       EdgeIt(Invalid i) : Edge(i) { }
 
-      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) : 
+      explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Adaptor& _graph, const Edge& e) : 
         Edge(e), graph(&_graph) { }
 
@@ -118 +119 @@
 
     class OutEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -125 +126 @@
       OutEdgeIt(Invalid i) : Edge(i) { }
 
-      OutEdgeIt(const Graph& _graph, const Node& node) 
+      OutEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstOut(*this, node);
       }
 
-      OutEdgeIt(const Graph& _graph, const Edge& edge) 
+      OutEdgeIt(const Adaptor& _graph, const Edge& edge) 
         : Edge(edge), graph(&_graph) {}
 
@@ -142 +143 @@
 
     class InEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -149 +150 @@
       InEdgeIt(Invalid i) : Edge(i) { }
 
-      InEdgeIt(const Graph& _graph, const Node& node) 
+      InEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstIn(*this, node);
       }
 
-      InEdgeIt(const Graph& _graph, const Edge& edge) : 
+      InEdgeIt(const Adaptor& _graph, const Edge& edge) : 
         Edge(edge), graph(&_graph) {}
 
@@ -198 +199 @@
   ///
   /// \brief Extender for the UGraphAdaptors
-  template <typename Base> 
-  class UGraphAdaptorExtender : public Base {
+  template <typename _UGraph> 
+  class UGraphAdaptorExtender : public _UGraph {
   public:
     
-    typedef Base Parent;
-    typedef UGraphAdaptorExtender Graph;
+    typedef _UGraph Parent;
+    typedef _UGraph UGraph;
+    typedef UGraphAdaptorExtender Adaptor;
 
     typedef typename Parent::Node Node;
@@ -255 +257 @@
 
     class NodeIt : public Node { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -262 +264 @@
       NodeIt(Invalid i) : Node(i) { }
 
-      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Node*>(this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node) 
+      explicit NodeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Adaptor& _graph, const Node& node) 
         : Node(node), graph(&_graph) {}
 
@@ -278 +280 @@
 
     class EdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -285 +287 @@
       EdgeIt(Invalid i) : Edge(i) { }
 
-      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<Edge*>(this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) : 
+      explicit EdgeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Adaptor& _graph, const Edge& e) : 
         Edge(e), graph(&_graph) { }
 
@@ -301 +303 @@
 
     class OutEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -308 +310 @@
       OutEdgeIt(Invalid i) : Edge(i) { }
 
-      OutEdgeIt(const Graph& _graph, const Node& node) 
+      OutEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstOut(*this, node);
       }
 
-      OutEdgeIt(const Graph& _graph, const Edge& edge) 
+      OutEdgeIt(const Adaptor& _graph, const Edge& edge) 
         : Edge(edge), graph(&_graph) {}
 
@@ -325 +327 @@
 
     class InEdgeIt : public Edge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -332 +334 @@
       InEdgeIt(Invalid i) : Edge(i) { }
 
-      InEdgeIt(const Graph& _graph, const Node& node) 
+      InEdgeIt(const Adaptor& _graph, const Node& node) 
         : graph(&_graph) {
         _graph.firstIn(*this, node);
       }
 
-      InEdgeIt(const Graph& _graph, const Edge& edge) : 
+      InEdgeIt(const Adaptor& _graph, const Edge& edge) : 
         Edge(edge), graph(&_graph) {}
 
@@ -348 +350 @@
 
     class UEdgeIt : public Parent::UEdge { 
-      const Graph* graph;
+      const Adaptor* graph;
     public:
 
@@ -355 +357 @@
       UEdgeIt(Invalid i) : UEdge(i) { }
 
-      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<UEdge*>(this));
-      }
-
-      UEdgeIt(const Graph& _graph, const UEdge& e) : 
+      explicit UEdgeIt(const Adaptor& _graph) : graph(&_graph) {
+        _graph.first(static_cast<UEdge&>(*this));
+      }
+
+      UEdgeIt(const Adaptor& _graph, const UEdge& e) : 
         UEdge(e), graph(&_graph) { }
 
@@ -371 +373 @@
     class IncEdgeIt : public Parent::UEdge { 
       friend class UGraphAdaptorExtender;
-      const Graph* graph;
+      const Adaptor* graph;
       bool direction;
     public:
@@ -379 +381 @@
       IncEdgeIt(Invalid i) : UEdge(i), direction(false) { }
 
-      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
+      IncEdgeIt(const Adaptor& _graph, const Node &n) : graph(&_graph) {
         _graph.firstInc(static_cast<UEdge&>(*this), direction, n);
       }
 
-      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+      IncEdgeIt(const Adaptor& _graph, const UEdge &ue, const Node &n)
         : graph(&_graph), UEdge(ue) {
         direction = (_graph.source(ue) == n);
@@ -437 +439 @@
   };
 
+  /// \ingroup graphbits
+  ///
+  /// \brief Extender for the BpUGraphAdaptors
+  template <typename Base>
+  class BpUGraphAdaptorExtender : public Base {
+  public:
+    typedef Base Parent;
+    typedef BpUGraphAdaptorExtender Graph;
+
+    typedef typename Parent::Node Node;
+    typedef typename Parent::BNode BNode;
+    typedef typename Parent::ANode ANode;
+    typedef typename Parent::Edge Edge;
+    typedef typename Parent::UEdge UEdge;
+
+    Node oppositeNode(const UEdge& edge, const Node& node) const {
+      return source(edge) == node ? 
+        target(edge) : source(edge);
+    }
+
+
+    int maxId(Node) const {
+      return Parent::maxNodeId();
+    }
+    int maxId(BNode) const {
+      return Parent::maxBNodeId();
+    }
+    int maxId(ANode) const {
+      return Parent::maxANodeId();
+    }
+    int maxId(Edge) const {
+      return Parent::maxEdgeId();
+    }
+    int maxId(UEdge) const {
+      return Parent::maxUEdgeId();
+    }
+
+
+    Node fromId(int id, Node) const {
+      return Parent::nodeFromId(id);
+    }
+    ANode fromId(int id, ANode) const {
+      return Parent::fromANodeId(id);
+    }
+    BNode fromId(int id, BNode) const {
+      return Parent::fromBNodeId(id);
+    }
+    Edge fromId(int id, Edge) const {
+      return Parent::edgeFromId(id);
+    }
+    UEdge fromId(int id, UEdge) const {
+      return Parent::uEdgeFromId(id);
+    }  
+  
+    class NodeIt : public Node { 
+      const Graph* graph;
+    public:
+    
+      NodeIt() { }
+    
+      NodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
+        graph->first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Graph& _graph, const Node& node) 
+        : Node(node), graph(&_graph) { }
+    
+      NodeIt& operator++() { 
+        graph->next(*this);
+        return *this; 
+      }
+
+    };
+
+    class ANodeIt : public Node { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      ANodeIt() { }
+    
+      ANodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit ANodeIt(const Graph& _graph) : graph(&_graph) {
+        graph->firstANode(static_cast<Node&>(*this));
+      }
+
+      ANodeIt(const Graph& _graph, const Node& node) 
+        : Node(node), graph(&_graph) {}
+    
+      ANodeIt& operator++() { 
+        graph->nextANode(*this);
+        return *this; 
+      }
+    };
+
+    class BNodeIt : public Node { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      BNodeIt() { }
+    
+      BNodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit BNodeIt(const Graph& _graph) : graph(&_graph) {
+        graph->firstBNode(static_cast<Node&>(*this));
+      }
+
+      BNodeIt(const Graph& _graph, const Node& node) 
+        : Node(node), graph(&_graph) {}
+    
+      BNodeIt& operator++() { 
+        graph->nextBNode(*this);
+        return *this; 
+      }
+    };
+
+    class EdgeIt : public Edge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      EdgeIt() { }
+    
+      EdgeIt(Invalid i) : Edge(INVALID) { }
+    
+      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
+        graph->first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Graph& _graph, const Edge& edge) 
+        : Edge(edge), graph(&_graph) { }
+    
+      EdgeIt& operator++() { 
+        graph->next(*this);
+        return *this; 
+      }
+
+    };
+
+    class UEdgeIt : public UEdge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      UEdgeIt() { }
+    
+      UEdgeIt(Invalid i) : UEdge(INVALID) { }
+    
+      explicit UEdgeIt(const Graph& _graph) : graph(&_graph) {
+        graph->first(static_cast<UEdge&>(*this));
+      }
+
+      UEdgeIt(const Graph& _graph, const UEdge& edge) 
+        : UEdge(edge), graph(&_graph) { }
+    
+      UEdgeIt& operator++() { 
+        graph->next(*this);
+        return *this; 
+      }
+    };
+
+    class OutEdgeIt : public Edge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      OutEdgeIt() { }
+    
+      OutEdgeIt(Invalid i) : Edge(i) { }
+    
+      OutEdgeIt(const Graph& _graph, const Node& node) 
+        : graph(&_graph) {
+        graph->firstOut(*this, node);
+      }
+    
+      OutEdgeIt(const Graph& _graph, const Edge& edge) 
+        : Edge(edge), graph(&_graph) {}
+    
+      OutEdgeIt& operator++() { 
+        graph->nextOut(*this);
+        return *this; 
+      }
+
+    };
+
+
+    class InEdgeIt : public Edge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+    public:
+    
+      InEdgeIt() { }
+    
+      InEdgeIt(Invalid i) : Edge(i) { }
+    
+      InEdgeIt(const Graph& _graph, const Node& node) 
+        : graph(&_graph) {
+        graph->firstIn(*this, node);
+      }
+    
+      InEdgeIt(const Graph& _graph, const Edge& edge) : 
+        Edge(edge), graph(&_graph) {}
+    
+      InEdgeIt& operator++() { 
+        graph->nextIn(*this);
+        return *this; 
+      }
+
+    };
+  
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the source in this case) of the iterator
+    Node baseNode(const OutEdgeIt &e) const {
+      return Parent::source((Edge&)e);
+    }
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the target in this case) of the
+    /// iterator
+    Node runningNode(const OutEdgeIt &e) const {
+      return Parent::target((Edge&)e);
+    }
+  
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the target in this case) of the iterator
+    Node baseNode(const InEdgeIt &e) const {
+      return Parent::target((Edge&)e);
+    }
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the source in this case) of the
+    /// iterator
+    Node runningNode(const InEdgeIt &e) const {
+      return Parent::source((Edge&)e);
+    }
+  
+    class IncEdgeIt : public Parent::UEdge { 
+      friend class BpUGraphAdaptorExtender;
+      const Graph* graph;
+      bool direction;
+    public:
+    
+      IncEdgeIt() { }
+    
+      IncEdgeIt(Invalid i) : UEdge(i), direction(true) { }
+    
+      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
+        graph->firstInc(*this, direction, n);
+      }
+
+      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+        : graph(&_graph), UEdge(ue) {
+        direction = (graph->source(ue) == n);
+      }
+
+      IncEdgeIt& operator++() {
+        graph->nextInc(*this, direction);
+        return *this; 
+      }
+    };
+  
+
+    /// Base node of the iterator
+    ///
+    /// Returns the base node of the iterator
+    Node baseNode(const IncEdgeIt &e) const {
+      return e.direction ? source(e) : target(e);
+    }
+
+    /// Running node of the iterator
+    ///
+    /// Returns the running node of the iterator
+    Node runningNode(const IncEdgeIt &e) const {
+      return e.direction ? target(e) : source(e);
+    }
+
+  };
+
 
 }