Changeset 986:e997802b855c in lemon-0.x for src/work/marci/experiment/list_graph.h

Timestamp:

11/13/04 13:53:28 (19 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

Naming changes:

• head -> target
• tail -> source

File:

• src/work/marci/experiment/list_graph.h (modified) (14 diffs)

src/work/marci/experiment/list_graph.h

@@ -123 +123 @@
       //ListGraph* G;
       int id;
-      node_item* _tail;
-      node_item* _head;
+      node_item* _source;
+      node_item* _target;
       edge_item* _next_out;
       edge_item* _prev_out;
@@ -150 +150 @@
     }
 
-    edge_item* _add_edge(node_item* _tail, node_item* _head) {
+    edge_item* _add_edge(node_item* _source, node_item* _target) {
       edge_item* e=new edge_item;
       e->id=edge_id++;
-      e->_tail=_tail;
-      e->_head=_head;
-      
-      e->_prev_out=_tail->_last_out_edge;
-      if (_tail->_last_out_edge) (_tail->_last_out_edge)->_next_out=e;
-      _tail->_last_out_edge=e;
-      if (!_tail->_first_out_edge) _tail->_first_out_edge=e; 
+      e->_source=_source;
+      e->_target=_target;
+      
+      e->_prev_out=_source->_last_out_edge;
+      if (_source->_last_out_edge) (_source->_last_out_edge)->_next_out=e;
+      _source->_last_out_edge=e;
+      if (!_source->_first_out_edge) _source->_first_out_edge=e; 
       e->_next_out=0;
  
-      e->_prev_in=_head->_last_in_edge;
-      if (_head->_last_in_edge) (_head->_last_in_edge)->_next_in=e;
-      _head->_last_in_edge=e;
-      if (!_head->_first_in_edge) { _head->_first_in_edge=e; } 
+      e->_prev_in=_target->_last_in_edge;
+      if (_target->_last_in_edge) (_target->_last_in_edge)->_next_in=e;
+      _target->_last_in_edge=e;
+      if (!_target->_first_in_edge) { _target->_first_in_edge=e; } 
       e->_next_in=0;
 
@@ -185 +185 @@
     void _delete_edge(edge_item* e) {
       if (e->_next_out) (e->_next_out)->_prev_out=e->_prev_out; else 
-        (e->_tail)->_last_out_edge=e->_prev_out;
+        (e->_source)->_last_out_edge=e->_prev_out;
       if (e->_prev_out) (e->_prev_out)->_next_out=e->_next_out; else 
-        (e->_tail)->_first_out_edge=e->_next_out;
+        (e->_source)->_first_out_edge=e->_next_out;
       if (e->_next_in) (e->_next_in)->_prev_in=e->_prev_in; else 
-        (e->_head)->_last_in_edge=e->_prev_in;
+        (e->_target)->_last_in_edge=e->_prev_in;
       if (e->_prev_in) (e->_prev_in)->_next_in=e->_next_in; else 
-        (e->_head)->_first_in_edge=e->_next_in;
+        (e->_target)->_first_in_edge=e->_next_in;
 
       delete e;
@@ -197 +197 @@
     }
 
-    void _set_tail(edge_item* e, node_item* _tail) {
+    void _set_source(edge_item* e, node_item* _source) {
       if (e->_next_out) (e->_next_out)->_prev_out=e->_prev_out; else 
-        (e->_tail)->_last_out_edge=e->_prev_out;
+        (e->_source)->_last_out_edge=e->_prev_out;
       if (e->_prev_out) (e->_prev_out)->_next_out=e->_next_out; else 
-        (e->_tail)->_first_out_edge=e->_next_out;
-      
-      e->_tail=_tail;
-      
-      e->_prev_out=_tail->_last_out_edge;
-      if (_tail->_last_out_edge) (_tail->_last_out_edge)->_next_out=e;
-      _tail->_last_out_edge=e;
-      if (!_tail->_first_out_edge) _tail->_first_out_edge=e; 
+        (e->_source)->_first_out_edge=e->_next_out;
+      
+      e->_source=_source;
+      
+      e->_prev_out=_source->_last_out_edge;
+      if (_source->_last_out_edge) (_source->_last_out_edge)->_next_out=e;
+      _source->_last_out_edge=e;
+      if (!_source->_first_out_edge) _source->_first_out_edge=e; 
       e->_next_out=0;
     }
 
-    void _set_head(edge_item* e, node_item* _head) {
+    void _set_target(edge_item* e, node_item* _target) {
       if (e->_next_in) (e->_next_in)->_prev_in=e->_prev_in; else 
-        (e->_head)->_last_in_edge=e->_prev_in;
+        (e->_target)->_last_in_edge=e->_prev_in;
       if (e->_prev_in) (e->_prev_in)->_next_in=e->_next_in; else 
-        (e->_head)->_first_in_edge=e->_next_in;
-      
-      e->_head=_head;
-      
-      e->_prev_in=_head->_last_in_edge;
-      if (_head->_last_in_edge) (_head->_last_in_edge)->_next_in=e;
-      _head->_last_in_edge=e;
-      if (!_head->_first_in_edge) { _head->_first_in_edge=e; } 
+        (e->_target)->_first_in_edge=e->_next_in;
+      
+      e->_target=_target;
+      
+      e->_prev_in=_target->_last_in_edge;
+      if (_target->_last_in_edge) (_target->_last_in_edge)->_next_in=e;
+      _target->_last_in_edge=e;
+      if (!_target->_first_in_edge) { _target->_first_in_edge=e; } 
       e->_next_in=0;
     }
@@ -248 +248 @@
     //InEdgeIt firstInEdge(const Node v) const { return InEdgeIt(v); }
     //SymEdgeIt firstSymEdge(const Node v) const { return SymEdgeIt(v); }
-    Node tail(Edge e) const { return e.tailNode(); }
-    Node head(Edge e) const { return e.headNode(); }
+    Node source(Edge e) const { return e.sourceNode(); }
+    Node target(Edge e) const { return e.targetNode(); }
 
     Node aNode(const OutEdgeIt& e) const { return e.aNode(); }
@@ -278 +278 @@
     SymEdgeIt& /*getF*/first(SymEdgeIt& e, Node v) const { 
       e=SymEdgeIt(*this, v); return e; }
-    //void getTail(Node& n, const Edge& e) const { n=tail(e); }
-    //void getHead(Node& n, const Edge& e) const { n=head(e); }
+    //void getSource(Node& n, const Edge& e) const { n=source(e); }
+    //void getTarget(Node& n, const Edge& e) const { n=target(e); }
 
     //void getANode(Node& n, const OutEdgeIt& e) const { n=e.aNode(); }
@@ -346 +346 @@
     }
 
-    void setTail(Edge e, Node tail) {
-      _set_tail(e.edge, tail.node); 
-    }
-
-    void setHead(Edge e, Node head) {
-      _set_head(e.edge, head.node); 
+    void setSource(Edge e, Node source) {
+      _set_source(e.edge, source.node); 
+    }
+
+    void setTarget(Edge e, Node target) {
+      _set_target(e.edge, target.node); 
     }
 
@@ -360 +360 @@
     }
     friend std::ostream& operator<<(std::ostream& os, const Edge& i) { 
-      os << "(" << i.edge->_tail->id << "--" << i.edge->id << "->" << i.edge->_head->id << ")"; 
+      os << "(" << i.edge->_source->id << "--" << i.edge->id << "->" << i.edge->_target->id << ")"; 
       return os; 
     }
@@ -427 +427 @@
       friend bool operator!=(Edge u, Edge v) { return v.edge!=u.edge; } 
     protected:
-      Node tailNode() const { return Node(edge->_tail); }
-      Node headNode() const { return Node(edge->_head); }
+      Node sourceNode() const { return Node(edge->_source); }
+      Node targetNode() const { return Node(edge->_target); }
     public:
       friend std::ostream& operator<<(std::ostream& os, const Edge& i);
@@ -448 +448 @@
       EdgeIt(edge_item* _e) : Edge(_e) { }
       EdgeIt& operator++() { 
-        node_item* v=edge->_tail;
+        node_item* v=edge->_source;
         edge=edge->_next_out; 
         while (v && !edge) { v=v->_next_node; if (v) edge=v->_first_out_edge; }
@@ -468 +468 @@
       OutEdgeIt& operator++() { edge=edge->_next_out; return *this; }
     protected:
-      Node aNode() const { return Node(edge->_tail); }
-      Node bNode() const { return Node(edge->_head); }
+      Node aNode() const { return Node(edge->_source); }
+      Node bNode() const { return Node(edge->_target); }
     };
     
@@ -485 +485 @@
       InEdgeIt& operator++() { edge=edge->_next_in; return *this; }
     protected:
-      Node aNode() const { return Node(edge->_head); }
-      Node bNode() const { return Node(edge->_tail); }
+      Node aNode() const { return Node(edge->_target); }
+      Node bNode() const { return Node(edge->_source); }
     };
 
@@ -511 +511 @@
       SymEdgeIt& operator++() { 
         if (out_or_in) { 
-          node_item* v=edge->_tail;
+          node_item* v=edge->_source;
           edge=edge->_next_out; 
           if (!edge) { out_or_in=0; edge=v->_first_in_edge; }
@@ -521 +521 @@
     protected:
       Node aNode() const { 
-        return (out_or_in) ? Node(edge->_tail) : Node(edge->_head); }
+        return (out_or_in) ? Node(edge->_source) : Node(edge->_target); }
       Node bNode() const { 
-        return (out_or_in) ? Node(edge->_head) : Node(edge->_tail); }
+        return (out_or_in) ? Node(edge->_target) : Node(edge->_source); }
     };