home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / IBMCLASS / ITBTRE.IF < prev    next >
Text File  |  1993-09-22  |  22KB  |  542 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, INumber pNumberOfChildren >
  15. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  16. checkCursorIsForThis (ITreeCursor const& cursor) const
  17. {
  18. #ifndef INO_CHECKS
  19.   ICHECK (((Cursor const&)cursor).isFor (*this),
  20.           ICursorInvalidException, ICursorNotForThisText)
  21. #endif
  22. }
  23.  
  24. template < class Element, class ElementOps, INumber pNumberOfChildren >
  25. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  26. checkCursor (ITreeCursor const& cursor) const
  27. {
  28. #ifndef INO_CHECKS
  29.   ICHECK (((Cursor const&)cursor).isFor (*this),
  30.           ICursorInvalidException, ICursorNotForThisText)
  31.   ICHECK (cursor.isValid (), ICursorInvalidException, IInvalidCursorText)
  32. #endif
  33. #ifdef IALL_CHECKS
  34.   ICHECK (ivImpl.checkNode(((Cursor const&)cursor).ivNode),
  35.           ICursorInvalidException, ICursorNotContainedText)
  36. #endif
  37. }
  38.  
  39. template < class Element, class ElementOps, INumber pNumberOfChildren >
  40. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  41. checkCursorOfTree (IGTabularTree < Element,
  42.                                    ElementOps,
  43.                                    pNumberOfChildren > const& tree,
  44.                    ITreeCursor const& cursor) const
  45. {
  46. #ifndef INO_CHECKS
  47.   ICHECK (((Cursor const&)cursor).ivCollection == &tree,
  48.           ICursorInvalidException, ICursorNotForGivenText)
  49.   ICHECK (cursor.isValid (), ICursorInvalidException, IInvalidCursorText)
  50. #endif
  51. #ifdef IALL_CHECKS
  52.   ICHECK (tree.ivImpl.checkNode(((Cursor const&)cursor).ivNode),
  53.           ICursorInvalidException, ICursorNotContainedText)
  54. #endif
  55. }
  56.  
  57. template < class Element, class ElementOps, INumber pNumberOfChildren >
  58. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  59. checkPosition (IPosition position) const
  60. {
  61. #ifndef INO_CHECKS
  62.   ICHECK (1 <= position && position <= pNumberOfChildren,
  63.           IPositionInvalidException, IInvalidPositionText)
  64. #endif
  65. }
  66.  
  67. template < class Element, class ElementOps, INumber pNumberOfChildren >
  68. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  69. checkRootNotExists () const
  70. {
  71. #ifndef INO_CHECKS
  72.   ICHECK (ivImpl.ivRoot == 0,
  73.           IRootAlreadyExistsException, IRootAlreadyExistsText)
  74. #endif
  75. }
  76.  
  77. template < class Element, class ElementOps, INumber pNumberOfChildren >
  78. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  79. checkChildNotExists (ITabularTreeImpl::Node* n) const
  80. {
  81. #ifndef INO_CHECKS
  82.   ICHECK (n == 0, IChildAlreadyExistsException, IChildAlreadyExistsText)
  83. #endif
  84. }
  85.  
  86. template < class Element, class ElementOps, int numberOfChildren >
  87. inline void IGTabularTree < Element, ElementOps, numberOfChildren >::
  88. copySubtree (Node* from)
  89. { if (from == 0)
  90.     ivImpl.ivRoot = 0;
  91.   else {
  92.     copySubtree ((Node*&)ivImpl.ivRoot, from);
  93.     ivImpl.ivRoot->ivParent = 0;
  94.   }
  95. }
  96.  
  97. template < class Element, class ElementOps, INumber pNumberOfChildren >
  98. inline IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  99. IGTabularTree ()
  100. : ivImpl (pNumberOfChildren)
  101. {
  102. }
  103.  
  104. template < class Element, class ElementOps, INumber pNumberOfChildren >
  105. inline IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  106. IGTabularTree (IGTabularTree < Element,
  107.                                ElementOps,
  108.                                pNumberOfChildren > const& tabularTree)
  109. : ivImpl (pNumberOfChildren)
  110. { copySubtree ((Node*)tabularTree.ivImpl.ivRoot);
  111. }
  112.  
  113. template < class Element, class ElementOps, INumber pNumberOfChildren >
  114. inline IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  115. ~IGTabularTree ()
  116. { removeAll ();
  117. }
  118.  
  119. template < class Element, class ElementOps, INumber pNumberOfChildren >
  120. inline IGTabularTree < Element, ElementOps, pNumberOfChildren >&
  121. IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  122. operator= (IGTabularTree < Element, ElementOps, pNumberOfChildren > const& tree)
  123. { copy (tree);
  124.   return *this;
  125. }
  126.  
  127. template < class Element, class ElementOps, INumber pNumberOfChildren >
  128. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  129. copy (IGTabularTree < Element, ElementOps, pNumberOfChildren > const& tree)
  130. { if (&tree != this)
  131.   { removeAll ();
  132.     copySubtree ((Node*)tree.ivImpl.ivRoot);
  133.   }
  134. }
  135.  
  136. template < class Element, class ElementOps, INumber pNumberOfChildren >
  137. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  138. copySubtree (IGTabularTree < Element,
  139.                              ElementOps,
  140.                              pNumberOfChildren > const& tree,
  141.              ITreeCursor const& cursor)
  142. { checkCursorOfTree (tree, cursor);
  143.   if (&tree != this) {
  144.     removeAll ();
  145.     copySubtree ((Node*)((Cursor const&)cursor).ivNode);
  146.   }
  147.   else {
  148.     IGTabularTree < Element, ElementOps, pNumberOfChildren > t;
  149.     t.attachSubtreeAsRoot (*this, cursor);
  150.     removeAll ();
  151.     attachAsRoot (t);
  152.   }
  153. }
  154.  
  155. template < class Element, class ElementOps, INumber pNumberOfChildren >
  156. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  157. addAsRoot (Element const& element)
  158. { checkRootNotExists ();
  159.   ivImpl.ivRoot = (ITabularTreeImpl::Node*) newNode (element);
  160.   ivImpl.initNode (ivImpl.ivRoot, 0);
  161. }
  162.  
  163. template < class Element, class ElementOps, INumber pNumberOfChildren >
  164. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  165. addAsChild (ITreeCursor const& cursor,
  166.             IPosition position,
  167.             Element const& element)
  168. { checkCursor (cursor);
  169.   checkPosition (position);
  170.   ITabularTreeImpl::Node* parent = ((Cursor const&)cursor).ivNode;
  171.   ITabularTreeImpl::Node*& child = parent->ivChildren [position-1];
  172.   checkChildNotExists (child);
  173.   child = (ITabularTreeImpl::Node*) newNode (element);
  174.   ivImpl.initNode (child, parent);
  175. }
  176.  
  177. template < class Element, class ElementOps, INumber pNumberOfChildren >
  178. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  179. attachAsRoot (IGTabularTree < Element, ElementOps, pNumberOfChildren >& tree)
  180. { checkRootNotExists ();
  181.   ivImpl.ivRoot = tree.ivImpl.ivRoot;
  182.   tree.ivImpl.ivRoot = 0;
  183. }
  184.  
  185. template < class Element, class ElementOps, INumber pNumberOfChildren >
  186. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  187. attachAsChild (ITreeCursor const& cursor, IPosition position,
  188.                IGTabularTree < Element, ElementOps, pNumberOfChildren >& tree)
  189. { checkCursor (cursor);
  190.   checkPosition (position);
  191.   ITabularTreeImpl::Node* parent = ((Cursor const&)cursor).ivNode;
  192.   ITabularTreeImpl::Node*& child = parent->ivChildren [position-1];
  193.   checkChildNotExists (child);
  194.   child = tree.ivImpl.ivRoot;
  195.   if (child != 0)
  196.     child->ivParent = parent;
  197.   tree.ivImpl.ivRoot = 0;
  198. }
  199.  
  200. template < class Element, class ElementOps, INumber pNumberOfChildren >
  201. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  202. attachSubtreeAsRoot (IGTabularTree < Element,
  203.                                      ElementOps,
  204.                                      pNumberOfChildren >& tree,
  205.                      ITreeCursor const& cursor)
  206. { checkCursorOfTree (tree, cursor);
  207.   checkRootNotExists ();
  208.   ITabularTreeImpl::Node* node = ((Cursor const&)cursor).ivNode;
  209.   ivImpl.attachSubtreeAsRoot (tree.ivImpl, node);
  210. }
  211.  
  212. template < class Element, class ElementOps, INumber pNumberOfChildren >
  213. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  214. attachSubtreeAsChild (ITreeCursor const& cursorTo,
  215.                       IPosition pos,
  216.                       IGTabularTree < Element,
  217.                                       ElementOps,
  218.                                       pNumberOfChildren >& tree,
  219.                       ITreeCursor const& cursorFrom)
  220. { checkCursorOfTree (tree, cursorFrom);
  221.   checkCursor (cursorTo);
  222.   checkPosition (pos);
  223.   ITabularTreeImpl::Node* parent = ((Cursor const&)cursorTo).ivNode;
  224.   ITabularTreeImpl::Node*& child = parent->ivChildren [pos-1];
  225.   checkChildNotExists (child);
  226.   ITabularTreeImpl::Node* nodeFrom = ((Cursor const&)cursorFrom).ivNode;
  227.   ivImpl.attachSubtreeAsChild (parent, pos, tree.ivImpl, nodeFrom);
  228. }
  229.  
  230. template < class Element, class ElementOps, INumber pNumberOfChildren >
  231. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  232. removeAll ()
  233. { INumber result;
  234.   if (ivImpl.ivRoot != 0) {
  235.     result = removeSubtree ((Node*)ivImpl.ivRoot);
  236.     ivImpl.ivRoot = 0;
  237.   }
  238.   else
  239.     result = 0;
  240.   return result;
  241. }
  242.  
  243. template < class Element, class ElementOps, INumber pNumberOfChildren >
  244. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  245. removeSubtree (ITreeCursor const& cursor)
  246. { checkCursor (cursor);
  247.   ITabularTreeImpl::Node* node = ((Cursor const&)cursor).ivNode;
  248.   if (node->ivParent == 0)
  249.     ivImpl.ivRoot = 0;
  250.   else
  251.     node->ivParent->ivChildren [position (cursor) - 1] = 0;
  252.   return removeSubtree ((Node*)node);
  253. }
  254.  
  255. template < class Element, class ElementOps, INumber pNumberOfChildren >
  256. inline Element const& IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  257. elementAt (ITreeCursor const& cursor) const
  258. { checkCursor (cursor);
  259.   return ((Node*)((Cursor const&)cursor).ivNode)->ivElement;
  260. }
  261.  
  262. template < class Element, class ElementOps, INumber pNumberOfChildren >
  263. inline Element& IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  264. elementAt (ITreeCursor const& cursor)
  265. { checkCursor (cursor);
  266.   return ((Node*)((Cursor const&)cursor).ivNode)->ivElement;
  267. }
  268.  
  269. template < class Element, class ElementOps, INumber pNumberOfChildren >
  270. inline void IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  271. replaceAt (ITreeCursor const& cursor, Element const& element)
  272. { checkCursor (cursor);
  273.   elementOps().assign
  274.     (((Node*)((Cursor const&)cursor).ivNode)->ivElement, element);
  275. }
  276.  
  277. template < class Element, class ElementOps, INumber pNumberOfChildren >
  278. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  279. numberOfChildren () const
  280. { return pNumberOfChildren;
  281. }
  282.  
  283. template < class Element, class ElementOps, INumber pNumberOfChildren >
  284. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  285. numberOfElements () const
  286. { if (ivImpl.ivRoot == 0)
  287.     return 0;
  288.   else
  289.     return ivImpl.numberOfSubtreeElements (ivImpl.ivRoot);
  290. }
  291.  
  292. template < class Element, class ElementOps, INumber pNumberOfChildren >
  293. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  294. numberOfSubtreeElements (ITreeCursor const& cursor) const
  295. { checkCursor (cursor);
  296.   return ivImpl.numberOfSubtreeElements (((Cursor const&)cursor).ivNode);
  297. }
  298.  
  299. template < class Element, class ElementOps, INumber pNumberOfChildren >
  300. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  301. numberOfLeaves () const
  302. { if (ivImpl.ivRoot == 0)
  303.     return 0;
  304.   else
  305.     return ivImpl.numberOfSubtreeLeaves (ivImpl.ivRoot);
  306. }
  307.  
  308. template < class Element, class ElementOps, INumber pNumberOfChildren >
  309. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  310. numberOfSubtreeLeaves (ITreeCursor const& cursor) const
  311. { checkCursor (cursor);
  312.   return ivImpl.numberOfSubtreeLeaves (((Cursor const&)cursor).ivNode);
  313. }
  314.  
  315. template < class Element, class ElementOps, INumber pNumberOfChildren >
  316. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  317. isEmpty () const
  318. { return ivImpl.ivRoot == 0;
  319. }
  320.  
  321. template < class Element, class ElementOps, INumber pNumberOfChildren >
  322. inline ITreeCursor* IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  323. newCursor () const
  324. { ITreeCursor* result = new Cursor (*this);
  325.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  326.   return result;
  327. }
  328.  
  329. template < class Element, class ElementOps, INumber pNumberOfChildren >
  330. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  331. isRoot (ITreeCursor const& cursor) const
  332. { checkCursor (cursor);
  333.   return ivImpl.ivRoot == ((Cursor const&)cursor).ivNode;
  334. }
  335.  
  336. template < class Element, class ElementOps, INumber pNumberOfChildren >
  337. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  338. isLeaf (ITreeCursor const& cursor) const
  339. { checkCursor (cursor);
  340.   return ivImpl.isLeaf (((Cursor const&)cursor).ivNode);
  341. }
  342.  
  343. template < class Element, class ElementOps, INumber pNumberOfChildren >
  344. inline INumber IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  345. position (ITreeCursor const& cursor) const
  346. { checkCursor (cursor);
  347.   return ivImpl.position (((Cursor const&)cursor).ivNode);
  348. }
  349.  
  350. template < class Element, class ElementOps, INumber pNumberOfChildren >
  351. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  352. hasChild (IPosition position, ITreeCursor const& cursor) const
  353. { checkCursor (cursor);
  354.   checkPosition (position);
  355.   return (((Cursor const&)cursor).ivNode)->ivChildren [position-1] != 0;
  356. }
  357.  
  358. template < class Element, class ElementOps, INumber pNumberOfChildren >
  359. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  360. setToRoot (ITreeCursor& cursor) const
  361. { checkCursorIsForThis (cursor);
  362.   ((Cursor&)cursor).ivNode = (ITabularTreeImpl::Node*)ivImpl.ivRoot;
  363.   return ivImpl.ivRoot != 0;
  364. }
  365.  
  366. template < class Element, class ElementOps, INumber pNumberOfChildren >
  367. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  368. setToChild (IPosition position, ITreeCursor& cursor) const
  369. { checkCursor (cursor);
  370.   checkPosition (position);
  371.   ITabularTreeImpl::Node* node = ((Cursor const&)cursor).ivNode;
  372.   ((Cursor&)cursor).ivNode = node->ivChildren [position-1];
  373.   return ((Cursor const&)cursor).ivNode != 0;
  374. }
  375.  
  376. template < class Element, class ElementOps, INumber pNumberOfChildren >
  377. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  378. setToParent (ITreeCursor& cursor) const
  379. { checkCursor (cursor);
  380.   return ivImpl.setToParent (((Cursor&)cursor).ivNode);
  381. }
  382.  
  383. template < class Element, class ElementOps, INumber pNumberOfChildren >
  384. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  385. setToFirstExistingChild (ITreeCursor& cursor) const
  386. { checkCursor (cursor);
  387.   return ivImpl.setToFirstExistingChild (((Cursor&)cursor).ivNode);
  388. }
  389.  
  390. template < class Element, class ElementOps, INumber pNumberOfChildren >
  391. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  392. setToNextExistingChild (ITreeCursor& cursor) const
  393. { checkCursor (cursor);
  394.   return ivImpl.setToNextExistingChild (((Cursor&)cursor).ivNode);
  395. }
  396.  
  397. template < class Element, class ElementOps, INumber pNumberOfChildren >
  398. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  399. setToLastExistingChild (ITreeCursor& cursor) const
  400. { checkCursor (cursor);
  401.   return ivImpl.setToLastExistingChild (((Cursor&)cursor).ivNode);
  402. }
  403.  
  404. template < class Element, class ElementOps, INumber pNumberOfChildren >
  405. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  406. setToPreviousExistingChild (ITreeCursor& cursor) const
  407. { checkCursor (cursor);
  408.   return ivImpl.setToPreviousExistingChild (((Cursor&)cursor).ivNode);
  409. }
  410.  
  411. template < class Element, class ElementOps, INumber pNumberOfChildren >
  412. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  413. setToFirst (ITreeCursor& cursor, ITreeIterationOrder order) const
  414. { checkCursorIsForThis (cursor);
  415.   return ivImpl.setToFirst (((Cursor&)cursor).ivNode, order);
  416. }
  417.  
  418. template < class Element, class ElementOps, INumber pNumberOfChildren >
  419. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  420. setToNext (ITreeCursor& cursor, ITreeIterationOrder order) const
  421. { checkCursorIsForThis (cursor);
  422.   return ivImpl.setToNext (((Cursor&)cursor).ivNode, order);
  423. }
  424.  
  425. template < class Element, class ElementOps, INumber pNumberOfChildren >
  426. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  427. setToLast (ITreeCursor& cursor, ITreeIterationOrder order) const
  428. { checkCursorIsForThis (cursor);
  429.   return ivImpl.setToLast (((Cursor&)cursor).ivNode, order);
  430. }
  431.  
  432. template < class Element, class ElementOps, INumber pNumberOfChildren >
  433. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  434. setToPrevious (ITreeCursor& cursor, ITreeIterationOrder order) const
  435. { checkCursorIsForThis (cursor);
  436.   return ivImpl.setToPrevious (((Cursor&)cursor).ivNode, order);
  437. }
  438.  
  439. template < class Element, class ElementOps, INumber pNumberOfChildren >
  440. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  441. allElementsDo (IBoolean (*function) (Element&, void*),
  442.                ITreeIterationOrder order,
  443.                void* additionalArgument)
  444. { if (ivImpl.ivRoot == 0)
  445.     return True;
  446.   else
  447.     return ivImpl.allElementsDo (function, order, additionalArgument,
  448.                                  functionIteration, ivImpl.ivRoot);
  449. }
  450.  
  451. template < class Element, class ElementOps, INumber pNumberOfChildren >
  452. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  453. allElementsDo (IIterator <Element>& iterator, ITreeIterationOrder order)
  454. { if (ivImpl.ivRoot == 0)
  455.     return True;
  456.   else
  457.     return ivImpl.allElementsDo (&iterator, order,
  458.                                  iteratorIteration, ivImpl.ivRoot);
  459. }
  460.  
  461. template < class Element, class ElementOps, INumber pNumberOfChildren >
  462. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  463. allElementsDo (IBoolean (*function) (Element const&, void*),
  464.                ITreeIterationOrder order,
  465.                void* additionalArgument) const
  466. { if (ivImpl.ivRoot == 0)
  467.     return True;
  468.   else
  469.     return ivImpl.allElementsDo (function, order, additionalArgument,
  470.                                  constantFunctionIteration, ivImpl.ivRoot);
  471. }
  472.  
  473. template < class Element, class ElementOps, INumber pNumberOfChildren >
  474. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  475. allElementsDo (IConstantIterator <Element>& iterator,
  476.                ITreeIterationOrder order) const
  477. { if (ivImpl.ivRoot == 0)
  478.     return True;
  479.   else
  480.     return ivImpl.allElementsDo (&iterator, order,
  481.                                  constantIteratorIteration, ivImpl.ivRoot);
  482. }
  483.  
  484. template < class Element, class ElementOps, INumber pNumberOfChildren >
  485. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  486. isConsistent () const
  487. { return ivImpl.isConsistent ();
  488. }
  489.  
  490. template < class Element, class ElementOps, INumber pNumberOfChildren >
  491. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  492. allSubtreeElementsDo (ITreeCursor const& cursor,
  493.                       IBoolean (*function) (Element&, void*),
  494.                       ITreeIterationOrder order,
  495.                       void* additionalArgument)
  496. { checkCursor (cursor);
  497.   return ivImpl.allElementsDo
  498.     (function, order, additionalArgument,
  499.      functionIteration, ((Cursor const&)cursor).ivNode);
  500. }
  501.  
  502. template < class Element, class ElementOps, INumber pNumberOfChildren >
  503. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  504. allSubtreeElementsDo (ITreeCursor const& cursor,
  505.                       IIterator <Element>& iterator,
  506.                       ITreeIterationOrder order)
  507. { checkCursor (cursor);
  508.   return ivImpl.allElementsDo (&iterator, order, iteratorIteration,
  509.                                ((Cursor const&)cursor).ivNode);
  510. }
  511.  
  512. template < class Element, class ElementOps, INumber pNumberOfChildren >
  513. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  514. allSubtreeElementsDo (ITreeCursor const& cursor,
  515.                       IBoolean (*function) (Element const&, void*),
  516.                       ITreeIterationOrder order,
  517.                       void* additionalArgument) const
  518. { checkCursor (cursor);
  519.   return ivImpl.allElementsDo
  520.            (function, order, additionalArgument,
  521.             constantFunctionIteration, ((Cursor const&)cursor).ivNode);
  522. }
  523.  
  524. template < class Element, class ElementOps, INumber pNumberOfChildren >
  525. inline IBoolean IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  526. allSubtreeElementsDo (ITreeCursor const& cursor,
  527.                       IConstantIterator <Element>& iterator,
  528.                       ITreeIterationOrder order) const
  529. { checkCursor (cursor);
  530.   return ivImpl.allElementsDo (&iterator, order, constantIteratorIteration,
  531.                                ((Cursor const&)cursor).ivNode);
  532. }
  533.  
  534. template < class Element, class ElementOps, INumber pNumberOfChildren >
  535. inline IGTabularTree < Element, ElementOps, pNumberOfChildren >::Node*
  536. IGTabularTree < Element, ElementOps, pNumberOfChildren >::
  537. newNode (Element const& element)
  538. { Node *result = new Node (element);
  539.   ICHECK (result != 0, IOutOfMemory, IOutOfMemoryText)
  540.   return result;
  541. }
  542.