home *** CD-ROM | disk | FTP | other *** search
/ Informática Multimedia: Special Games / INFESPGAMES.mdf / os2 / ribble / support / cslist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-16  |  3.7 KB  |  233 lines
  1. #include <CSList.h>
  2.  
  3. template <class T>
  4. CSListNode<T>::CSListNode(const T& _item) 
  5. : item(_item) 
  6. { 
  7. }
  8.  
  9. template <class T>
  10. CSList<T>::CSList(const CSList<T>& from)
  11. {
  12.   tail = 0;
  13.  
  14.   CSListIterator<T> it(from);
  15.  
  16.   while (it)
  17.     addTail(it++);
  18. }
  19.  
  20. template <class T>
  21. CSList<T>::CSList()                                             
  22. { 
  23.   tail = 0;  
  24. }
  25.  
  26. template <class T>
  27. CSList<T>::~CSList()                                    
  28. { 
  29.   destroy();  
  30. }
  31.  
  32. template <class T>
  33. CSList<T>& 
  34. CSList<T>::operator+=(const T item)
  35. {
  36.   addTail(item);
  37.   return *this;
  38. }
  39.  
  40. template <class T>
  41. T& 
  42. CSList<T>::getHead(void) const                       
  43. { 
  44.   return tail->next->item;  
  45. }
  46.  
  47. template <class T>
  48. T& 
  49. CSList<T>::getTail(void) const                       
  50. { 
  51.   return tail->item;  
  52. }
  53.  
  54. template <class T>
  55. int 
  56. CSList<T>::isEmpty(void) const                      
  57. { 
  58.   return (tail == 0);  
  59. }
  60.  
  61. template <class T>
  62. CSList<T>::operator int() const                         
  63. { 
  64.   return !isEmpty();  
  65. }
  66.  
  67. template <class T>
  68. CSList<T>& 
  69. CSList<T>::operator=(const CSList<T>& from)
  70. {
  71.   if (this != &from)
  72.     {
  73.       destroy();
  74.       tail = 0;
  75.  
  76.       CSListIterator<T> it(from);
  77.  
  78.       while (it)
  79.         addTail(it++);
  80.     }
  81.   return *this;
  82. }
  83.  
  84. template <class T>
  85. void 
  86. CSList<T>::destroy(void)
  87. {
  88.   CSListNode<T>* walk = tail;
  89.  
  90.   if (walk)
  91.     {
  92.       do
  93.         {
  94.           CSListNode<T>* n = walk->next;
  95.           delete walk;
  96.           walk = n;
  97.         } while (walk != tail);
  98.     }
  99.   tail = 0;
  100. }
  101.  
  102. template <class T>
  103. void 
  104. CSList<T>::addTail(const T item)
  105. {
  106.   CSListNode<T>* newNode = new CSListNode<T>(item);
  107.   if (tail)
  108.     {
  109.       newNode->next = tail->next;
  110.       tail = tail->next = newNode;
  111.     }
  112.   else
  113.     tail = newNode->next = newNode;
  114. }
  115.  
  116. template <class T>
  117. void 
  118. CSList<T>::addHead(const T item)
  119. {
  120.   CSListNode<T>* newNode = new CSListNode<T>(item);
  121.   if (tail)
  122.     {
  123.       newNode->next = tail->next;
  124.       tail->next = newNode;
  125.     }
  126.   else
  127.     tail = newNode->next = newNode;
  128. }
  129.  
  130. template <class T>
  131. T 
  132. CSList<T>::remHead(void)
  133. {
  134.   CSListNode<T>* n = tail->next;
  135.   if (n == tail)
  136.     tail = 0;
  137.   else
  138.     tail->next = n->next;
  139.  
  140.   T result = n->item;
  141.   delete n;
  142.   return result;
  143. }
  144.  
  145. template <class T>
  146. int 
  147. CSList<T>::count(void) const
  148. {
  149.   int c = 0;
  150.   if (tail)
  151.     {
  152.       CSListNode<T>* n = tail->next;
  153.       do
  154.         {
  155.           c++;
  156.           n = n->next;
  157.         }
  158.       while (n != tail->next);
  159.     }
  160.   return c;
  161. }
  162.  
  163. template <class T>
  164. CSListIterator<T>::CSListIterator(const CSList<T>& _list) 
  165. : list(&_list)         
  166. { 
  167.   cur = list->tail ? list->tail->next : 0; 
  168. }
  169.  
  170. template <class T>
  171. CSListIterator<T>::CSListIterator(const CSListIterator<T>& _it) 
  172. : list(_it.list) 
  173. { 
  174.   cur = _it.cur; 
  175. }
  176.  
  177. template <class T>
  178. T& 
  179. CSListIterator<T>::current(void) const                                
  180. { 
  181.   return cur->item;  
  182. }
  183.  
  184. template <class T>
  185. void 
  186. CSListIterator<T>::rewind(void)                                     
  187. { 
  188.   cur = list->tail ? list->tail->next : 0;  
  189. }
  190.  
  191. template <class T>
  192. CSListIterator<T>::operator int()                                        
  193. { 
  194.   return cur != 0;  
  195. }
  196.  
  197. template <class T>
  198. T& 
  199. CSListIterator<T>::operator++(int)
  200. {
  201.   CSListNode<T>* n = cur;
  202.   if (cur == list->tail)
  203.     cur = 0;
  204.   else
  205.     cur = cur->next;
  206.   return n->item;
  207. }
  208.  
  209. template <class T>
  210. T& 
  211. CSListIterator<T>::operator++()
  212. {
  213.   if (cur == list->tail)
  214.     cur = 0;
  215.   else
  216.     cur = cur->next;
  217.   return cur->item;
  218. }
  219.  
  220. template <class T>
  221. CSListIterator<T>& 
  222. CSListIterator<T>::operator=(const CSListIterator<T>& _it)
  223. {
  224.   if (this != &_it)
  225.     {
  226.       list = _it.list;
  227.       cur = _it.cur;
  228.     }
  229.   return *this;
  230. }
  231.  
  232.  
  233.