Changeset 2231:06faf3f06d67 in lemon-0.x for lemon/bits/graph_extender.h

Timestamp:

10/03/06 13:46:39 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Some rearrangement of concepts and extenders
BpUGraph concepts and concept check test

File:

• lemon/bits/graph_extender.h (modified) (7 diffs)

lemon/bits/graph_extender.h

@@ -731 +731 @@
   class BpUGraphExtender : public Base {
   public:
+
     typedef Base Parent;
     typedef BpUGraphExtender Graph;
 
     typedef typename Parent::Node Node;
+    typedef typename Parent::ANode ANode;
+    typedef typename Parent::BNode BNode;
+    typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
 
 
-    using Parent::first;
-    using Parent::next;
-
-    using Parent::id;
-
-    class ANode : public Node {
-      friend class BpUGraphExtender;
-    public:
-      ANode() {}
-      ANode(const Node& node) : Node(node) {
-        LEMON_ASSERT(Parent::aNode(node) || node == INVALID, 
-                     typename Parent::NodeSetError());
-      }
-      ANode(Invalid) : Node(INVALID) {}
-    };
-
-    void first(ANode& node) const {
-      Parent::firstANode(static_cast<Node&>(node));
-    }
-    void next(ANode& node) const {
-      Parent::nextANode(static_cast<Node&>(node));
-    }
-
-    int id(const ANode& node) const {
-      return Parent::aNodeId(node);
-    }
-
-    class BNode : public Node {
-      friend class BpUGraphExtender;
-    public:
-      BNode() {}
-      BNode(const Node& node) : Node(node) {
-        LEMON_ASSERT(Parent::bNode(node) || node == INVALID,
-                     typename Parent::NodeSetError());
-      }
-      BNode(Invalid) : Node(INVALID) {}
-    };
-
-    void first(BNode& node) const {
-      Parent::firstBNode(static_cast<Node&>(node));
-    }
-    void next(BNode& node) const {
-      Parent::nextBNode(static_cast<Node&>(node));
-    }
-  
-    int id(const BNode& node) const {
-      return Parent::aNodeId(node);
-    }
-
-    Node source(const UEdge& edge) const {
-      return aNode(edge);
-    }
-    Node target(const UEdge& edge) const {
-      return bNode(edge);
-    }
-
-    void firstInc(UEdge& edge, bool& direction, const Node& node) const {
-      if (Parent::aNode(node)) {
-        Parent::firstFromANode(edge, node);
-        direction = true;
-      } else {
-        Parent::firstFromBNode(edge, node);
-        direction = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-    void nextInc(UEdge& edge, bool& direction) const {
-      if (direction) {
-        Parent::nextFromANode(edge);
-      } else {
-        Parent::nextFromBNode(edge);
-        if (edge == INVALID) direction = true;
-      }
-    }
-
-    class Edge : public UEdge {
-      friend class BpUGraphExtender;
-    protected:
-      bool forward;
-
-      Edge(const UEdge& edge, bool _forward)
-        : UEdge(edge), forward(_forward) {}
-
-    public:
-      Edge() {}
-      Edge (Invalid) : UEdge(INVALID), forward(true) {}
-      bool operator==(const Edge& i) const {
-        return UEdge::operator==(i) && forward == i.forward;
-      }
-      bool operator!=(const Edge& i) const {
-        return UEdge::operator!=(i) || forward != i.forward;
-      }
-      bool operator<(const Edge& i) const {
-        return UEdge::operator<(i) || 
-          (!(i.forward<forward) && UEdge(*this)<UEdge(i));
-      }
-    };
-
-    void first(Edge& edge) const {
-      Parent::first(static_cast<UEdge&>(edge));
-      edge.forward = true;
-    }
-
-    void next(Edge& edge) const {
-      if (!edge.forward) {
-        Parent::next(static_cast<UEdge&>(edge));
-      }
-      edge.forward = !edge.forward;
-    }
-
-    void firstOut(Edge& edge, const Node& node) const {
-      if (Parent::aNode(node)) {
-        Parent::firstFromANode(edge, node);
-        edge.forward = true;
-      } else {
-        Parent::firstFromBNode(edge, node);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-    void nextOut(Edge& edge) const {
-      if (edge.forward) {
-        Parent::nextFromANode(edge);
-      } else {
-        Parent::nextFromBNode(edge);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-
-    void firstIn(Edge& edge, const Node& node) const {
-      if (Parent::bNode(node)) {
-        Parent::firstFromBNode(edge, node);
-        edge.forward = true;    
-      } else {
-        Parent::firstFromANode(edge, node);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-    void nextIn(Edge& edge) const {
-      if (edge.forward) {
-        Parent::nextFromBNode(edge);
-      } else {
-        Parent::nextFromANode(edge);
-        edge.forward = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-
-    Node source(const Edge& edge) const {
-      return edge.forward ? Parent::aNode(edge) : Parent::bNode(edge);
-    }
-    Node target(const Edge& edge) const {
-      return edge.forward ? Parent::bNode(edge) : Parent::aNode(edge);
-    }
-
-    int id(const Edge& edge) const {
-      return (Parent::id(static_cast<const UEdge&>(edge)) << 1) + 
-        (edge.forward ? 0 : 1);
-    }
-    Edge edgeFromId(int id) const {
-      return Edge(Parent::fromUEdgeId(id >> 1), (id & 1) == 0);
-    }
-    int maxEdgeId() const {
-      return (Parent::maxUEdgeId(UEdge()) << 1) + 1;
-    }
-
-    bool direction(const Edge& edge) const {
-      return edge.forward;
-    }
-
-    Edge direct(const UEdge& edge, bool direction) const {
-      return Edge(edge, direction);
-    }
-
-    int edgeNum() const {
-      return 2 * Parent::uEdgeNum();
-    }
-
-    int uEdgeNum() const {
-      return Parent::uEdgeNum();
-    }
-
-    Node oppositeNode(const UEdge& edge, const Node& node) const {
-      return source(edge) == node ? 
-        target(edge) : source(edge);
-    }
-
+    Node oppositeNode(const Node& node, const UEdge& edge) const {
+      return Parent::aNode(edge) == node ? 
+        Parent::bNode(edge) : Parent::aNode(edge);
+    }
+
+    using Parent::direct;
     Edge direct(const UEdge& edge, const Node& node) const {
-      return Edge(edge, node == Parent::source(edge));
+      return Parent::direct(edge, node == Parent::source(edge));
     }
 
     Edge oppositeEdge(const Edge& edge) const {
-      return Parent::direct(edge, !Parent::direction(edge));
-    }
-
-
+      return direct(edge, !Parent::direction(edge));
+    }
+    
     int maxId(Node) const {
       return Parent::maxNodeId();
@@ -941 +766 @@
     }
     int maxId(Edge) const {
-      return maxEdgeId();
+      return Parent::maxEdgeId();
     }
     int maxId(UEdge) const {
@@ -952 +777 @@
     }
     ANode fromId(int id, ANode) const {
-      return Parent::fromANodeId(id);
+      return Parent::nodeFromANodeId(id);
     }
     BNode fromId(int id, BNode) const {
-      return Parent::fromBNodeId(id);
+      return Parent::nodeFromBNodeId(id);
     }
     Edge fromId(int id, Edge) const {
@@ -1305 +1130 @@
       NodeMap& operator=(const CMap& cmap) {
         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
-        const typename Parent::Notifier* notifier = Parent::getNotifier();
-        Edge it;
-        for (graph.first(it); it != INVALID; graph.next(it)) {
-          Parent::set(it, cmap[it]);
-        }
-        return *this;
+        aNodeMap = cmap;
+        bNodeMap = cmap;
+        return *this;
       }
 
@@ -1460 +1282 @@
     
       std::vector<Edge> edges;
-      edges.push_back(direct(uedge, true));
-      edges.push_back(direct(uedge, false));
+      edges.push_back(Parent::direct(uedge, true));
+      edges.push_back(Parent::direct(uedge, false));
       getNotifier(Edge()).add(edges);
     
@@ -1500 +1322 @@
     void erase(const UEdge& uedge) {
       std::vector<Edge> edges;
-      edges.push_back(direct(uedge, true));
-      edges.push_back(direct(uedge, false));
+      edges.push_back(Parent::direct(uedge, true));
+      edges.push_back(Parent::direct(uedge, false));
       getNotifier(Edge()).erase(edges);
       getNotifier(UEdge()).erase(uedge);
@@ -1527 +1349 @@
       UEdge uedge = Parent::findUEdge(u, v, prev);
       if (uedge != INVALID) {
-        return direct(uedge, Parent::aNode(u));
+        return Parent::direct(uedge, Parent::aNode(u));
       } else {
         return INVALID;