home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / oclsrc15.zip / OCL / Include / OList.inl < prev    next >
Text File  |  1996-08-12  |  5KB  |  240 lines
  1. // OCL - OS/2 Class Library
  2. // (c) Cubus 1995
  3. // All Rights Reserved
  4. // OList.inl
  5.  
  6. /*
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  * 1. Redistributions of source code must retain the above copyright
  11.  *    notice, this list of conditions and the following disclaimer.
  12.  * 2. Neither the name Cubus nor the name Team OCL may be used to
  13.  *    endorse or promote products derived from this software
  14.  *    without specific prior written permission.
  15.  * 3. See OCL.INF for a detailed copyright notice.
  16.  *
  17.  *              THIS SOFTWARE IS PROVIDED ``AS IS'' AND
  18.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27.  * SUCH DAMAGE.
  28.  */
  29.  
  30. // $Header: W:/Projects/OCL/Include/rcs/OList.inl 1.50 1996/08/11 23:47:19 B.STEIN Release $
  31.  
  32.  
  33. #ifndef OLIST_INLINED
  34.   #define OLIST_INLINED
  35.  
  36.  
  37. template <class T>
  38. OList<T>::OList(BOOL copyElements)
  39.   : OCollection(copyElements)
  40.   {}
  41.  
  42. template <class T>
  43. OList<T>::OList(OList<T>& list, BOOL copyElements)
  44.   : OCollection(copyElements)
  45. {
  46.  T* temp = list.getFirst();
  47.  
  48.  while (temp) {
  49.    add((T*)temp);
  50.    temp = list.getNext(); }
  51. }
  52.  
  53. template <class T>
  54. OList<T>::~OList()
  55.   {}
  56.  
  57. template <class T>
  58. PSZ OList<T>::isOfType() const
  59. { 
  60.  return("OList<T>"); 
  61. }
  62.  
  63. template <class T>
  64. void OList<T>::freeItem(PVOID elem)
  65. { 
  66.  delete (T*) elem; 
  67. }
  68.  
  69. template <class T>
  70. T* OList<T>::getFirst()
  71. { 
  72.  return((T*) OCollection::_getFirst()); 
  73. }
  74.  
  75. template <class T>
  76. T* OList<T>::getLast()
  77. { 
  78.  return((T*) OCollection::_getLast()); 
  79. }
  80.  
  81. template <class T>
  82. T* OList<T>::get()
  83. { 
  84.  return((T*) OCollection::_getNext()); 
  85. }
  86.  
  87. template <class T>
  88. T* OList<T>::getNext()         
  89. { 
  90.  return((T*) OCollection::_getNext()); 
  91. }
  92.  
  93. template <class T>
  94. T* OList<T>::getNext(T *elem)
  95. { 
  96.  return((T*) OCollection::_getNext(elem)); 
  97. }
  98.  
  99. template <class T>
  100. T* OList<T>::getPrev()          
  101. { 
  102.  return((T*) OCollection::_getPrev()); 
  103. }
  104.  
  105. template <class T>
  106. T* OList<T>::getPrev(T *elem)
  107. { 
  108.  return((T*) OCollection::_getPrev(elem)); 
  109. }
  110.  
  111. template <class T>
  112. T* OList<T>::getItem(ULONG itemNum)
  113. { 
  114.  return((T*) OCollection::_getItem(itemNum)); 
  115. }
  116.  
  117.  
  118. template <class T>
  119. OListItem<T>* OList<T>::first() const
  120. {
  121.  return((OListItem<T>*)OCollection::first);
  122. }
  123.  
  124. template <class T>
  125. OListItem<T>* OList<T>::actual() const
  126. {
  127.  return((OListItem<T>*)OCollection::actual);
  128. }
  129.  
  130. template <class T>
  131. OListItem<T>* OList<T>::last() const
  132. {
  133.  return((OListItem<T>*)OCollection::last);
  134. }
  135.  
  136. template <class T>
  137. OListItem<T>* OList<T>::getNextListItem(T *elem)
  138. { 
  139.  return((OListItem<T>*) OCollection::_getNextListItem(elem)); 
  140. }
  141.  
  142. template <class T>
  143. OListItem<T>* OList<T>::getPrevListItem(T *elem)
  144. { 
  145.  return((OListItem<T>*) OCollection::_getPrevListItem(elem)); 
  146. }
  147.  
  148. template <class T>
  149. void OList<T>::add(T& elem)
  150. { 
  151.  isCopyCollection() ? addLast(new T(elem)) : addLast(&elem);
  152. }
  153.  
  154. template <class T>
  155. void OList<T>::add(T* elem)
  156. { 
  157.  isCopyCollection() ? addLast(new T(*elem)) : addLast((T*)elem);
  158. }
  159.  
  160. template <class T>
  161. OList<T>& OList<T>::operator << (T* elem)
  162. {
  163.  if (elem) add(elem);
  164.  return(*this);
  165. }
  166.  
  167. template <class T>
  168. OList<T>& OList<T>::operator << (T& elem)
  169. {
  170.  add(&elem);
  171.  return(*this);
  172. }
  173.  
  174. template <class T>
  175. OList<T>& OList<T>::operator >> (T& elem)
  176. {
  177.  T* temp = getNext();
  178.  
  179.  if (temp)
  180.    elem = *temp;
  181.  
  182.  return(*this);
  183. }
  184.  
  185. template <class T>
  186. OList<T>& OList<T>::operator >> (T* elem)
  187. {
  188.  elem = getNext();
  189.  return(*this);
  190. }
  191.  
  192.  
  193. template <class T>
  194. void OList<T>::allElementsDo(void (*function)(const T* elem)) const
  195. {
  196.  OListItem<T> *temp = first();
  197.  
  198.  while(temp) {
  199.    if (temp->item)
  200.      function(temp->item);
  201.    temp = temp->next; }
  202. }
  203.  
  204. template <class T>
  205. void OList<T>::allElementsDo(OConstIterator<T>& iter) const
  206. {
  207.  OListItem<T> *temp = first();
  208.  
  209.  while(temp) {
  210.    if (temp->item)
  211.      iter.applyToElement(temp->item);
  212.    temp = temp->next; }
  213. }
  214.  
  215.  
  216. template <class T>
  217. void OList<T>::allElementsDo(void (*function)(T* elem))
  218. {
  219.  T *temp = getFirst();
  220.  
  221.  while(temp) {
  222.    function(temp);
  223.    temp = getNext(); }
  224. }
  225.  
  226. template <class T>
  227. void OList<T>::allElementsDo(OIterator<T>& iter)
  228. {
  229.  T *temp = getFirst();
  230.  
  231.  while(temp) {
  232.    iter.applyToElement(temp);
  233.    temp = getNext(); }
  234. }
  235.  
  236.  
  237. #endif // OLIST_INLINED
  238.  
  239. // end of source
  240.