home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / IBMCLASS / ITDSEQ.C < prev    next >
Text File  |  1993-09-22  |  9KB  |  261 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. #include <ibexcept.h>
  13.  
  14. template <class Element, class ElementOps>
  15. IBoolean IGDilutedSequence <Element, ElementOps>::Cursor::setToFirst ()
  16. { return ivCollection->setToFirst (*this);
  17. }
  18.  
  19. template <class Element, class ElementOps>
  20. IBoolean IGDilutedSequence <Element, ElementOps>::Cursor::setToNext ()
  21. { return ivCollection->setToNext (*this);
  22. }
  23.  
  24. template <class Element, class ElementOps>
  25. IBoolean IGDilutedSequence <Element, ElementOps>::Cursor::isValid () const
  26. { return ivImpl.ivIsValid;
  27. }
  28.  
  29. template <class Element, class ElementOps>
  30. void IGDilutedSequence <Element, ElementOps>::Cursor::invalidate ()
  31. { ivImpl.ivIsValid = False;
  32. }
  33.  
  34. template < class Element, class ElementOps >
  35. void IGDilutedSequence < Element, ElementOps >::Operations::
  36. copyFrom (INumber index, void const* element) const
  37. { elementOps().assign
  38.     (((Node*)ivNodes) [index].ivElement, *(Element const*)element);
  39.   ((Node*)ivNodes) [index].ivIsRemoved = False;
  40. }
  41.  
  42. template < class Element, class ElementOps >
  43. void const* IGDilutedSequence < Element, ElementOps >::Operations::
  44. elementAt (INumber index) const
  45. { return &((Node*)ivNodes) [index].ivElement;
  46. }
  47.  
  48. template < class Element, class ElementOps >
  49. IBoolean IGDilutedSequence < Element, ElementOps >::Operations::
  50. isRemoved (INumber index) const
  51. { return ((Node*)ivNodes) [index].ivIsRemoved;
  52. }
  53.  
  54. template < class Element, class ElementOps >
  55. void IGDilutedSequence < Element, ElementOps >::Operations::
  56. remove (INumber index)
  57. { ((Node*)ivNodes) [index].ivIsRemoved = True;
  58.   if (--ivNumberOfElements > 0) {
  59.     if (index == ivFirst)
  60.       setToNext (ivFirst);
  61.     else if (index == ivLast)
  62.       setToPrevious (ivLast);
  63.   }
  64.   else
  65.     decMod (ivLast);
  66. }
  67.  
  68. template < class Element, class ElementOps >
  69. IBoolean IGDilutedSequence < Element, ElementOps >::Operations::
  70. setToNext (INumber& index) const
  71. { if (index == ivLast)
  72.     return False;
  73.   do
  74.     incMod (index);
  75.   while (((Node*)ivNodes) [index].ivIsRemoved);
  76.   return True;
  77. }
  78.  
  79. template < class Element, class ElementOps >
  80. IBoolean IGDilutedSequence < Element, ElementOps >::Operations::
  81. setToPrevious (INumber& index) const
  82. { if (index == ivFirst)
  83.     return False;
  84.   do
  85.     decMod (index);
  86.   while (((Node*)ivNodes) [index].ivIsRemoved);
  87.   return True;
  88. }
  89.  
  90. template < class Element, class ElementOps >
  91. void IGDilutedSequence < Element, ElementOps >::Operations::
  92. swap (INumber index1, INumber index2) const
  93. { Element e;
  94.   elementOps().assign (e, ((Node*)ivNodes) [index1].ivElement);
  95.   elementOps().assign
  96.     (((Node*)ivNodes) [index1].ivElement,
  97.      ((Node*)ivNodes) [index2].ivElement);
  98.   elementOps().assign (((Node*)ivNodes) [index2].ivElement, e);
  99. }
  100.  
  101. template < class Element, class ElementOps >
  102. IBoolean IGDilutedSequence < Element, ElementOps >::Operations::
  103. constantFunctionIteration (void *iterationFunction,
  104.                            void* env,
  105.                            INumber index) const
  106. { return (*(IBoolean (*) (Element const&, void*)) iterationFunction)
  107.            (((Node*)ivNodes) [index].ivElement, env);
  108. }
  109.  
  110. template < class Element, class ElementOps >
  111. IBoolean IGDilutedSequence < Element, ElementOps >::Operations::
  112. functionIteration (void *iterationFunction, void* env, INumber index)
  113. { return (*(IBoolean (*) (Element&, void*)) iterationFunction)
  114.            (((Node*)ivNodes) [index].ivElement, env);
  115. }
  116.  
  117. template < class Element, class ElementOps >
  118. IBoolean IGDilutedSequence < Element, ElementOps >::Operations::
  119. constantIteratorIteration (void* iterator, INumber index) const
  120. { return ((IConstantIterator < Element >*)iterator)->
  121.            applyTo (((Node*)ivNodes) [index].ivElement);
  122. }
  123.  
  124. template < class Element, class ElementOps >
  125. IBoolean IGDilutedSequence < Element, ElementOps >::Operations::
  126. iteratorIteration (void* iterator, INumber index)
  127. { return ((IIterator < Element >*)iterator)->
  128.            applyTo (((Node*)ivNodes) [index].ivElement);
  129. }
  130.  
  131. template < class Element, class ElementOps >
  132. long IGDilutedSequence < Element, ElementOps >::Operations::
  133. functionComparison (void *comparisonFunction,
  134.                     void const* element1,
  135.                     void const* element2)
  136. { return (*(long (*) (Element const&, Element const&) const)
  137.             comparisonFunction)
  138.            (*(Element*)element1, *(Element*)element2);
  139. }
  140.  
  141. template < class Element, class ElementOps >
  142. long IGDilutedSequence < Element, ElementOps >::Operations::
  143. functionComparison (void *comparisonFunction,
  144.                     INumber index1,
  145.                     INumber index2)
  146. { return (*(long (*) (Element const&, Element const&) const)
  147.             comparisonFunction)
  148.            (((Node*)ivNodes) [index1].ivElement,
  149.             ((Node*)ivNodes) [index2].ivElement);
  150. }
  151.  
  152. template < class Element, class ElementOps >
  153. void IGDilutedSequence < Element, ElementOps >::Operations::
  154. blockLeft (INumber lTarget, INumber lMoveCount)
  155. { for (INumber i = lTarget; lMoveCount > 0; i++, lMoveCount--)
  156.     ((Node*)ivNodes) [i] = ((Node*)ivNodes) [i+1];
  157. }
  158.  
  159. template < class Element, class ElementOps >
  160. void IGDilutedSequence < Element, ElementOps >::Operations::
  161. blockRight (INumber lTarget, INumber lMoveCount)
  162. { for (INumber i = lTarget + lMoveCount - 1; lMoveCount > 0; i--, lMoveCount--)
  163.     ((Node*)ivNodes) [i] = ((Node*)ivNodes) [i-1];
  164. }
  165.  
  166. template < class Element, class ElementOps >
  167. void IGDilutedSequence < Element, ElementOps >::Operations::
  168. compress ()
  169. { INumber from = ivFirst, to = ivFirst;
  170.   for (;;) {
  171.     if (from != to)
  172.       ((Node*)ivNodes) [to] = ((Node*)ivNodes) [from];
  173.     if (! setToNext (from))
  174.       break;
  175.     incMod (to);
  176.   }
  177.   ivLast = to;
  178. }
  179.  
  180. template < class Element, class ElementOps >
  181. void IGDilutedSequence < Element, ElementOps >::Operations::
  182. copy (IDilutedSequenceImpl::Table const& from)
  183. { if (from.ivNumberOfElements == 0)
  184.     return;
  185.   if (ivNumberOfElements > 0 &&
  186.       (ivFirst > ivLast ?
  187.         (ivFirst - ivLast - 1) :
  188.         (ivFirst + ivAllocatedElements - ivLast - 1))
  189.         < from.ivNumberOfElements)
  190.     compress ();
  191.   INumber toIndex = ivLast;
  192.   INumber fromIndex = from.ivFirst;
  193.   for (;;) {
  194.     incMod (toIndex);
  195.     ((Node*)ivNodes) [toIndex] = ((Node*)from.ivNodes) [fromIndex];
  196.     if (fromIndex == from.ivLast)
  197.       break;
  198.     do
  199.       from.incMod (fromIndex);
  200.     while (((Node*)from.ivNodes) [fromIndex].ivIsRemoved);
  201.   }
  202.   ivNumberOfElements += from.ivNumberOfElements;
  203.   ivLast = toIndex;
  204. }
  205.  
  206. template < class Element, class ElementOps >
  207. void IGDilutedSequence < Element, ElementOps >::Operations::
  208. expand (INumber n)
  209. { n += ivNumberOfElements;
  210.  
  211.   INumber newAllocatedElements = ivAllocatedElements;
  212.   while (newAllocatedElements < n)
  213.     newAllocatedElements *= 2;
  214.   Node* newNodes = new Node [newAllocatedElements];
  215.   ICHECK (newNodes != 0, IOutOfMemory, IOutOfMemoryText)
  216.  
  217.   IDilutedSequenceImpl::Table tab = *this;
  218.   (Node*&)ivNodes = newNodes;
  219.   ivAllocatedElements = newAllocatedElements;
  220.   ivFirst = 0;
  221.   ivLast = ivAllocatedElements - 1;
  222.   ivNumberOfElements = 0;
  223.   copy (tab);
  224.   delete[] (Node*)tab.ivNodes;
  225. }
  226.  
  227. template < class Element, class ElementOps >
  228. void IGDilutedSequence < Element, ElementOps >::Operations::
  229. makeFree (INumber& index)
  230. { INumber leftFree = index;
  231.   while (leftFree > 0 && ! ((Node*)ivNodes) [leftFree].ivIsRemoved) {
  232.     if (leftFree == ivFirst && leftFree - 1 != ivLast)
  233.       ((Node*)ivNodes) [leftFree - 1].ivIsRemoved = True;
  234.     leftFree--;
  235.   }
  236.   if (index - leftFree <= 1 && ((Node*)ivNodes) [leftFree].ivIsRemoved) {
  237.     index = leftFree;
  238.     return;
  239.   }
  240.   INumber rightFree = index;
  241.   while (rightFree < ivAllocatedElements - 1 &&
  242.          ! ((Node*)ivNodes) [rightFree].ivIsRemoved) {
  243.     if (rightFree == ivLast && rightFree + 1 != ivFirst)
  244.       ((Node*)ivNodes) [rightFree + 1].ivIsRemoved = True;
  245.     rightFree++;
  246.   }
  247.   if (! ((Node*)ivNodes) [leftFree].ivIsRemoved ||
  248.       (index - leftFree > rightFree - index &&
  249.        ((Node*)ivNodes) [rightFree].ivIsRemoved)) {
  250.     blockRight (index + 1, rightFree - (index + 1) + 1);
  251.     if (index <= ivFirst && ivFirst < rightFree) ivFirst++;
  252.     if (index <= ivLast && ivLast < rightFree) ivLast++;
  253.   }
  254.   else {
  255.     blockLeft (leftFree, (index - 1) - (leftFree + 1) + 1);
  256.     if (leftFree < ivFirst && ivFirst < index) ivFirst--;
  257.     if (leftFree < ivLast && ivLast < index) ivLast--;
  258.     index--;
  259.   }
  260. }
  261.