Changeset 774:4297098d9677 in lemon-0.x for src/hugo/full_graph.h

Timestamp:

08/30/04 14:01:47 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

Merge back the whole branches/hugo++ to trunk.

File:

• src/hugo/full_graph.h (modified) (7 diffs)

src/hugo/full_graph.h

@@ -64 +64 @@
     Node head(Edge e) const { return e.n/NodeNum; }
 
-    Node aNode(OutEdgeIt e) const { return tail(e); }
-    Node aNode(InEdgeIt e) const { return head(e); }
-
-    Node bNode(OutEdgeIt e) const { return head(e); }
-    Node bNode(InEdgeIt e) const { return tail(e); }
-
     NodeIt& first(NodeIt& v) const {
       v=NodeIt(*this); return v; }
@@ -79 +73 @@
       e=InEdgeIt(*this,v); return e; }
 
-    static bool valid(Edge e) { return e.n!=-1; }
-    static bool valid(Node n) { return n.n!=-1; }
-    
-    template <typename It> It getNext(It it) const
-    { It tmp(it); return next(tmp); }
-
-    NodeIt& next(NodeIt& it) const { 
-      it.n=(it.n+2)%(NodeNum+1)-1; 
-      return it; 
-    }
-    OutEdgeIt& next(OutEdgeIt& it) const
-    { it.n+=NodeNum; if(it.n>=EdgeNum) it.n=-1; return it; }
-    InEdgeIt& next(InEdgeIt& it) const
-    { if(!((++it.n)%NodeNum)) it.n=-1; return it; }
-    static EdgeIt& next(EdgeIt& it) { --it.n; return it; }
-
     static int id(Node v) { return v.n; }
     static int id(Edge e) { return e.n; }
 
+    /// Finds an edge between two nodes.
+    
+    /// Finds an edge from node \c u to node \c v.
+    ///
+    /// If \c prev is \ref INVALID (this is the default value), then
+    /// It finds the first edge from \c u to \c v. Otherwise it looks for
+    /// the next edge from \c u to \c v after \c prev.
+    /// \return The found edge or INVALID if there is no such an edge.
+    Edge findEdge(Node u,Node v, Edge prev = INVALID) 
+    {
+      return prev.n==-1?Edge(*this,u.n,v.n):INVALID;
+    }
+    
+      
     class Node {
       friend class FullGraph;
@@ -120 +112 @@
     
     class NodeIt : public Node {
+      const FullGraph *G;
       friend class FullGraph;
     public:
       NodeIt() : Node() { }
+      NodeIt(const FullGraph& _G,Node n) : Node(n), G(&_G) { }
       NodeIt(Invalid i) : Node(i) { }
-      NodeIt(const FullGraph& G) : Node(G.NodeNum?0:-1) { }
+      NodeIt(const FullGraph& _G) : Node(_G.NodeNum?0:-1), G(&_G) { }
       ///\todo Undocumented conversion Node -\> NodeIt.
-      NodeIt(const FullGraph& G, const Node &n) : Node(n) { }
+      NodeIt& operator++() { n=(n+2)%(G->NodeNum+1)-1;return *this; }
     };
 
@@ -139 +133 @@
       friend int FullGraph::id(Edge e);
 
-      Edge(int nn) {n=nn;}
+      Edge(int nn) : n(nn) {}
+      Edge(const FullGraph &G, int tail, int head) : n(G.NodeNum*head+tail) {}
     public:
       Edge() { }
@@ -155 +150 @@
       friend class FullGraph;
     public:
-      EdgeIt(const FullGraph& G) : Edge(G.EdgeNum-1) { }
+      EdgeIt(const FullGraph& _G) : Edge(_G.EdgeNum-1) { }
+      EdgeIt(const FullGraph&, Edge e) : Edge(e) { }
       EdgeIt (Invalid i) : Edge(i) { }
       EdgeIt() : Edge() { }
+      EdgeIt& operator++() { --n; return *this; }
+
       ///\bug This is a workaround until somebody tells me how to
       ///make class \c SymFullGraph::SymEdgeMap friend of Edge
@@ -164 +162 @@
     
     class OutEdgeIt : public Edge {
+      const FullGraph *G;
       friend class FullGraph;
     public: 
       OutEdgeIt() : Edge() { }
+      OutEdgeIt(const FullGraph& _G, Edge e) : Edge(e), G(&_G) { }
       OutEdgeIt (Invalid i) : Edge(i) { }
 
-      OutEdgeIt(const FullGraph& G,const Node v)
-        : Edge(v.n) {}
+      OutEdgeIt(const FullGraph& _G,const Node v) : Edge(v.n), G(&_G) {}
+      
+      OutEdgeIt& operator++()
+      { n+=G->NodeNum; if(n>=G->EdgeNum) n=-1; return *this; }
+
     };
     
     class InEdgeIt : public Edge {
+      const FullGraph *G;
       friend class FullGraph;
     public: 
       InEdgeIt() : Edge() { }
+      InEdgeIt(const FullGraph& _G, Edge e) : Edge(e), G(&_G) { }
       InEdgeIt (Invalid i) : Edge(i) { }
-      InEdgeIt(const FullGraph& G,Node v) :Edge(v.n*G.NodeNum){}
+      InEdgeIt(const FullGraph& _G,Node v) : Edge(v.n*_G.NodeNum), G(&_G) {}
+      InEdgeIt& operator++()
+      { if(!((++n)%G->NodeNum)) n=-1; return *this; }
     };
 
@@ -280 +287 @@
         return *this;
       }
-      
+
       void update() {}
       void update(T a) {}