home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / parser / chart / category.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-26  |  3.3 KB  |  157 lines
  1.  
  2. // Copyright 1992, David Perelman-Hall & Jamshid Afshar
  3.  
  4. #include <assert.h>
  5. #include "category.h"
  6.  
  7.  
  8. ostream& operator << ( ostream& os, const Category& cat )
  9. {
  10.    os << cat._s;
  11.    return os;
  12. }
  13.  
  14. //destructor
  15. Category::~Category()
  16. {
  17.    if (alive == DEAD)
  18.       abort();
  19.    if (alive != ALIVE)
  20.       abort();
  21.    alive = DEAD;
  22. }
  23.  
  24.  
  25. Category_Sequence::Category_Sequence()
  26.    : _first_node(NULL) { alive = ALIVE; }
  27.  
  28. Category_Sequence::Category_Sequence( const Category_Sequence& seq)
  29.    : _first_node(NULL)
  30. {
  31.    alive = ALIVE;
  32.    *this = seq;
  33. }
  34.  
  35. Category_Sequence::Category_Sequence( const Category& category )
  36.    : _first_node(NULL) 
  37. { 
  38.    alive = ALIVE; 
  39.    *this += category;
  40. }
  41.  
  42. Category_Sequence::~Category_Sequence()
  43. {
  44.    assert(alive==ALIVE);
  45.    alive = DEAD;
  46.    clear();
  47. }
  48.  
  49. Category Category_Sequence::pop()
  50. {
  51.    assert(!isEmpty());
  52.    Category cat = _first_node->_category;
  53.    CategoryNode *temp = _first_node;
  54.    _first_node = _first_node->_nextp;
  55.    delete temp;
  56.    return cat;
  57. }
  58.  
  59. //operator =
  60. void Category_Sequence::operator = ( const Category_Sequence& seq)
  61. {
  62.    clear();
  63.  
  64.    const CategoryNode *catnp = seq._first_node;
  65.    CategoryNode **thiscatnpp = &_first_node;
  66.    while ( catnp != NULL ){
  67.       *thiscatnpp = new CategoryNode(catnp->_category, NULL);
  68.       thiscatnpp = &((*thiscatnpp)->_nextp);
  69.       catnp = catnp->_nextp;
  70.    }
  71. }
  72.  
  73. //operator +=
  74. Category_Sequence& Category_Sequence::operator += ( const Category& category)
  75. {
  76.    assert(strcmp(category, "") != 0);
  77.    CategoryNode **thiscatnpp = &_first_node;
  78.    while( *thiscatnpp != 0 )
  79.       thiscatnpp = &((*thiscatnpp)->_nextp);
  80.    *thiscatnpp = new CategoryNode(category, NULL);
  81.    return *this;
  82. }
  83.  
  84. //operator +=
  85. Category_Sequence& Category_Sequence::operator += ( const Category_Sequence& seq)
  86. {
  87.    const CategoryNode *catnp = seq._first_node;
  88.    while ( catnp != NULL ){
  89.       *this += catnp->_category;
  90.       catnp = catnp->_nextp;
  91.    }
  92.    return *this;
  93. }
  94.  
  95. void Category_Sequence::clear()
  96. {
  97.    while ( !isEmpty() )
  98.       pop();
  99. }
  100.  
  101. Category_Sequence Category_Sequence::rest() const
  102. {
  103.    Category_Sequence seq = *this;
  104.    seq.pop();
  105.    return seq;
  106. }
  107.  
  108. int Category_Sequence::length() const
  109. {
  110.    int n = 0;
  111.    const CategoryNode *catnp = _first_node;
  112.    while ( catnp != NULL ){
  113.       n += 1;
  114.       catnp = catnp->_nextp;
  115.    }
  116.    return n;
  117. }
  118.  
  119. bool Category_Sequence::operator == ( const Category_Sequence& seq) const
  120. {
  121.    CategoryNode *s1 = _first_node;
  122.    CategoryNode *s2 = seq._first_node;
  123.    while ( s1 != NULL && s2 != NULL ) {
  124.       if ( s1->_category != s2->_category )
  125.          return FALSE;
  126.       s1 = s1->_nextp;
  127.       s2 = s2->_nextp;
  128.       }
  129.    return s1==NULL && s2==NULL;
  130. }
  131.  
  132. ostream& operator << ( ostream& os, const Category_Sequence& seq )
  133. {
  134.    const CategoryNode *catnp = seq._first_node;
  135.    bool is_first = TRUE;
  136.    while ( catnp != NULL ){
  137.       if (!is_first)
  138.          os << " ";
  139.       os << catnp->_category;
  140.       catnp = catnp->_nextp;
  141.       is_first = FALSE;
  142.    }
  143.    return os;
  144. }
  145.  
  146. istream& operator >> ( istream& is, Category_Sequence& seq )
  147. {
  148.    seq.clear();
  149.    char cat_str[MAX_STRING_LEN];
  150.    while (is.good()) {
  151.       is >> cat_str;
  152.       if (is.fail()) break;
  153.       seq += Category(cat_str);
  154.    }
  155.    return is;
  156. }
  157.