Changeset 1909:2d806130e700 in lemon-0.x for lemon/bits/iterable_graph_extender.h

Timestamp:

01/26/06 16:42:13 (18 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

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

Message:

Undir -> U transition

File:

• lemon/bits/iterable_graph_extender.h (modified) (17 diffs)

lemon/bits/iterable_graph_extender.h

@@ -17 +17 @@
     ///
     ///\bug Should it be here?
-    typedef False UndirTag;
+    typedef False UTag;
 
     typedef _Base Parent;
@@ -175 +175 @@
   
   template <typename _Base>
-  class IterableUndirGraphExtender : public IterableGraphExtender<_Base> {
+  class IterableUGraphExtender : public IterableGraphExtender<_Base> {
   public:
 
@@ -185 +185 @@
     ///\bug Should be tested in the concept checker whether it is defined
     ///correctly.
-    typedef True UndirTag;
+    typedef True UTag;
 
     typedef IterableGraphExtender<_Base> Parent;
-    typedef IterableUndirGraphExtender<_Base> Graph;
+    typedef IterableUGraphExtender<_Base> Graph;
     typedef typename Parent::Node Node;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
-
-    class UndirEdgeIt : public Parent::UndirEdge { 
-      const Graph* graph;
-    public:
-
-      UndirEdgeIt() { }
-
-      UndirEdgeIt(Invalid i) : UndirEdge(i) { }
-
-      explicit UndirEdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(*static_cast<UndirEdge*>(this));
-      }
-
-      UndirEdgeIt(const Graph& _graph, const UndirEdge& e) : 
-        UndirEdge(e), graph(&_graph) { }
-
-      UndirEdgeIt& operator++() { 
+    typedef typename Parent::UEdge UEdge;
+
+    class UEdgeIt : public Parent::UEdge { 
+      const Graph* graph;
+    public:
+
+      UEdgeIt() { }
+
+      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) : 
+        UEdge(e), graph(&_graph) { }
+
+      UEdgeIt& operator++() { 
         graph->next(*this);
         return *this; 
@@ -215 +215 @@
     };
 
-    class IncEdgeIt : public Parent::UndirEdge { 
+    class IncEdgeIt : public Parent::UEdge { 
       const Graph* graph;
       bool direction;
-      friend class IterableUndirGraphExtender;
+      friend class IterableUGraphExtender;
     public:
 
       IncEdgeIt() { }
 
-      IncEdgeIt(Invalid i) : UndirEdge(i), direction(false) { }
+      IncEdgeIt(Invalid i) : UEdge(i), direction(false) { }
 
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
@@ -229 +229 @@
       }
 
-      IncEdgeIt(const Graph& _graph, const UndirEdge &ue, const Node &n)
-        : graph(&_graph), UndirEdge(ue) {
+      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+        : graph(&_graph), UEdge(ue) {
         direction = (_graph.source(ue) == n);
       }
@@ -259 +259 @@
     ///
     /// Gives back the opposite on the given undirected edge.
-    Node oppositeNode(const Node& n, const UndirEdge& e) const {
+    Node oppositeNode(const Node& n, const UEdge& e) const {
       if (Parent::source(e) == n) {
         return Parent::target(e);
@@ -271 +271 @@
 
   template <typename _Base>
-  class IterableUndirBipartiteGraphExtender : public _Base {
+  class IterableUBipartiteGraphExtender : public _Base {
   public:
     typedef _Base Parent;
-    typedef IterableUndirBipartiteGraphExtender Graph;
+    typedef IterableUBipartiteGraphExtender Graph;
    
     typedef typename Parent::Node Node;
@@ -280 +280 @@
     typedef typename Parent::LowerNode LowerNode;
     typedef typename Parent::Edge Edge;
-    typedef typename Parent::UndirEdge UndirEdge;
+    typedef typename Parent::UEdge UEdge;
   
     class NodeIt : public Node { 
@@ -305 +305 @@
 
     class UpperNodeIt : public Node { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -327 +327 @@
 
     class LowerNodeIt : public Node { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -349 +349 @@
 
     class EdgeIt : public Edge { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -371 +371 @@
     };
 
-    class UndirEdgeIt : public UndirEdge { 
-      friend class IterableUndirBipartiteGraphExtender;
-      const Graph* graph;
-    public:
-    
-      UndirEdgeIt() { }
-    
-      UndirEdgeIt(Invalid i) : UndirEdge(INVALID) { }
-    
-      explicit UndirEdgeIt(const Graph& _graph) : graph(&_graph) {
-        graph->first(static_cast<UndirEdge&>(*this));
-      }
-
-      UndirEdgeIt(const Graph& _graph, const UndirEdge& edge) 
-        : UndirEdge(edge), graph(&_graph) { }
-    
-      UndirEdgeIt& operator++() { 
+    class UEdgeIt : public UEdge { 
+      friend class IterableUBipartiteGraphExtender;
+      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; 
@@ -394 +394 @@
 
     class OutEdgeIt : public Edge { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -419 +419 @@
 
     class InEdgeIt : public Edge { 
-      friend class IterableUndirBipartiteGraphExtender;
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
     public:
@@ -470 +470 @@
     }
   
-    class IncEdgeIt : public Parent::UndirEdge { 
-      friend class IterableUndirBipartiteGraphExtender;
+    class IncEdgeIt : public Parent::UEdge { 
+      friend class IterableUBipartiteGraphExtender;
       const Graph* graph;
       bool direction;
@@ -478 +478 @@
       IncEdgeIt() { }
     
-      IncEdgeIt(Invalid i) : UndirEdge(i), direction(true) { }
+      IncEdgeIt(Invalid i) : UEdge(i), direction(true) { }
     
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
@@ -484 +484 @@
       }
 
-      IncEdgeIt(const Graph& _graph, const UndirEdge &ue, const Node &n)
-        : graph(&_graph), UndirEdge(ue) {
+      IncEdgeIt(const Graph& _graph, const UEdge &ue, const Node &n)
+        : graph(&_graph), UEdge(ue) {
         direction = (graph->source(ue) == n);
       }