home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / IBMCLASS / IRBAG.C < prev    next >
Text File  |  1993-09-22  |  10KB  |  351 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.  
  13. template < class Element, class Base >
  14. void* IRBag < Element, Base >::
  15. identity () const
  16. { return (void*)&ivBase;
  17. }
  18.  
  19. template < class Element, class Base >
  20. IRBag < Element, Base >::
  21. ~IRBag ()
  22. {
  23. }
  24.  
  25. template < class Element, class Base >
  26. IBoolean IRBag < Element, Base >::
  27. add (Element const& element)
  28. { return ivBase.add (element);
  29. }
  30.  
  31. template < class Element, class Base >
  32. IBoolean IRBag < Element, Base >::
  33. add (Element const& element, ICursor &cursor)
  34. { return ivBase.add (element, cursor);
  35. }
  36.  
  37. template < class Element, class Base >
  38. Element const& IRBag < Element, Base >::
  39. elementAt (ICursor const& cursor) const
  40. { return ivBase.elementAt (cursor);
  41. }
  42.  
  43. template < class Element, class Base >
  44. Element& IRBag < Element, Base >::
  45. elementAt (ICursor const& cursor)
  46. { return ivBase.elementAt (cursor);
  47. }
  48.  
  49. template < class Element, class Base >
  50. Element const& IRBag < Element, Base >::
  51. anyElement () const
  52. { return ivBase.anyElement ();
  53. }
  54.  
  55. template < class Element, class Base >
  56. void IRBag < Element, Base >::
  57. removeAt (ICursor const& cursor)
  58. { ivBase.removeAt (cursor);
  59. }
  60.  
  61. template < class Element, class Base >
  62. INumber IRBag < Element, Base >::
  63. removeAll (IBoolean (*predicate) (Element const&, void*), void* env)
  64. { return ivBase.removeAll (predicate, env);
  65. }
  66.  
  67. template < class Element, class Base >
  68. void IRBag < Element, Base >::
  69. replaceAt (ICursor const& cursor, Element const& element)
  70. { ivBase.replaceAt (cursor, element);
  71. }
  72.  
  73. template < class Element, class Base >
  74. void IRBag < Element, Base >::
  75. removeAll ()
  76. { ivBase.removeAll ();
  77. }
  78.  
  79. template < class Element, class Base >
  80. IBoolean IRBag < Element, Base >::
  81. isBounded () const
  82. { return ivBase.isBounded ();
  83. }
  84.  
  85. template < class Element, class Base >
  86. INumber IRBag < Element, Base >::
  87. maxNumberOfElements () const
  88. { return ivBase.maxNumberOfElements ();
  89. }
  90.  
  91. template < class Element, class Base >
  92. INumber IRBag < Element, Base >::
  93. numberOfElements () const
  94. { return ivBase.numberOfElements ();
  95. }
  96.  
  97. template < class Element, class Base >
  98. IBoolean IRBag < Element, Base >::
  99. isEmpty () const
  100. { return ivBase.isEmpty ();
  101. }
  102.  
  103. template < class Element, class Base >
  104. IBoolean IRBag < Element, Base >::
  105. isFull () const
  106. { return ivBase.isFull ();
  107. }
  108.  
  109. template < class Element, class Base >
  110. ICursor* IRBag < Element, Base >::
  111. newCursor () const
  112. { return ivBase.newCursor ();
  113. }
  114.  
  115. template < class Element, class Base >
  116. IBoolean IRBag < Element, Base >::
  117. setToFirst (ICursor &cursor) const
  118. { return ivBase.setToFirst (cursor);
  119. }
  120.  
  121. template < class Element, class Base >
  122. IBoolean IRBag < Element, Base >::
  123. setToNext (ICursor &cursor) const
  124. { return ivBase.setToNext (cursor);
  125. }
  126.  
  127. template < class Element, class Base >
  128. IBoolean IRBag < Element, Base >::
  129. allElementsDo (IBoolean (*iterationFunction) (Element &, void*),
  130.                void* environment)
  131. { return ivBase.allElementsDo (iterationFunction, environment);
  132. }
  133.  
  134. template < class Element, class Base >
  135. IBoolean IRBag < Element, Base >::
  136. allElementsDo (IIterator <Element>& iterator)
  137. { return ivBase.allElementsDo (iterator);
  138. }
  139.  
  140. template < class Element, class Base >
  141. IBoolean IRBag < Element, Base >::
  142. allElementsDo (IBoolean (*iterationFunction) (Element const&, void*),
  143.                void* environment) const
  144. { return ivBase.allElementsDo (iterationFunction, environment);
  145. }
  146.  
  147. template < class Element, class Base >
  148. IBoolean IRBag < Element, Base >::
  149. allElementsDo (IConstantIterator <Element>& iterator) const
  150. { return ivBase.allElementsDo (iterator);
  151. }
  152.  
  153. template < class Element, class Base >
  154. IBoolean IRBag < Element, Base >::
  155. isConsistent () const
  156. { return ivBase.isConsistent ();
  157. }
  158.  
  159. template < class Element, class Base >
  160. IBoolean IRBag < Element, Base >::
  161. contains (Element const& element) const
  162. { return ivBase.contains (element);
  163. }
  164.  
  165. template < class Element, class Base >
  166. IBoolean IRBag < Element, Base >::
  167. locate (Element const& element, ICursor &cursor) const
  168. { return ivBase.locate (element, cursor);
  169. }
  170.  
  171. template < class Element, class Base >
  172. IBoolean IRBag < Element, Base >::
  173. locateOrAdd (Element const& element)
  174. { return ivBase.locateOrAdd (element);
  175. }
  176.  
  177. template < class Element, class Base >
  178. IBoolean IRBag < Element, Base >::
  179. locateOrAdd (Element const& element, ICursor &cursor)
  180. { return ivBase.locateOrAdd (element, cursor);
  181. }
  182.  
  183. template < class Element, class Base >
  184. IBoolean IRBag < Element, Base >::
  185. remove (Element const& element)
  186. { return ivBase.remove (element);
  187. }
  188.  
  189. template < class Element, class Base >
  190. INumber IRBag < Element, Base >::
  191. numberOfOccurrences (Element const& element) const
  192. { return ivBase.numberOfOccurrences (element);
  193. }
  194.  
  195. template < class Element, class Base >
  196. IBoolean IRBag < Element, Base >::
  197. locateNext (Element const& element, ICursor& cursor) const
  198. { return ivBase.locateNext (element, cursor);
  199. }
  200.  
  201. template < class Element, class Base >
  202. INumber IRBag < Element, Base >::
  203. removeAllOccurrences (Element const& element)
  204. { return ivBase.removeAllOccurrences (element);
  205. }
  206.  
  207. template < class Element, class Base >
  208. INumber IRBag < Element, Base >::
  209. numberOfDifferentElements () const
  210. { return ivBase.numberOfDifferentElements ();
  211. }
  212.  
  213. template < class Element, class Base >
  214. IBoolean IRBag < Element, Base >::
  215. setToNextDifferentElement (ICursor& cursor) const
  216. { return ivBase.setToNextDifferentElement (cursor);
  217. }
  218.  
  219. template < class Element, class Base >
  220. void IRBag < Element, Base >::
  221. unionWith (IABag < Element > const& collection)
  222. { if (isIdentical (collection))
  223.     ivBase.unionWith (ivBase);
  224.   else
  225.     addAllFrom (collection);
  226. }
  227.  
  228. template < class Element, class Base >
  229. void IRBag < Element, Base >::
  230. intersectionWith (IABag < Element > const& collection)
  231. { if (! isIdentical (collection))
  232.   { IAEqualityCollection < Element > const* env = &collection;
  233.     removeAll (IAEqualityCollection < Element >::isNotContained, &env);
  234.  
  235.     ICursor *cursor = collection.newCursor ();
  236.     for (cursor->setToFirst ();
  237.          cursor->isValid ();
  238.          collection.setToNextDifferentElement (*cursor)) {
  239.       Element const& e = collection.elementAt (*cursor);
  240.       INumber n = numberOfOccurrences (e);
  241.       if (n > 0) {
  242.         INumber n1 = collection.numberOfOccurrences (e);
  243.         for (; n > n1; n--)
  244.           remove (e);
  245.       }
  246.     }
  247.     delete cursor;
  248.  
  249.   }
  250. }
  251.  
  252. template < class Element, class Base >
  253. void IRBag < Element, Base >::
  254. differenceWith (IABag < Element > const& collection)
  255. { if (! isIdentical (collection))
  256.   { ICursor *cursor = collection.newCursor ();
  257.     forCursor (*cursor)
  258.       remove (collection.elementAt (*cursor));
  259.     delete cursor;
  260.   }
  261.   else
  262.     removeAll ();
  263. }
  264.  
  265. template < class Element, class Base >
  266. void IRBag < Element, Base >::
  267. addUnion (IABag < Element > const& collection1,
  268.           IABag < Element > const& collection2)
  269. { if (isIdentical (collection1)) {
  270.     if (isIdentical (collection2))
  271.       ivBase.addUnion (ivBase, ivBase);
  272.     else {
  273.       unionWith (collection1);
  274.       unionWith (collection2);
  275.     }
  276.   }
  277.   else {
  278.     unionWith (collection2);
  279.     unionWith (collection1);
  280.   }
  281. }
  282.  
  283. template < class Element, class Base >
  284. void IRBag < Element, Base >::
  285. addIntersection (IABag < Element > const& collection1,
  286.                  IABag < Element > const& collection2)
  287. { if (isIdentical (collection1)) {
  288.     if (isIdentical (collection2))
  289.       ivBase.unionWith (ivBase);
  290.     else
  291.       addIntersection (collection2, collection1);
  292.   }
  293.   else {
  294.     ICursor *cursor2 = collection2.newCursor ();
  295.     for (cursor2->setToFirst ();
  296.          cursor2->isValid ();
  297.          collection2.setToNextDifferentElement (*cursor2)) {
  298.       Element const& e = collection2.elementAt (*cursor2);
  299.       INumber n1, n2;
  300.       n1 = collection1.numberOfOccurrences (e);
  301.       n2 = collection2.numberOfOccurrences (e);
  302.       INumber n = (n1 < n2 ? n1 : n2);
  303.       for ( ; n > 0 ; n--)
  304.         add (e);
  305.     }
  306.     delete cursor2;
  307.   }
  308. }
  309.  
  310. template < class Element, class Base >
  311. void IRBag < Element, Base >::
  312. addDifference (IABag < Element > const& collection1,
  313.                IABag < Element > const& collection2)
  314. { if (isIdentical (collection1)) {
  315.     if (isIdentical (collection2))
  316.       return;
  317.     else {
  318.       ivBase.unionWith (ivBase);
  319.       ICursor *cursor2 = collection2.newCursor ();
  320.       for (cursor2->setToFirst ();
  321.            cursor2->isValid ();
  322.            collection2.setToNextDifferentElement (*cursor2)) {
  323.         Element const& e = collection2.elementAt (*cursor2);
  324.         INumber n1, n2;
  325.         n1 = numberOfOccurrences (e) / 2;
  326.         n2 = collection2.numberOfOccurrences (e);
  327.         INumber n = (n1 < n2 ? n1 : n2);
  328.         for ( ; n > 0 ; n--)
  329.           remove (e);
  330.       }
  331.       delete cursor2;
  332.     }
  333.   }
  334.   else {
  335.     ICursor *cursor1 = collection1.newCursor ();
  336.     for (cursor1->setToFirst ();
  337.          cursor1->isValid ();
  338.          collection1.setToNextDifferentElement (*cursor1)) {
  339.       Element const& e = collection1.elementAt (*cursor1);
  340.       INumber n1, n2;
  341.       n1 = collection1.numberOfOccurrences (e);
  342.       n2 = collection2.numberOfOccurrences (e);
  343.       INumber n = (n1 < n2 ? 0 : n1 - n2);
  344.       for ( ; n > 0 ; n--)
  345.         add (e);
  346.     }
  347.     delete cursor1;
  348.   }
  349. }
  350.  
  351.