home *** CD-ROM | disk | FTP | other *** search
/ Piper's Pit BBS/FTP: ibm 0040 - 0049 / ibm0040-0049 / ibm0040.tar / ibm0040 / BCPPOWL1.ZIP / CLSRC.ZIP / LIST.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-28  |  7.8 KB  |  355 lines
  1. // Borland C++ - (C) Copyright 1991 by Borland International
  2.  
  3. // Contents ----------------------------------------------------------------
  4. //
  5. //      List::add
  6. //      List::destroy
  7. //      List::detach
  8. //      List::initIterator
  9. //    List::hashValue
  10. //
  11. //      ListIterator::operator int
  12. //      ListIterator::operator Object&
  13. //      ListIterator::operator ++
  14. //      ListIterator::restart
  15. //
  16. // Description
  17. //
  18. //      Implementation of class List member functions.
  19. //
  20. // End ---------------------------------------------------------------------
  21.  
  22. // Interface Dependencies ---------------------------------------------------
  23.  
  24. #ifndef __IOSTREAM_H
  25. #include <iostream.h>
  26. #define __IOSTREAM_H
  27. #endif
  28.  
  29. #ifndef __CLSTYPES_H
  30. #include <clstypes.h>
  31. #endif
  32.  
  33. #ifndef __OBJECT_H
  34. #include <object.h>
  35. #endif
  36.  
  37. #ifndef __CONTAIN_H
  38. #include <contain.h>
  39. #endif
  40.  
  41. #ifndef __LIST_H
  42. #include <list.h>
  43. #endif
  44.  
  45. // End Interface Dependencies ------------------------------------------------
  46.  
  47.  
  48. // Implementation Dependencies ----------------------------------------------
  49.  
  50. #ifndef __LSTELEM_H
  51. #include <lstelem.h>
  52. #endif
  53.  
  54. // End Implementation Dependencies -------------------------------------------
  55.  
  56. // Member Function //
  57.  
  58. List::~List()
  59.  
  60. // Summary -----------------------------------------------------------------
  61. //
  62. //      Destructor for a List object.
  63. //
  64. // End ---------------------------------------------------------------------
  65. {
  66.     while( head != 0 )
  67.         {
  68.         ListElement *temp = head;
  69.         head = head->next;
  70.         delete temp;
  71.         }
  72. }
  73. // End Destructor //
  74.  
  75. RObject List::peekHead() const
  76. { 
  77.       if(head)
  78.          return *(head->data);
  79.       else
  80.          return NOOBJECT;
  81. }
  82.  
  83. // Member Function //
  84.  
  85. void List::add( Object& toAdd )
  86.  
  87. // Summary -----------------------------------------------------------------
  88. //
  89. //      Adds the given object on the list.
  90. //
  91. // Parameters
  92. //
  93. //      toAdd
  94. //
  95. //      The object we are to add to the list.  Once the object is
  96. //      added, it is owned by the list.
  97. //
  98. // End ---------------------------------------------------------------------
  99. {
  100.     ListElement *newElement = new ListElement( &toAdd );
  101.  
  102.     newElement->next = head;
  103.     head = newElement;
  104.     itemsInContainer++;
  105. }
  106. // End Member Function List::add //
  107.  
  108.  
  109. // Member Function //
  110.  
  111. void    List::detach( const Object& toDetach, int deleteObjectToo )
  112.  
  113. // Summary -----------------------------------------------------------------
  114. //
  115. //      Detaches an object from the list.
  116. //
  117. // Parameter
  118. //
  119. //      toDetach
  120. //
  121. //      The object we are to search for and detach from the List.
  122. //
  123. //      deleteObjectToo
  124. //
  125. //      Specifies whether we are to delete the object.
  126. //
  127. // Functional Description                     
  128. //
  129. //      If the object specified is at the head of the list, we remove
  130. //      the reference right away.  Otherwise, we iterate through the list until
  131. //      we find it, then remove the reference.
  132. //
  133. // Remarks
  134. //
  135. //  warnings:
  136. //      No error condition is generated if the object which was specified
  137. //      isn't in the list.
  138. //
  139. // End ---------------------------------------------------------------------
  140. {
  141.     if(head == 0)
  142.       return;
  143.  
  144.     ListElement *cursor = head;
  145.  
  146.     if ( *(head->data) == toDetach )
  147.     {
  148.         head = head->next;
  149.     }
  150.     else  // the object isn't at the head of the list.
  151.     {
  152.  
  153. // Body Comment
  154. //
  155. //     Normally we would do this iteration with a list iterator.
  156. //     Since we need to keep track of not only the objects in the
  157. //     list but also the list elements, i.e. the pointer nodes,
  158. //     we don't use the iterator.
  159. //
  160. // End
  161.  
  162.         ListElement *trailer = head;
  163.  
  164.         while ( (cursor = cursor->next) != 0 )
  165.         {
  166.             if ( *(cursor->data) == toDetach )
  167.             {
  168.                 trailer->next = cursor->next;
  169.                 break;
  170.             }
  171.             else // the object isn't the one we want.
  172.             {
  173.                 trailer = trailer->next;
  174.             }
  175.         } // end while
  176.  
  177.     } // end else the object wasn't at the head of the list.
  178.  
  179. // Body Comment
  180. //
  181. //  Now cursor points to the object that we've found
  182. //
  183. // End
  184.  
  185.    if( cursor != 0 )
  186.    {
  187.       itemsInContainer--;
  188.       if ( !deleteObjectToo )
  189.          cursor->data = 0;       // insure that we don't delete the data
  190.  
  191.       delete cursor;
  192.    }
  193. }
  194. // End Member Function List::detach //
  195.  
  196.  
  197. // Member Function //
  198.  
  199. classType List::isA() const
  200.  
  201. // Summary -----------------------------------------------------------------
  202. //
  203. //      Returns a predefined value for the class List.
  204. //
  205. // Parameters
  206. //
  207. //      none
  208. //
  209. // End ---------------------------------------------------------------------
  210. {
  211.     return listClass;
  212. }
  213. // End Member Function List::isA //
  214.  
  215. // Member Function //
  216.  
  217. char *List::nameOf() const
  218.  
  219. // Summary -----------------------------------------------------------------
  220. //
  221. //      Returns the string "List".
  222. //
  223. // Parameters
  224. //
  225. //      none
  226. //
  227. // End ---------------------------------------------------------------------
  228. {
  229.     return "List";
  230. }
  231. // End Member Function List::nameOf //
  232.  
  233.  
  234. // Member Function //
  235.  
  236. hashValueType List::hashValue() const
  237.  
  238. // Summary -----------------------------------------------------------------
  239. //
  240. //      Returns the hash value of a list.
  241. //
  242. // End ---------------------------------------------------------------------
  243. {
  244.     return hashValueType(0);
  245. }
  246. // End Member Function List::hashValue //
  247.  
  248. // Member Function //
  249.  
  250. ContainerIterator& List::initIterator() const
  251.  
  252. // Summary -----------------------------------------------------------------
  253. //
  254. //      Initializes an iterator for a list.
  255. //
  256. // End ---------------------------------------------------------------------
  257. {
  258.     return *( (ContainerIterator *)new ListIterator( *this ) );
  259. }
  260. // End Member Function List::initIterator //
  261.  
  262.  
  263. // Member Function //
  264.  
  265. ListIterator::~ListIterator()
  266.  
  267. // Summary -----------------------------------------------------------------
  268. //
  269. //
  270. //
  271. // End ---------------------------------------------------------------------
  272. {
  273. }
  274. // End Destructor //
  275.  
  276.  
  277. // Member Function //
  278.  
  279. ListIterator::operator int()
  280.  
  281. // Summary -----------------------------------------------------------------
  282. //
  283. //  Returns an integer value indicating whether the iteration is complete.
  284. //
  285. //    1 indicates not complete, 0 indicates complete.
  286. //
  287. // End ---------------------------------------------------------------------
  288. {
  289.     return currentElement != 0;
  290. }
  291. // End Member Function ListIterator::operator int //
  292.  
  293.  
  294. // Member Function //
  295.  
  296. ListIterator::operator Object&()
  297.  
  298. // Summary -----------------------------------------------------------------
  299. //
  300. //      Object reference conversion operator.
  301. //
  302. // End ---------------------------------------------------------------------
  303. {
  304.     if ( currentElement == 0 )
  305.     {
  306.         return NOOBJECT;
  307.     }
  308.     else
  309.     {
  310.         return ( (Object&)(*(currentElement->data)) );
  311.     }
  312. }
  313. // End Member Function ListIterator::operator Object& //
  314.  
  315.  
  316. // Member Function //
  317.  
  318. Object& ListIterator::operator ++()
  319.  
  320. // Summary -----------------------------------------------------------------
  321. //
  322. //     Increments the list iterator and returns the next object.
  323. //
  324. // End ---------------------------------------------------------------------
  325. {
  326.     ListElement *trailer = currentElement;
  327.  
  328.     if ( currentElement != 0 )
  329.     {
  330.         currentElement = currentElement->next;
  331.         return ( (Object&)(*(trailer->data)) );
  332.     }
  333.     else // no more elements in the list.
  334.     {
  335.         return NOOBJECT;
  336.     }
  337.  
  338. }
  339. // End Member Function ListIterator::operator ++ //
  340.  
  341.  
  342. // Member Function //
  343.  
  344. void ListIterator::restart()
  345.  
  346. // Summary -----------------------------------------------------------------
  347. //
  348. //      Restart function for a list iterator object.
  349. //
  350. // End ---------------------------------------------------------------------
  351. {
  352.     currentElement = startingElement;
  353. }
  354. // End Member Function ListIterator::restart //
  355.