Changeset 986:e997802b855c in lemon-0.x for src/work/sage_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/sage_graph.h (modified) (15 diffs)

src/work/sage_graph.h

@@ -97 +97 @@
     struct edge_item {
       int id;
-      node_item* _tail;
-      node_item* _head;
+      node_item* _source;
+      node_item* _target;
       edge_item* _next_out;
       edge_item* _prev_out;
@@ -122 +122 @@
     }
 
-    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->_source=_source;
+      e->_target=_target;
       
-      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->_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;
 
@@ -157 +157 @@
     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;
@@ -169 +169 @@
     }
 
-    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->_source)->_first_out_edge=e->_next_out;
       
-      e->_tail=_tail;
+      e->_source=_source;
       
-      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->_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->_target)->_first_in_edge=e->_next_in;
       
-      e->_head=_head;
+      e->_target=_target;
       
-      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;
     }
@@ -222 +222 @@
     //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(); }
@@ -252 +252 @@
     SymEdgeIt& 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(); }
@@ -330 +330 @@
     }
 
-    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); 
     }
 
@@ -349 +349 @@
 //     friend std::ostream& operator<<(std::ostream& os, const Edge& i) { 
 //       if (i.valid()) 
-//      os << "(" << i.edge->_tail->id << "--" << i.edge->id << "->" << i.edge->_head->id << ")"; 
+//      os << "(" << i.edge->_source->id << "--" << i.edge->id << "->" << i.edge->_target->id << ")"; 
 //       else 
 //      os << "invalid";
@@ -420 +420 @@
       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);
@@ -441 +441 @@
     public:
       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; }
@@ -457 +457 @@
       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); }
     };
     
@@ -470 +470 @@
       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); }
     };
 
@@ -496 +496 @@
       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; }
@@ -506 +506 @@
     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); }
     };
   };
@@ -524 +524 @@
   std::ostream& operator<<(std::ostream& os, const SageGraph::Edge& i) { 
     if (i.valid()) 
-      os << "(" << i.tailNode() << "--" << i.edge->id << "->" 
-         << i.headNode() << ")"; 
+      os << "(" << i.sourceNode() << "--" << i.edge->id << "->" 
+         << i.targetNode() << ")"; 
     else 
       os << "invalid";