home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / IBMCLASS / ITBSEQ.IF < prev    next >
Text File  |  1993-09-22  |  14KB  |  424 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. inline void IGTabularSequence < Element, ElementOps >::
  16. checkNotEmpty () const
  17. {
  18. #ifndef INO_CHECKS
  19.   ICHECK (!isEmpty (), IEmptyException, ICollectionIsEmptyText)
  20. #endif
  21. }
  22.  
  23. template < class Element, class ElementOps >
  24. inline void IGTabularSequence < Element, ElementOps >::
  25. checkCursorIsForThis (ICursor const& cursor) const
  26. {
  27. #ifndef INO_CHECKS
  28.   ICHECK (((Cursor const&)cursor).isFor (*this),
  29.           ICursorInvalidException, ICursorNotForThisText)
  30. #endif
  31. }
  32.  
  33. template < class Element, class ElementOps >
  34. inline void IGTabularSequence < Element, ElementOps >::
  35. checkCursor (ICursor const& cursor) const
  36. {
  37. #ifndef INO_CHECKS
  38.   ICHECK (((Cursor const&)cursor).isFor (*this),
  39.           ICursorInvalidException, ICursorNotForThisText)
  40.   ICHECK (cursor.isValid (), ICursorInvalidException, IInvalidCursorText)
  41.   ICHECK (ivImpl.checkIndex (((Cursor const&)cursor).ivImpl.ivIndex),
  42.           ICursorInvalidException, ICursorNotContainedText)
  43. #endif
  44. }
  45.  
  46. template < class Element, class ElementOps >
  47. inline void IGTabularSequence < Element, ElementOps >::
  48. checkPositionExists (IPosition position) const
  49. {
  50. #ifndef INO_CHECKS
  51.   ICHECK (1 <= position && position <= numberOfElements(),
  52.           IPositionInvalidException, IInvalidPositionText)
  53. #endif
  54. }
  55.  
  56. template < class Element, class ElementOps >
  57. inline void IGTabularSequence < Element, ElementOps >::
  58. checkPositionForAdd (IPosition position) const
  59. {
  60. #ifndef INO_CHECKS
  61.   ICHECK (1 <= position && position <= numberOfElements() + 1,
  62.           IPositionInvalidException, IInvalidPositionText)
  63. #endif
  64. }
  65.  
  66. template <class Element, class ElementOps>
  67. inline IGTabularSequence <Element, ElementOps>::
  68. IGTabularSequence (INumber n)
  69. : ivImpl (&ivOps)
  70. { if (n == 0) n++;
  71.   Node* newNodes = new Node [n];
  72.   ICHECK (newNodes != 0, IOutOfMemory, IOutOfMemoryText)
  73.   ivOps.ivAllocatedElements = n;
  74.   ivOps.ivLast = ivOps.ivAllocatedElements - 1;
  75.   ivOps.ivFirst = ivOps.ivNumberOfElements = 0;
  76.   (Node*&)ivOps.ivNodes = newNodes;
  77. }
  78.  
  79. template <class Element, class ElementOps>
  80. inline IGTabularSequence <Element, ElementOps>::
  81. IGTabularSequence (IGTabularSequence < Element, ElementOps > const& sequence)
  82. : ivImpl (&ivOps)
  83. { Node* newNodes = new Node [sequence.ivOps.ivAllocatedElements];
  84.   ICHECK (newNodes != 0, IOutOfMemory, IOutOfMemoryText)
  85.   ivOps.ivAllocatedElements = sequence.ivOps.ivAllocatedElements;
  86.   ivOps.ivLast = ivOps.ivAllocatedElements - 1;
  87.   ivOps.ivFirst = ivOps.ivNumberOfElements = 0;
  88.   (Node*&)ivOps.ivNodes = newNodes;
  89.   ivOps.copy (sequence.ivOps);
  90. }
  91.  
  92. template <class Element, class ElementOps>
  93. inline IGTabularSequence <Element, ElementOps>::
  94. ~IGTabularSequence ()
  95. { delete[] (Node*) ivOps.ivNodes;
  96. }
  97.  
  98. template <class Element, class ElementOps>
  99. inline IBoolean IGTabularSequence <Element, ElementOps>::
  100. add (Element const& element, ICursor& cursor)
  101. { addAsLast (element, cursor);
  102.   return True;
  103. }
  104.  
  105. template <class Element, class ElementOps>
  106. inline IBoolean IGTabularSequence <Element, ElementOps>::
  107. add (Element const& element)
  108. { Cursor cursor (*this);
  109.   return add (element, cursor);
  110. }
  111.  
  112. template <class Element, class ElementOps>
  113. inline void IGTabularSequence <Element, ElementOps>::
  114. addAllFrom (IGTabularSequence < Element, ElementOps > const& sequence)
  115. {
  116. #ifndef INO_CHECKS
  117.   ICHECK (this != &sequence,
  118.           IIdenticalCollectionException, IIdenticalCollectionText)
  119. #endif
  120.   ivImpl.addAllFrom (sequence.ivImpl);
  121. }
  122.  
  123. template <class Element, class ElementOps>
  124. inline Element const& IGTabularSequence <Element, ElementOps>::
  125. elementAt (ICursor const& cursor) const
  126. { checkCursor (cursor);
  127.   return ((Node*)ivOps.ivNodes)
  128.            [((Cursor const&)cursor).ivImpl.ivIndex].ivElement;
  129. }
  130.  
  131. template <class Element, class ElementOps>
  132. inline Element& IGTabularSequence <Element, ElementOps>::
  133. elementAt (ICursor const& cursor)
  134. { checkCursor (cursor);
  135.   return ((Node*) ivOps.ivNodes)
  136.            [((Cursor const&)cursor).ivImpl.ivIndex].ivElement;
  137. }
  138.  
  139. template <class Element, class ElementOps>
  140. inline Element const& IGTabularSequence <Element, ElementOps>::
  141. anyElement () const
  142. { return firstElement ();
  143. }
  144.  
  145. template <class Element, class ElementOps>
  146. inline void IGTabularSequence <Element, ElementOps>::
  147. removeAt (ICursor const& cursor)
  148. { checkCursor (cursor);
  149.   INumber index = ((Cursor&)cursor).ivImpl.ivIndex;
  150.   ivImpl.removeAt (index);
  151. }
  152.  
  153. template < class Element, class ElementOps >
  154. inline INumber IGTabularSequence < Element, ElementOps >::
  155. removeAll (IBoolean (*predicate) (Element const&, void*), void* env)
  156. { return ivImpl.removeAll (predicate, env);
  157. }
  158.  
  159. template <class Element, class ElementOps>
  160. inline void IGTabularSequence <Element, ElementOps>::
  161. replaceAt (ICursor const& cursor, Element const& element)
  162. { checkCursor (cursor);
  163.   elementOps().assign
  164.     (((Node*) ivOps.ivNodes)
  165.        [((Cursor const&)cursor).ivImpl.ivIndex].ivElement,
  166.      element);
  167. }
  168.  
  169. template <class Element, class ElementOps>
  170. inline void IGTabularSequence <Element, ElementOps>::
  171. removeAll ()
  172. { ivOps.ivLast = ivOps.ivAllocatedElements - 1;
  173.   ivOps.ivFirst = ivOps.ivNumberOfElements = 0;
  174. }
  175.  
  176. template <class Element, class ElementOps>
  177. inline IBoolean IGTabularSequence <Element, ElementOps>::
  178. isBounded () const
  179. { return False;
  180. }
  181.  
  182. template <class Element, class ElementOps>
  183. inline INumber IGTabularSequence <Element, ElementOps>::
  184. maxNumberOfElements () const
  185. { ICHECK (False, INotBoundedException,
  186.           INotBoundedText)
  187.   return 0;
  188. }
  189.  
  190. template <class Element, class ElementOps>
  191. inline INumber IGTabularSequence <Element, ElementOps>::
  192. numberOfElements () const
  193. { return ivOps.ivNumberOfElements;
  194. }
  195.  
  196. template <class Element, class ElementOps>
  197. inline IBoolean IGTabularSequence <Element, ElementOps>::
  198. isEmpty () const
  199. { return ivOps.ivNumberOfElements == 0;
  200. }
  201.  
  202. template <class Element, class ElementOps>
  203. inline IBoolean IGTabularSequence <Element, ElementOps>::
  204. isFull () const
  205. { return False;
  206. }
  207.  
  208. template <class Element, class ElementOps>
  209. inline ICursor* IGTabularSequence <Element, ElementOps>::
  210. newCursor () const
  211. { ICursor* result = new Cursor (*this);
  212.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  213.   return result;
  214. }
  215.  
  216. template <class Element, class ElementOps>
  217. inline IBoolean IGTabularSequence <Element, ElementOps>::
  218. setToFirst (ICursor& cursor) const
  219. { checkCursorIsForThis (cursor);
  220.   return ivImpl.setToFirst (((Cursor&)cursor).ivImpl);
  221. }
  222.  
  223. template <class Element, class ElementOps>
  224. inline IBoolean IGTabularSequence <Element, ElementOps>::
  225. setToNext (ICursor& cursor) const
  226. { checkCursor (cursor);
  227.   return ivImpl.setToNext (((Cursor&)cursor).ivImpl);
  228. }
  229.  
  230. template <class Element, class ElementOps>
  231. inline IBoolean IGTabularSequence <Element, ElementOps>::
  232. allElementsDo (IBoolean (*function) (Element&, void*), void* env)
  233. { return ivImpl.allElementsDo (function, env);
  234. }
  235.  
  236. template <class Element, class ElementOps>
  237. inline IBoolean IGTabularSequence <Element, ElementOps>::
  238. allElementsDo (IIterator < Element > & iterator)
  239. { return ivImpl.allElementsDo (&iterator);
  240. }
  241.  
  242. template <class Element, class ElementOps>
  243. inline IBoolean IGTabularSequence <Element, ElementOps>::
  244. allElementsDo (IBoolean (*function) (Element const&, void*),
  245.                void* env) const
  246. { return ivImpl.allElementsDo (function, env);
  247. }
  248.  
  249. template <class Element, class ElementOps>
  250. inline IBoolean IGTabularSequence <Element, ElementOps>::
  251. allElementsDo (IConstantIterator < Element > & iterator) const
  252. { return ivImpl.allElementsDo (&iterator);
  253. }
  254.  
  255. template <class Element, class ElementOps>
  256. inline IBoolean IGTabularSequence <Element, ElementOps>::
  257. isConsistent () const
  258. { return ivImpl.isConsistent ();
  259. }
  260.  
  261. template <class Element, class ElementOps>
  262. inline IGTabularSequence <Element, ElementOps>&
  263. IGTabularSequence <Element, ElementOps>::
  264. operator = (IGTabularSequence < Element, ElementOps > const& sequence)
  265. { ivImpl.operator= (sequence.ivImpl);
  266.   return *this;
  267. }
  268.  
  269. template <class Element, class ElementOps>
  270. inline void IGTabularSequence <Element, ElementOps>::
  271. removeFirst ()
  272. { checkNotEmpty ();
  273.   INumber index = ivOps.ivFirst;
  274.   ivImpl.removeAt (index);
  275. }
  276.  
  277. template <class Element, class ElementOps>
  278. inline void IGTabularSequence <Element, ElementOps>::
  279. removeLast ()
  280. { checkNotEmpty ();
  281.   INumber index = ivOps.ivLast;
  282.   ivImpl.removeAt (index);
  283. }
  284.  
  285. template <class Element, class ElementOps>
  286. inline void IGTabularSequence <Element, ElementOps>::
  287. removeAtPosition (IPosition position)
  288. { checkPositionExists (position);
  289.   ITabularSequenceImpl::Cursor cursor;
  290.   ivImpl.setToPosition (position, cursor);
  291.   ivImpl.removeAt (cursor.ivIndex);
  292. }
  293.  
  294. template <class Element, class ElementOps>
  295. inline Element const& IGTabularSequence <Element, ElementOps>::
  296. firstElement () const
  297. { checkNotEmpty ();
  298.   return ((Node*) ivOps.ivNodes) [ivOps.ivFirst].ivElement;
  299. }
  300.  
  301. template <class Element, class ElementOps>
  302. inline Element const& IGTabularSequence <Element, ElementOps>::
  303. lastElement () const
  304. { checkNotEmpty ();
  305.   return ((Node*) ivOps.ivNodes) [ivOps.ivLast].ivElement;
  306. }
  307.  
  308. template <class Element, class ElementOps>
  309. inline Element const& IGTabularSequence <Element, ElementOps>::
  310. elementAtPosition (IPosition position) const
  311. { checkPositionExists (position);
  312.   ITabularSequenceImpl::Cursor cursor;
  313.   ivImpl.setToPosition (position, cursor);
  314.   return ((Node*) ivOps.ivNodes) [cursor.ivIndex].ivElement;
  315. }
  316.  
  317. template <class Element, class ElementOps>
  318. inline IBoolean IGTabularSequence <Element, ElementOps>::
  319. setToLast (ICursor& cursor) const
  320. { checkCursorIsForThis (cursor);
  321.   return ivImpl.setToLast (((Cursor&)cursor).ivImpl);
  322. }
  323.  
  324. template <class Element, class ElementOps>
  325. inline IBoolean IGTabularSequence <Element, ElementOps>::
  326. setToPrevious (ICursor& cursor) const
  327. { checkCursor (cursor);
  328.   return ivImpl.setToPrevious (((Cursor&)cursor).ivImpl);
  329. }
  330.  
  331. template <class Element, class ElementOps>
  332. inline void IGTabularSequence <Element, ElementOps>::
  333. setToPosition (IPosition position, ICursor& cursor) const
  334. { checkPositionExists (position);
  335.   checkCursorIsForThis (cursor);
  336.   ivImpl.setToPosition (position, ((Cursor&)cursor).ivImpl);
  337. }
  338.  
  339. template <class Element, class ElementOps>
  340. inline IBoolean IGTabularSequence <Element, ElementOps>::
  341. isFirst (ICursor const& cursor) const
  342. { checkCursor (cursor);
  343.   return ((Cursor const&)cursor).ivImpl.ivIndex == ivOps.ivFirst;
  344. }
  345.  
  346. template <class Element, class ElementOps>
  347. inline IBoolean IGTabularSequence <Element, ElementOps>::
  348. isLast (ICursor const& cursor) const
  349. { checkCursor (cursor);
  350.   return ((Cursor const&)cursor).ivImpl.ivIndex == ivOps.ivLast;
  351. }
  352.  
  353. template <class Element, class ElementOps>
  354. inline long IGTabularSequence <Element, ElementOps>::
  355. compare (IGTabularSequence < Element, ElementOps > const& sequence,
  356.           long (*comparisonFunction) (Element const&, Element const&)) const {
  357.   return ivImpl.compare (sequence.ivImpl, comparisonFunction);
  358. }
  359.  
  360. template <class Element, class ElementOps>
  361. inline void IGTabularSequence <Element, ElementOps>::
  362. addAsFirst (Element const& element)
  363. { Cursor cursor (*this);
  364.   addAsFirst (element, cursor);
  365. }
  366.  
  367. template <class Element, class ElementOps>
  368. inline void IGTabularSequence <Element, ElementOps>::
  369. addAsFirst (Element const& element, ICursor& cursor)
  370. { checkCursorIsForThis (cursor);
  371.   ivImpl.addAsFirst (&element, ((Cursor&)cursor).ivImpl);
  372. }
  373.  
  374. template <class Element, class ElementOps>
  375. inline void IGTabularSequence <Element, ElementOps>::
  376. addAsLast (Element const& element)
  377. { Cursor cursor (*this);
  378.   addAsLast (element, cursor);
  379. }
  380.  
  381. template <class Element, class ElementOps>
  382. inline void IGTabularSequence <Element, ElementOps>::
  383. addAsLast (Element const& element, ICursor& cursor)
  384. { checkCursorIsForThis (cursor);
  385.   ivImpl.addAsLast (&element, ((Cursor&)cursor).ivImpl);
  386. }
  387.  
  388. template <class Element, class ElementOps>
  389. inline void IGTabularSequence <Element, ElementOps>::
  390. addAsNext (Element const& element, ICursor& cursor)
  391. { checkCursor (cursor);
  392.   ivImpl.addAsNext (&element, ((Cursor&)cursor).ivImpl);
  393. }
  394.  
  395. template <class Element, class ElementOps>
  396. inline void IGTabularSequence <Element, ElementOps>::
  397. addAsPrevious (Element const& element, ICursor& cursor)
  398. { checkCursor (cursor);
  399.   ivImpl.addAsPrevious (&element, ((Cursor&)cursor).ivImpl);
  400. }
  401.  
  402. template <class Element, class ElementOps>
  403. inline void IGTabularSequence <Element, ElementOps>::
  404. addAtPosition (IPosition position, Element const& element)
  405. { Cursor cursor (*this);
  406.   addAtPosition (position, element, cursor);
  407. }
  408.  
  409. template <class Element, class ElementOps>
  410. inline void IGTabularSequence <Element, ElementOps>::
  411. addAtPosition (IPosition position,
  412.                Element const& element,
  413.                ICursor& cursor)
  414. { checkPositionForAdd (position);
  415.   checkCursorIsForThis (cursor);
  416.   ivImpl.addAtPosition (position, &element, ((Cursor&)cursor).ivImpl);
  417. }
  418.  
  419. template <class Element, class ElementOps>
  420. inline void IGTabularSequence <Element, ElementOps>::
  421. sort (long (*comparisonFunction) (Element const&, Element const&))
  422. { ivImpl.sort (comparisonFunction);
  423. }
  424.