home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / IBMCLASS / IBSTKSS.C < prev    next >
Text File  |  1993-09-22  |  10KB  |  244 lines
  1. /*******************************************************************************
  2. *                                                                              *
  3. * COPYRIGHT:                                                                   *
  4. *   IBM C/C++ Tools Version 2.01 - Collection Class Library                    *
  5. *   Licensed Materials - Property of IBM                                       *
  6. *   (C) Copyright IBM Corporation 1992, 1993                                   *
  7. *   All Rights Reserved                                                        *
  8. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  9. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  10. *                                                                              *
  11. *******************************************************************************/
  12. template < class Element, class Key, class ElementOps, size_t nodeSize >
  13. void const* IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
  14. getElement () const
  15. { return &ivItem;
  16. }
  17.  
  18. template < class Element, class Key, class ElementOps, size_t nodeSize >
  19. void* IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
  20. getElement ()
  21. { return &ivItem;
  22. }
  23.  
  24. template < class Element, class Key, class ElementOps, size_t nodeSize >
  25. void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
  26. replaceElement (void const* element)
  27. { ivItem = *(Element const*) element;
  28. }
  29.  
  30. template < class Element, class Key, class ElementOps, size_t nodeSize >
  31. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
  32. isKeyEqualTo (void const* lnode) const
  33. { return 0 == elementOps().keyOps.compare (
  34.                 elementOps().key (ivItem),
  35.                 elementOps().key (((Lnode const*) lnode)->ivItem));
  36. }
  37.  
  38. template < class Element, class Key, class ElementOps, size_t nodeSize >
  39. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
  40. isKeyEqualToKeyOfElement (void const* element) const
  41. { return 0 == elementOps().keyOps.compare (
  42.                 elementOps().key (ivItem),
  43.                 elementOps().key (*(Element const*) element));
  44. }
  45.  
  46. template < class Element, class Key, class ElementOps, size_t nodeSize >
  47. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Lnode::
  48. isKeyEqualToKey (void const* key) const
  49. { return 0 == elementOps().keyOps.compare (
  50.                 elementOps().key (ivItem),
  51.                 *(Key const*) key);
  52. }
  53.  
  54. template < class Element, class Key, class ElementOps, size_t nodeSize >
  55. IBSTKeySortedSetImpl::Lnode*
  56. IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  57. newLnode (void const* element) const
  58. { IBSTKeySortedSetImpl::Lnode* result = new Lnode(*(Element const*) element);
  59.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  60.   return result;
  61. }
  62.  
  63. template < class Element, class Key, class ElementOps, size_t nodeSize >
  64. IBSTKeySortedSetImpl::Lnode*
  65. IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  66. newLnodeFromLnode (void const* lnode) const
  67. { IBSTKeySortedSetImpl::Lnode* result = new Lnode(*(Lnode const*) lnode);
  68.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  69.   return result;
  70. }
  71.  
  72. template < class Element, class Key, class ElementOps, size_t nodeSize >
  73. IBSTKeySortedSetImpl::Inode*
  74. IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  75. newInode () const
  76. { IBSTKeySortedSetImpl::Inode* result = new Inode();
  77.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  78.   return result;
  79. }
  80.  
  81. template < class Element, class Key, class ElementOps, size_t nodeSize >
  82. IBSTKeySortedSetImpl::Inode*
  83. IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  84. newInode (void const* inode) const
  85. { Inode const* in = (Inode const*) inode;
  86.   Inode* result = new Inode (*in);
  87.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  88.   for (IPosition i = 0; i < result->ivm; i++)
  89.     result->ivNodeptrs[i] = in->ivNodeptrs[i];
  90.   for (i = 0; i < result->ivm-1; i++)
  91.     result->ivKeys [i] = in->ivKeys [i];
  92.   return result;
  93. }
  94.  
  95. template < class Element, class Key, class ElementOps, size_t nodeSize >
  96. void* IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  97. newKey () const
  98. { void* result = new KeyWrapper;
  99.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  100.   return result;
  101. }
  102.  
  103. template < class Element, class Key, class ElementOps, size_t nodeSize >
  104. void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  105. deleteLnode (void* lnode) const
  106. { delete ((Lnode*) lnode);
  107. }
  108.  
  109. template < class Element, class Key, class ElementOps, size_t nodeSize >
  110. void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  111. deleteInode (void* inode) const
  112. { delete ((Inode*) inode);
  113. }
  114.  
  115. template < class Element, class Key, class ElementOps, size_t nodeSize >
  116. void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  117. deleteKey (void* key) const
  118. { delete ((KeyWrapper*) key);
  119. }
  120.  
  121. template < class Element, class Key, class ElementOps, size_t nodeSize >
  122. IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  123. isKeyLessThan (void const* key1, void const* key2) const
  124. { return 0 >  elementOps().keyOps.compare (
  125.                 * (Key*) key1,
  126.                 * (Key*) key2);
  127. }
  128.  
  129. template < class Element, class Key, class ElementOps, size_t nodeSize >
  130. void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  131. copyKey (void *to, unsigned int toIndex,
  132.          void const* from, unsigned int fromIndex) const
  133. { ((Key*)to) [toIndex] = ((Key*)from) [fromIndex];
  134. }
  135.  
  136. template < class Element, class Key, class ElementOps, size_t nodeSize >
  137. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  138. isKeyLessThanLnode (void const* key, void const* lnode) const
  139. { return 0 >  elementOps().keyOps.compare (
  140.                 *(Key const*) key,
  141.                 elementOps().key (((Lnode const*) lnode)->ivItem));
  142. }
  143.  
  144. template < class Element, class Key, class ElementOps, size_t nodeSize >
  145. void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  146. copyKeyFromLnode (void* key, void const* lnode)
  147. { *(Key*)key = elementOps().key (((Lnode const*) lnode)->ivItem);
  148. }
  149.  
  150. template < class Element, class Key, class ElementOps, size_t nodeSize >
  151. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  152. isKeyGreaterThanLnode (void const* key,
  153.                        unsigned int index,
  154.                        void const* lnode) const
  155. { return 0 <  elementOps().keyOps.compare (
  156.                 ((Key const*) key) [index],
  157.                 elementOps().key (((Lnode const*) lnode)->ivItem));
  158. }
  159.  
  160. template < class Element, class Key, class ElementOps, size_t nodeSize >
  161. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  162. isKeyGreaterThanKey (void const* key1,
  163.                      unsigned int index,
  164.                      void const* key2) const
  165. { return 0 <  elementOps().keyOps.compare (
  166.                 ((Key const*) key1) [index],
  167.                 *(Key const*) key2);
  168. }
  169.  
  170. template < class Element, class Key, class ElementOps, size_t nodeSize >
  171. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  172. isKeyGreaterThanElement (void const* key,
  173.                          unsigned int index,
  174.                          void const* element) const
  175. { return 0 <  elementOps().keyOps.compare (
  176.                 ((Key const*) key) [index],
  177.                 elementOps().key (*(Element const*) element));
  178. }
  179.  
  180. template < class Element, class Key, class ElementOps, size_t nodeSize >
  181. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
  182. setToFirst ()
  183. { return ivCollection->setToFirst (*this);
  184. }
  185.  
  186. template < class Element, class Key, class ElementOps, size_t nodeSize >
  187. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
  188. setToNext ()
  189. { return ivCollection->setToNext (*this);
  190. }
  191.  
  192. template < class Element, class Key, class ElementOps, size_t nodeSize >
  193. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
  194. isValid () const
  195. { return ivNode != 0;
  196. }
  197.  
  198. template < class Element, class Key, class ElementOps, size_t nodeSize >
  199. void IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Cursor::
  200. invalidate ()
  201. { ivNode = 0;
  202. }
  203.  
  204. template < class Element, class Key, class ElementOps, size_t nodeSize >
  205. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  206. constantFunctionIteration (void *iterationFunction,
  207.                            void* env,
  208.                            void const* lnode) const
  209. { return (*(IBoolean (*) (Element const&, void*)) iterationFunction)
  210.            (((Lnode const*)lnode)->ivItem, env);
  211. }
  212.  
  213. template < class Element, class Key, class ElementOps, size_t nodeSize >
  214. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  215. functionIteration (void *iterationFunction, void* env, void* lnode) const
  216. { return (*(IBoolean (*) (Element&, void*)) iterationFunction)
  217.            (((Lnode*)lnode)->ivItem, env);
  218. }
  219.  
  220. template < class Element, class Key, class ElementOps, size_t nodeSize >
  221. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  222. constantIteratorIteration (void* iterator, void const* lnode) const
  223. { return ((IConstantIterator < Element >*)iterator)->
  224.            applyTo (((Lnode const*)lnode)->ivItem);
  225. }
  226.  
  227. template < class Element, class Key, class ElementOps, size_t nodeSize >
  228. IBoolean IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  229. iteratorIteration (void* iterator, void* lnode) const
  230. { return ((IIterator < Element >*)iterator)->
  231.            applyTo (((Lnode*)lnode)->ivItem);
  232. }
  233.  
  234. template < class Element, class Key, class ElementOps, size_t nodeSize >
  235. long IWBSTKeySortedSet < Element, Key, ElementOps, nodeSize >::Operations::
  236. functionComparison (void *comparisonFunction,
  237.                     void const* lnode1,
  238.                     void const* lnode2) const
  239. { return (*(long (*) (Element const&, Element const&) const)
  240.             comparisonFunction)
  241.            ( ((Lnode const*)lnode1)->ivItem,
  242.              ((Lnode const*)lnode2)->ivItem );
  243. }
  244.