home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / parser / chart / edge.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-26  |  3.8 KB  |  188 lines
  1.  
  2. // Copyright 1992, David Perelman-Hall & Jamshid Afshar
  3.  
  4. #include <assert.h>
  5. #include "misc.h"
  6. #include "edge.h"
  7.  
  8.  
  9. Edge combine( const Edge& edge1, const Edge& edge2 )
  10. {
  11.    assert( edge1.canCombineWith( edge2 ));
  12.    const Edge *ap, *ip;
  13.  
  14.    if( edge1.isActive() ){
  15.       ap = &edge1;
  16.       ip = &edge2;
  17.    }
  18.    else{
  19.       ip = &edge1;
  20.       ap = &edge2;
  21.    }
  22.  
  23.    Tree tmp( ap->_tree );
  24.    tmp.add_child( ip->_tree );
  25.  
  26.  
  27.    return Edge( ap->_start, ip->_finish, tmp, ap->_toFind.rest() );
  28. }
  29.  
  30.  
  31. ostream& operator << ( ostream& os, const Edge& edge )
  32. {
  33.    os << "<" << edge.start() << "," << edge.finish() << ","
  34.       << edge.label() << ",";
  35.    os << edge.found() << "." << edge.toFind() << ">";
  36.  
  37.    return os;
  38. }
  39.  
  40.  
  41. // constructor
  42. Edge::Edge( int start, int finish, const Category& label )
  43.    : _start(start), _finish(finish), _tree(label) {}
  44.  
  45.  
  46. // constructor
  47. Edge::Edge( int start, int finish, const Category& label,
  48.                const Category_Sequence& toFind )
  49.    : _start(start), _finish(finish), _tree(label), 
  50.      _toFind(toFind) {}
  51.  
  52. // constructor
  53. Edge::Edge( int start, int finish, const Tree& tree,
  54.             const Category_Sequence& toFind )
  55.    : _start(start), _finish(finish), _tree(tree), 
  56.      _toFind(toFind) {}
  57.  
  58. // copy constructor
  59. Edge::Edge( const Edge& edge )
  60.    : _start(edge._start), _finish(edge._finish), _tree(edge._tree), 
  61.      _toFind(edge._toFind) {}
  62.  
  63.  
  64. // assignment operator
  65. void Edge::operator = ( const Edge& edge )
  66. {
  67.    _start = edge._start;
  68.    _finish = edge._finish;
  69.    _tree = edge._tree;
  70.    _toFind = edge._toFind; 
  71. }
  72.  
  73. // boolean equal
  74. bool Edge::operator == ( const Edge& edge ) const
  75. {
  76.    return(  _start == edge._start  &&
  77.             _finish == edge._finish  &&
  78.             _tree == edge._tree  &&
  79.             _toFind == edge._toFind );
  80. }   
  81.  
  82. bool Edge::canCombineWith( const Edge& edge ) const
  83. {
  84.    const Edge *ap, *ip;
  85.  
  86.    if( isActive() ){
  87.       ip = &edge;
  88.       ap = this;
  89.    }
  90.    else{
  91.       ip = this;
  92.       ap = &edge;
  93.    }
  94.  
  95.    if (!ap->isActive() || ip->isActive()) {
  96.       return FALSE;
  97.    }      
  98.    else {
  99.       Category cat = ap->_toFind.first();
  100.       return (ip->_start == ap->_finish ) && ( ip->_tree.cat() == cat );
  101.    }
  102. }
  103.       
  104. // constructor
  105. Edge_List::Edge_List()
  106.    : _firstNode(NULL){}
  107.  
  108.    
  109. // copy constructor
  110. Edge_List::Edge_List( const Edge_List& edge_List )
  111.    : _firstNode(NULL)
  112. {
  113.    *this = edge_List;
  114. }
  115.  
  116.  
  117. Edge_List::~Edge_List()
  118. {
  119.    clear();
  120. }
  121.  
  122. void Edge_List::push( const Edge& edge )
  123. {
  124.    edgeNode *newnode = new edgeNode( edge, _firstNode );
  125.    _firstNode = newnode;
  126. }
  127.  
  128.  
  129. Edge Edge_List::pop()
  130. {
  131.    assert( _firstNode != NULL );
  132.  
  133.    Edge e = _firstNode->_edge;  // call to copy constructor
  134.    edgeNode *eptr = _firstNode;
  135.    _firstNode = _firstNode->_next;
  136.    delete eptr;
  137.    return e;
  138. }
  139.  
  140. // assignment operator 
  141. void Edge_List::operator = ( const Edge_List& edge_List )
  142. {
  143.    // delete allocated nodes
  144.    clear();
  145.  
  146.    const edgeNode *enp = edge_List._firstNode;
  147.    edgeNode **thisenpp = &_firstNode;
  148.    while ( enp != NULL ){
  149.       *thisenpp = new edgeNode(enp->_edge, NULL);
  150.       thisenpp = &((*thisenpp)->_next);
  151.       enp = enp->_next;
  152.    }
  153. }
  154.  
  155. void Edge_List::clear()
  156. {
  157.    while ( !isEmpty() )
  158.       pop();
  159. }
  160.  
  161.  
  162. bool Edge_List::isMember( const Edge& edge ) const
  163. {
  164.    const edgeNode *enp = _firstNode;
  165.    while ( enp != NULL ){
  166.       if( enp->_edge == edge )
  167.          return TRUE;
  168.       enp = enp->_next;
  169.    }
  170.    return FALSE;
  171. }
  172.  
  173. bool Edge_List::isEmpty() const
  174. {
  175.    return _firstNode == NULL;
  176. }
  177.  
  178. ostream& operator << ( ostream& os, const Edge_List& list )
  179. {
  180.    const edgeNode *enp = list._firstNode;
  181.    while ( enp != NULL ){
  182.       cout << enp->_edge << "\n";
  183.       enp = enp->_next;
  184.    }
  185.    return os;
  186. }
  187.  
  188.