home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional Developers Kit 1992 November / Disc01 / Disc01.mdf / runnable / ibmc / ibmclass / itbtre.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-26  |  8.9 KB  |  254 lines
  1. /* Copyright (c) IBM Corp. 1992 */
  2. #ifndef _ITBTRE_H
  3. #define _ITBTRE_H
  4.  
  5. #include <iglobals.h>
  6. #include <itcursor.h>
  7. #include <iitbtre.h>
  8.  
  9. template < class Element, class ElementOps, INumber pNumberOfChildren >
  10. class IGTabularTree
  11. { 
  12.   static ElementOps cvElementOps;
  13.  
  14.   class Node;
  15.   class Cursor;
  16.  
  17.   friend class Node;
  18.   friend class Cursor;
  19.  
  20.   class Node
  21.   { friend class IGTabularTree < Element, ElementOps, pNumberOfChildren >;
  22.     friend class Cursor;
  23.  
  24.     // must be layout compatible with ITabularTreeImpl::Node
  25.     // cannot derive because of unknown pNumberOfChildren in impl
  26.  
  27.     Node** ivParent;
  28.     Node* ivChildren [pNumberOfChildren];
  29.     Element ivElement;      
  30.  
  31.   public :
  32.                      Node                (Element const& element)
  33.              : ivElement (element) {};
  34.  
  35.     void*            operator new        (size_t s)
  36.              { return cvElementOps.allocate (s); }
  37.  
  38.     void             operator delete     (void* p)
  39.                      { cvElementOps.deallocate (p); }
  40.   };
  41.  
  42.   ITabularTreeImpl ivImpl;
  43.  
  44. public :
  45.  
  46.   class Cursor : public ITreeCursor {
  47.   protected:
  48.     IGTabularTree < Element, ElementOps,
  49.             pNumberOfChildren > const* ivCollection;
  50.     ITabularTreeImpl::Node **ivNode;
  51.     friend class IGTabularTree < Element, ElementOps, pNumberOfChildren >;
  52.  
  53.   public:
  54.     Cursor (IGTabularTree < Element, ElementOps,
  55.                 pNumberOfChildren > const& collection)
  56.     : ivCollection (&collection), ivNode (0) {};
  57.  
  58.     Boolean setToRoot ();
  59.     Boolean setToChild (IPosition);
  60.     Boolean setToFirstExistingChild ();
  61.     Boolean setToNextExistingChild ();
  62.     Boolean setToLastExistingChild ();
  63.     Boolean setToPreviousExistingChild ();
  64.     Boolean isValid () const;
  65.     void    invalidate ();
  66.  
  67.     Element const& element      ()
  68.     { return ivCollection->elementAt (*this); }
  69.  
  70.     Boolean operator== (Cursor const& cursor)
  71.     { return ivCollection == cursor.ivCollection &&
  72.              ivNode == cursor.ivNode; }
  73.     Boolean operator!= (Cursor const& cursor)
  74.     { return ! operator== (cursor); }
  75.   };
  76.  
  77.                   IGTabularTree               ();
  78.                   IGTabularTree               (IGTabularTree
  79.                          < Element,
  80.                            ElementOps,
  81.                            pNumberOfChildren > const&);
  82.                  ~IGTabularTree               ();
  83.  
  84.    IGTabularTree < Element, ElementOps, pNumberOfChildren >&
  85.           operator=                   (IGTabularTree
  86.                          < Element,
  87.                            ElementOps,
  88.                            pNumberOfChildren > const&);
  89.  
  90.    void           copy                        (IGTabularTree
  91.                          < Element,
  92.                            ElementOps,
  93.                            pNumberOfChildren > const&);
  94.    void           copySubtree                 (IGTabularTree
  95.                              < Element,
  96.                            ElementOps,
  97.                            pNumberOfChildren > const&,
  98.                            ITreeCursor const&);
  99.  
  100.    void           addAsRoot                   (Element const&);
  101.    void           addAsChild                  (ITreeCursor const&,
  102.                                IPosition,
  103.                                Element const&);
  104.  
  105.    void           attachAsRoot                (IGTabularTree
  106.                          < Element,
  107.                            ElementOps,
  108.                            pNumberOfChildren >&);
  109.    void           attachAsChild               (ITreeCursor const&,
  110.                                    IPosition,
  111.                                    IGTabularTree
  112.                          < Element,
  113.                            ElementOps,
  114.                            pNumberOfChildren >&);
  115.    void           attachSubtreeAsRoot         (IGTabularTree
  116.                          < Element,
  117.                            ElementOps,
  118.                            pNumberOfChildren >&,
  119.                                ITreeCursor const&);
  120.    void           attachSubtreeAsChild        (ITreeCursor const&,
  121.                                IPosition,
  122.                                IGTabularTree
  123.                          < Element,
  124.                            ElementOps,
  125.                            pNumberOfChildren >&,
  126.                                ITreeCursor const&);
  127.  
  128.    INumber        removeAll                   ();
  129.    INumber        removeSubtree               (ITreeCursor const&);
  130.  
  131.    Element const& elementAt                   (ITreeCursor const&) const;
  132.    Element&       elementAt                   (ITreeCursor const&);
  133.  
  134.    void           replaceAt                   (ITreeCursor const&,
  135.                            Element const&);
  136.  
  137.    INumber        numberOfChildren            () const;
  138.    INumber        numberOfElements            () const;
  139.    INumber        numberOfSubtreeElements     (ITreeCursor const&) const;
  140.    INumber        numberOfLeaves              () const;
  141.    INumber        numberOfSubtreeLeaves       (ITreeCursor const&) const;
  142.  
  143.    Boolean        isEmpty                     () const;
  144.  
  145.    ITreeCursor*   newCursor                   () const;
  146.  
  147.    Boolean        isRoot                      (ITreeCursor const&) const;
  148.    Boolean        isLeaf                      (ITreeCursor const&) const;
  149.    INumber        position                    (ITreeCursor const&) const;
  150.    Boolean        hasChild                    (IPosition,
  151.                            ITreeCursor const&) const;
  152.  
  153.    Boolean        setToRoot                   (ITreeCursor&) const;
  154.    Boolean        setToChild                  (IPosition, ITreeCursor&) const;
  155.    Boolean        setToParent                 (ITreeCursor&) const;
  156.    Boolean        setToFirstExistingChild     (ITreeCursor&) const;
  157.    Boolean        setToNextExistingChild      (ITreeCursor&) const;
  158.    Boolean        setToLastExistingChild      (ITreeCursor&) const;
  159.    Boolean        setToPreviousExistingChild  (ITreeCursor&) const;
  160.  
  161.    Boolean        setToFirst                  (ITreeCursor&,
  162.                            ITreeIterationOrder) const;
  163.    Boolean        setToNext                   (ITreeCursor&,
  164.                            ITreeIterationOrder) const;
  165.    Boolean        setToLast                   (ITreeCursor&,
  166.                            ITreeIterationOrder) const;
  167.    Boolean        setToPrevious               (ITreeCursor&,
  168.                            ITreeIterationOrder) const;
  169.  
  170.    Boolean        allElementsDo               (Boolean (*function)
  171.                                     (Element&, void*),
  172.                            ITreeIterationOrder,
  173.                                    void* additionalArgument = 0);
  174.  
  175.    Boolean        allElementsDo               (IIterator <Element>&,
  176.                            ITreeIterationOrder);
  177.  
  178.    Boolean        allElementsDo               (Boolean (*function)
  179.                                     (Element const&, void*),
  180.                            ITreeIterationOrder,
  181.                                    void* additionalArgument = 0)
  182.                           const;
  183.  
  184.    Boolean        allElementsDo               (IConstantIterator <Element>&,
  185.                            ITreeIterationOrder) const;
  186.  
  187.    Boolean        allSubtreeElementsDo        (ITreeCursor const&,
  188.                                Boolean (*function)
  189.                                 (Element&, void*),
  190.                                ITreeIterationOrder,
  191.                                void* additionalArgument = 0);
  192.  
  193.    Boolean        allSubtreeElementsDo        (ITreeCursor const&,
  194.                                IIterator <Element>&,
  195.                                ITreeIterationOrder);
  196.  
  197.    Boolean        allSubtreeElementsDo        (ITreeCursor const&,
  198.                                Boolean (*function)
  199.                                 (Element const&, void*),
  200.                                ITreeIterationOrder,
  201.                                void* additionalArgument = 0)
  202.                           const;
  203.  
  204.    Boolean        allSubtreeElementsDo        (ITreeCursor const&,
  205.                                IConstantIterator <Element>&,
  206.                                ITreeIterationOrder) const;
  207.  
  208. private:
  209.  
  210.    void           copySubtree                 (Node*& to, Node* from);
  211.    INumber        removeSubtree               (Node*);
  212.    Node*          newNode                     (Element const&);
  213.  
  214.    void           checkNotEmpty               () const;
  215.    void           checkCursorIsForThis        (ITreeCursor const&) const;
  216.    void           checkCursor                 (ITreeCursor const&) const;
  217.    void           checkCursorOfTree           (IGTabularTree
  218.                          < Element,
  219.                            ElementOps,
  220.                            pNumberOfChildren > const&,
  221.                            ITreeCursor const&) const;
  222.    void           checkPosition               (IPosition position) const;
  223.    void           checkRootNotExists          () const;
  224.    void           checkChildNotExists         (ITabularTreeImpl::Node*) const;
  225.  
  226.    static
  227.    Boolean        constantFunctionIteration   (void *function,
  228.                                                void* env,
  229.                                                void const* node);
  230.    static
  231.    Boolean        functionIteration           (void *function,
  232.                                                void* env,
  233.                                                void* node);
  234.    static
  235.    Boolean        constantIteratorIteration   (void* iterator,
  236.                                                void const* node);
  237.    static
  238.    Boolean        iteratorIteration           (void* iterator,
  239.                                                void* node);
  240. };
  241.  
  242. template < class Element, INumber pNumberOfChildren >
  243. class ITabularTree :
  244.   public IGTabularTree < Element, IStdOps < Element >, pNumberOfChildren > {
  245. };
  246.  
  247. #include <itbtre.if>
  248.  
  249. #ifdef __IBMCPP__
  250. #include <itbtre.c>
  251. #endif
  252.  
  253. #endif
  254.