home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / Dloads / OTHERUTI / TCPP30-1.ZIP / CLASSINC.ZIP / STACKS.H < prev    next >
C/C++ Source or Header  |  1992-02-18  |  24KB  |  895 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  STACKS.H                                                              */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1991                                  */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __STACKS_H )
  11. #define __STACKS_H
  12.  
  13. #if !defined( ___DEFS_H )
  14. #include <_defs.h>
  15. #endif  // ___DEFS_H
  16.  
  17. #if !defined( __CHECKS_H )
  18. #include <Checks.h>
  19. #endif  // __CHECKS_H
  20.  
  21. #if !defined( __SHDDEL_H )
  22. #include <ShdDel.h>
  23. #endif  // __SHDDEL_H
  24.  
  25. #if !defined( __VECTIMP_H )
  26. #include <VectImp.h>
  27. #endif  // __VECTIMP_H
  28.  
  29. #if !defined( __LISTIMP_H )
  30. #include <ListImp.h>
  31. #endif  // __LISTIMP_H
  32.  
  33. #if !defined( __CONTAIN_H )
  34. #include <Contain.h>
  35. #endif  // __CONTAIN_H
  36.  
  37. /*------------------------------------------------------------------------*/
  38. /*                                                                        */
  39. /*  template <class Vect, class T> class BI_StackAsVectorImp              */
  40. /*                                                                        */
  41. /*  Implements the fundamental stack operations, using a vector           */
  42. /*  as the underlying implementation.  The type Vect specifies the        */
  43. /*  form of the vector, either a BI_VectorImp<T0> or a                    */
  44. /*  BI_IVectorImp<T0>.  The type T specifies the type of the              */
  45. /*  objects to be put on the stack.  When using BI_VectorImp<T0>,         */
  46. /*  T should be the same as T0. When using BI_IVectorImp<T0>, T           */
  47. /*  should be of type pointer to T0.  See BI_StackAsVector and            */
  48. /*  BI_IStackAsVector for examples.                                       */
  49. /*                                                                        */
  50. /*------------------------------------------------------------------------*/
  51.  
  52. template <class Vect, class T> class _CLASSTYPE BI_StackAsVectorImp
  53. {
  54.  
  55. public:
  56.  
  57.     BI_StackAsVectorImp( unsigned max = DEFAULT_STACK_SIZE ) :
  58.         data(max),
  59.         current(0)
  60.         {
  61.         }
  62.  
  63.     void push( T t )
  64.         {
  65.         PRECONDITION( current < data.limit() );
  66.         data[current++] = t;
  67.         }
  68.  
  69.     T pop()
  70.         {
  71.         PRECONDITION( current > 0 );
  72.         return data[--current];
  73.         }
  74.  
  75.     T top() const
  76.         {
  77.         PRECONDITION( current > 0 );
  78.         return data[current-1];
  79.         }
  80.  
  81.     int isEmpty() const
  82.         {
  83.         return current == 0;
  84.         }
  85.  
  86.     int isFull() const
  87.         {
  88.         return current == data.limit();
  89.         }
  90.  
  91.     int getItemsInContainer() const
  92.         {
  93.         return current;
  94.         }
  95.  
  96.     void flush( TShouldDelete::DeleteType = TShouldDelete::DefDelete )
  97.         {
  98.         current = 0;
  99.         }
  100.  
  101. protected:
  102.  
  103.     Vect data;
  104.     unsigned current;
  105.  
  106. };
  107.  
  108. /*------------------------------------------------------------------------*/
  109. /*                                                                        */
  110. /*  template <class T> class BI_StackAsVector                             */
  111. /*                                                                        */
  112. /*  Implements a stack of objects of type T, using a vector as            */
  113. /*  the underlying implementation.                                        */
  114. /*                                                                        */
  115. /*------------------------------------------------------------------------*/
  116.  
  117. template <class T> class _CLASSTYPE BI_StackAsVector :
  118.     public BI_StackAsVectorImp<BI_VectorImp<T>,T>
  119. {
  120.  
  121. public:
  122.  
  123.     friend class _CLASSTYPE BI_StackAsVectorIterator<T>;
  124.  
  125.     BI_StackAsVector( unsigned max = DEFAULT_STACK_SIZE ) :
  126.         BI_StackAsVectorImp<BI_VectorImp<T>,T>( max )
  127.         {
  128.         }
  129.  
  130.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  131.         {
  132.         if( !isEmpty() )
  133.             data.forEach( f, args, 0, current );
  134.         }
  135.  
  136.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  137.                        void _FAR *args
  138.                      ) const
  139.         {
  140.         if( isEmpty() )
  141.             return 0;
  142.         return data.firstThat( f, args, 0, current );
  143.         }
  144.  
  145.     T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
  146.                       void _FAR *args
  147.                     ) const
  148.         {
  149.         if( isEmpty() )
  150.             return 0;
  151.         return data.lastThat( f, args, 0, current );
  152.         }
  153.  
  154. };
  155.  
  156. template <class T> class _CLASSTYPE BI_StackAsVectorIterator :
  157.     public BI_VectorIteratorImp<T>
  158. {
  159.  
  160. public:
  161.  
  162.     BI_StackAsVectorIterator( const BI_StackAsVector<T> _FAR & s ) :
  163.         BI_VectorIteratorImp<T>(s.data,0,s.current)
  164.         {
  165.         }
  166.  
  167. };
  168.  
  169. /*------------------------------------------------------------------------*/
  170. /*                                                                        */
  171. /*  template <class T> class BI_IStackAsVector                            */
  172. /*                                                                        */
  173. /*  Implements a stack of pointers to objects of type T,                  */
  174. /*  using a vector as the underlying implementation.                      */
  175. /*                                                                        */
  176. /*------------------------------------------------------------------------*/
  177.  
  178. template <class T> class _CLASSTYPE BI_IStackAsVector :
  179.     public BI_StackAsVectorImp<BI_IVectorImp<T>, T _FAR * >,
  180.     public virtual TShouldDelete
  181. {
  182.  
  183. public:
  184.  
  185.     friend class _CLASSTYPE BI_IStackAsVectorIterator<T>;
  186.  
  187.     BI_IStackAsVector( unsigned max = DEFAULT_STACK_SIZE ) :
  188.         BI_StackAsVectorImp<BI_IVectorImp<T>,T _FAR *>( max )
  189.         {
  190.         }
  191.  
  192.     ~BI_IStackAsVector()
  193.         {
  194.         flush();
  195.         }
  196.  
  197.     void push( T _FAR *t )
  198.         {
  199.         BI_StackAsVectorImp<BI_IVectorImp<T>,T _FAR *>::push( t );
  200.         }
  201.  
  202.     T _FAR *pop()
  203.  
  204.         {
  205.         return (T _FAR *)BI_StackAsVectorImp<BI_IVectorImp<T>,T _FAR *>::pop();
  206.         }
  207.  
  208.     T _FAR *top() const
  209.         {
  210.         return (T _FAR *)BI_StackAsVectorImp<BI_IVectorImp<T>,T _FAR *>::top();
  211.         }
  212.  
  213.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  214.         {
  215.         if( !isEmpty() )
  216.             data.forEach( f, args, 0, current );
  217.         }
  218.  
  219.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *), void _FAR *args ) const
  220.         {
  221.         if( isEmpty() )
  222.             return 0;
  223.         return data.firstThat( f, args, 0, current );
  224.         }
  225.  
  226.     T _FAR *lastThat( int (_FAR *f)(const T _FAR &, void _FAR *), void _FAR *args ) const
  227.         {
  228.         if( isEmpty() )
  229.             return 0;
  230.         return data.lastThat( f, args, 0, current );
  231.         }
  232.  
  233.     void flush( DeleteType dt = DefDelete )
  234.         {
  235.         data.flush( delObj(dt), current );
  236.         BI_StackAsVectorImp<BI_IVectorImp<T>,T _FAR *>::flush();
  237.         }
  238.  
  239. };
  240.  
  241. template <class T> class _CLASSTYPE BI_IStackAsVectorIterator :
  242.     public BI_IVectorIteratorImp<T>
  243. {
  244.  
  245. public:
  246.  
  247.     BI_IStackAsVectorIterator( const BI_IStackAsVector<T> _FAR & s ) :
  248.         BI_IVectorIteratorImp<T>(s.data,0,s.current)
  249.         {
  250.         }
  251.  
  252. };
  253.  
  254. /*------------------------------------------------------------------------*/
  255. /*                                                                        */
  256. /*  class BI_OStackAsVector                                               */
  257. /*                                                                        */
  258. /*  Implements a stack of pointers to Object,                             */
  259. /*  using a vector as the underlying implementation.                      */
  260. /*                                                                        */
  261. /*------------------------------------------------------------------------*/
  262.  
  263. class _CLASSTYPE BI_OStackAsVector
  264. {
  265.  
  266. public:
  267.  
  268.     friend class _CLASSTYPE BI_OStackAsVectorIterator;
  269.  
  270.     BI_OStackAsVector( unsigned max = DEFAULT_STACK_SIZE ) :
  271.         ostack( max )
  272.         {
  273.         }
  274.  
  275.  
  276.     void push( Object _FAR *t )
  277.         {
  278.         ostack.push( t );
  279.         }
  280.  
  281.     Object _FAR *pop()
  282.         {
  283.         return (Object _FAR *)(ostack.pop());
  284.         }
  285.  
  286.     Object _FAR *top() const
  287.         {
  288.         return (Object _FAR *)(ostack.top());
  289.         }
  290.  
  291.     int isEmpty() const
  292.         {
  293.         return ostack.isEmpty();
  294.         }
  295.  
  296.     int isFull() const
  297.         {
  298.         return ostack.isFull();
  299.         }
  300.  
  301.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  302.         {
  303.         ostack.forEach( f, args );
  304.         }
  305.  
  306.     Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  307.                             void _FAR *args
  308.                           ) const
  309.         {
  310.         return ostack.firstThat( f, args );
  311.         }
  312.  
  313.     Object _FAR *lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  314.                            void _FAR *args
  315.                          ) const
  316.         {
  317.         return ostack.lastThat( f, args );
  318.         }
  319.  
  320.     void flush( TShouldDelete::DeleteType dt )
  321.         {
  322.         ostack.flush( dt );
  323.         }
  324.  
  325.     int getItemsInContainer() const
  326.         {
  327.         return ostack.getItemsInContainer();
  328.         }
  329.  
  330. private:
  331.  
  332.     BI_IStackAsVector<Object> ostack;
  333.  
  334. };
  335.  
  336. class _CLASSTYPE BI_OStackAsVectorIterator :
  337.     public BI_IStackAsVectorIterator<Object>
  338. {
  339.  
  340. public:
  341.  
  342.     BI_OStackAsVectorIterator( const BI_OStackAsVector _FAR & s ) :
  343.         BI_IStackAsVectorIterator<Object>(s.ostack)
  344.         {
  345.         }
  346.  
  347. };
  348.  
  349. /*------------------------------------------------------------------------*/
  350. /*                                                                        */
  351. /*  class BI_TCStackAsVector                                              */
  352. /*                                                                        */
  353. /*  Implements an Object stack, with the full semantics of                */
  354. /*  the BC 2.0 style stack, using a vector as the underlying              */
  355. /*  implementation.                                                       */
  356. /*                                                                        */
  357. /*------------------------------------------------------------------------*/
  358.  
  359. class _CLASSTYPE BI_TCStackAsVector : public Container
  360. {
  361.  
  362. public:
  363.  
  364.     friend class _CLASSTYPE BI_TCStackAsVectorIterator;
  365.  
  366.     BI_TCStackAsVector( unsigned lim = DEFAULT_STACK_SIZE ) :
  367.         stk(lim)
  368.         {
  369.         }
  370.  
  371.     void push( Object _FAR & o )
  372.         {
  373.         stk.push( &o );
  374.         }
  375.  
  376.     Object _FAR & pop()
  377.         {
  378.         return ptrToRef(stk.pop());
  379.         }
  380.  
  381.     Object _FAR & top() const
  382.         {
  383.         return ptrToRef(stk.top());
  384.         }
  385.  
  386.     virtual int isEmpty() const
  387.         {
  388.         return stk.isEmpty();
  389.         }
  390.  
  391.     virtual countType getItemsInContainer() const
  392.         {
  393.         return stk.getItemsInContainer();
  394.         }
  395.  
  396.     virtual void flush( DeleteType dt = DefDelete )
  397.         {
  398.         stk.flush( dt );
  399.         }
  400.  
  401.     virtual ContainerIterator _FAR & initIterator() const;
  402.  
  403.     virtual classType isA() const
  404.         {
  405.         return stackClass;
  406.         }
  407.  
  408.     virtual char _FAR *nameOf() const
  409.         {
  410.         return "BI_TCStackAsVector";
  411.         }
  412.  
  413.     virtual void forEach( iterFuncType f, void _FAR *args )
  414.         {
  415.         stk.forEach( f, args );
  416.         }
  417.  
  418.     virtual Object _FAR & firstThat( condFuncType f, void _FAR *args ) const
  419.         {
  420.         return ptrToRef(stk.firstThat( f, args ));
  421.         }
  422.  
  423.     virtual Object _FAR & lastThat( condFuncType f, void _FAR *args ) const
  424.         {
  425.         return ptrToRef(stk.lastThat( f, args ));
  426.         }
  427.  
  428. private:
  429.  
  430.     BI_OStackAsVector stk;
  431.  
  432. };
  433.  
  434. class _CLASSTYPE BI_TCStackAsVectorIterator : public ContainerIterator
  435. {
  436.  
  437. public:
  438.  
  439.     BI_TCStackAsVectorIterator( const BI_TCStackAsVector _FAR & s ) :
  440.         iter(s.stk)
  441.         {
  442.         }
  443.  
  444.     virtual operator int()
  445.         {
  446.         return int(iter);
  447.         }
  448.  
  449.     virtual Object _FAR & current()
  450.         {
  451.         return Object::ptrToRef(iter.current());
  452.         }
  453.  
  454.     virtual Object _FAR & operator ++ ( int )
  455.         {
  456.         return Object::ptrToRef(iter++);
  457.         }
  458.  
  459.     virtual Object _FAR & operator ++ ()
  460.         {
  461.         return Object::ptrToRef(++iter);
  462.         }
  463.  
  464.     virtual void restart()
  465.         {
  466.         iter.restart();
  467.         }
  468.  
  469. private:
  470.  
  471.     BI_OStackAsVectorIterator iter;
  472.  
  473. };
  474.  
  475. inline ContainerIterator _FAR & BI_TCStackAsVector::initIterator() const
  476. {
  477.     return *new BI_TCStackAsVectorIterator( *this );
  478. }
  479.  
  480. /*------------------------------------------------------------------------*/
  481. /*                                                                        */
  482. /*  template <class Stk, class T> class BI_StackAsListImp                 */
  483. /*                                                                        */
  484. /*  Implements the fundamental stack operations, using a stack            */
  485. /*  as the underlying implementation.  The type Stk specifies the         */
  486. /*  form of the stack, either a BI_StackImp<T0> or a                      */
  487. /*  BI_IStackImp<T0>.  The type T specifies the type of the               */
  488. /*  objects to be put on the stack.  When using BI_StackImp<T0>,          */
  489. /*  T should be the same as T0. When using BI_IStackImp<T0>, T            */
  490. /*  should be of type pointer to T0.  See BI_StackAsList and              */
  491. /*  BI_IStackAsList for examples.                                         */
  492. /*                                                                        */
  493. /*------------------------------------------------------------------------*/
  494.  
  495. template <class Stk, class T> class _CLASSTYPE BI_StackAsListImp
  496. {
  497.  
  498. public:
  499.  
  500.     BI_StackAsListImp() :
  501.         itemsInContainer(0)
  502.         {
  503.         }
  504.  
  505.     void push( T t )
  506.         {
  507.         data.add( t );
  508.         itemsInContainer++;
  509.         }
  510.  
  511.     T pop()
  512.         {
  513.         T t = top();
  514.         data.detach( t, 0 );
  515.         itemsInContainer--;
  516.         return t;
  517.         }
  518.  
  519.     T top() const
  520.         {
  521.         PRECONDITION( !data.isEmpty() );
  522.         return data.peekHead();
  523.         }
  524.  
  525.     int isEmpty() const
  526.         {
  527.         return data.isEmpty();
  528.         }
  529.  
  530.     int isFull() const
  531.         {
  532.         return 0;
  533.         }
  534.  
  535.     void flush( TShouldDelete::DeleteType = TShouldDelete::DefDelete )
  536.         {
  537.         data.flush( 0 );
  538.         itemsInContainer = 0;
  539.         }
  540.  
  541.     int getItemsInContainer() const
  542.         {
  543.         return itemsInContainer;
  544.         }
  545.  
  546. protected:
  547.  
  548.     Stk data;
  549.     int itemsInContainer;
  550.  
  551. };
  552.  
  553. /*------------------------------------------------------------------------*/
  554. /*                                                                        */
  555. /*  template <class T> class BI_StackAsList                               */
  556. /*                                                                        */
  557. /*  Implements a stack of objects of type T, using a list as              */
  558. /*  the underlying implementation.                                        */
  559. /*                                                                        */
  560. /*------------------------------------------------------------------------*/
  561.  
  562. template <class T> class _CLASSTYPE BI_StackAsList :
  563.     public BI_StackAsListImp<BI_ListImp<T>,T>
  564. {
  565.  
  566. public:
  567.  
  568.     friend class _CLASSTYPE BI_StackAsListIterator<T>;
  569.  
  570.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  571.         {
  572.         data.forEach( f, args );
  573.         }
  574.  
  575.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  576.                        void _FAR *args
  577.                      ) const
  578.         {
  579.         return data.firstThat( f, args );
  580.         }
  581.  
  582.     T _FAR *lastThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  583.                       void _FAR *args
  584.                     ) const
  585.         {
  586.         return data.lastThat( f, args );
  587.         }
  588.  
  589. };
  590.  
  591. template <class T> class _CLASSTYPE BI_StackAsListIterator :
  592.     public BI_ListIteratorImp<T>
  593. {
  594.  
  595. public:
  596.  
  597.     BI_StackAsListIterator( const BI_StackAsList<T> _FAR & s ) :
  598.         BI_ListIteratorImp<T>(s.data)
  599.         {
  600.         }
  601.  
  602. };
  603.  
  604. /*------------------------------------------------------------------------*/
  605. /*                                                                        */
  606. /*  template <class T> class BI_IStackAsList                              */
  607. /*                                                                        */
  608. /*  Implements a stack of pointers to objects of type T,                  */
  609. /*  using a linked list as the underlying implementation.                 */
  610. /*                                                                        */
  611. /*------------------------------------------------------------------------*/
  612.  
  613. template <class T> class _CLASSTYPE BI_IStackAsList :
  614.     public BI_StackAsListImp<BI_IListImp<T>,T _FAR *>,
  615.     public virtual TShouldDelete
  616. {
  617.  
  618. public:
  619.  
  620.     friend class _CLASSTYPE BI_IStackAsListIterator<T>;
  621.  
  622.     ~BI_IStackAsList()
  623.         {
  624.         flush();
  625.         }
  626.  
  627.     void push( T _FAR *t )
  628.         {
  629.         BI_StackAsListImp<BI_IListImp<T>,T _FAR *>::push( t );
  630.         }
  631.  
  632.     T _FAR *pop()
  633.         {
  634.         return (T _FAR *)BI_StackAsListImp<BI_IListImp<T>,T _FAR *>::pop();
  635.         }
  636.  
  637.     T _FAR *top() const
  638.         {
  639.         return (T _FAR *)BI_StackAsListImp<BI_IListImp<T>,T _FAR *>::top();
  640.         }
  641.  
  642.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  643.         {
  644.         data.forEach( f, args );
  645.         }
  646.  
  647.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  648.                        void _FAR *args
  649.                      ) const
  650.         {
  651.         return data.firstThat( f, args );
  652.         }
  653.  
  654.     T _FAR *lastThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  655.                       void _FAR *args
  656.                     ) const
  657.         {
  658.         return data.lastThat( f, args );
  659.         }
  660.  
  661.     void flush( DeleteType dt = DefDelete )
  662.         { data.flush( delObj(dt) ); }
  663. };
  664.  
  665. template <class T> class _CLASSTYPE BI_IStackAsListIterator :
  666.     public BI_IListIteratorImp<T>
  667. {
  668.  
  669. public:
  670.  
  671.     BI_IStackAsListIterator( const BI_IStackAsList<T> _FAR & s ) :
  672.         BI_IListIteratorImp<T>(s.data)
  673.         {
  674.         }
  675.  
  676. };
  677.  
  678. /*------------------------------------------------------------------------*/
  679. /*                                                                        */
  680. /*  class BI_OStackAsList                                                 */
  681. /*                                                                        */
  682. /*  Implements a stack of pointers to Object,                             */
  683. /*  using a list as the underlying implementation.                        */
  684. /*                                                                        */
  685. /*------------------------------------------------------------------------*/
  686.  
  687. class _CLASSTYPE BI_OStackAsList
  688. {
  689.  
  690. public:
  691.  
  692.     friend class _CLASSTYPE BI_OStackAsListIterator;
  693.  
  694.     void push( Object _FAR *t )
  695.         {
  696.         ostack.push( t );
  697.         }
  698.  
  699.     Object _FAR *pop()
  700.         {
  701.         return (Object _FAR *)(ostack.pop());
  702.         }
  703.  
  704.     Object _FAR *top() const
  705.         {
  706.         return (Object _FAR *)(ostack.top());
  707.         }
  708.  
  709.     int isEmpty() const
  710.         {
  711.         return ostack.isEmpty();
  712.         }
  713.  
  714.     int isFull() const
  715.         {
  716.         return ostack.isFull();
  717.         }
  718.  
  719.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  720.         {
  721.         ostack.forEach( f, args );
  722.         }
  723.  
  724.     Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  725.                             void _FAR *args
  726.                           ) const
  727.         {
  728.         return ostack.firstThat( f, args );
  729.         }
  730.  
  731.     Object _FAR *lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  732.                            void _FAR *args
  733.                          ) const
  734.         {
  735.         return ostack.lastThat( f, args );
  736.         }
  737.  
  738.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  739.         {
  740.         ostack.flush( dt );
  741.         }
  742.  
  743.     int getItemsInContainer() const
  744.         {
  745.         return ostack.getItemsInContainer();
  746.         }
  747.  
  748. private:
  749.  
  750.     BI_IStackAsList<Object> ostack;
  751.  
  752. };
  753.  
  754. class _CLASSTYPE BI_OStackAsListIterator :
  755.     public BI_IStackAsListIterator<Object>
  756. {
  757.  
  758. public:
  759.  
  760.     BI_OStackAsListIterator( const BI_OStackAsList _FAR & s ) :
  761.         BI_IStackAsListIterator<Object>(s.ostack)
  762.         {
  763.         }
  764.  
  765. };
  766.  
  767. /*------------------------------------------------------------------------*/
  768. /*                                                                        */
  769. /*  class BI_TCStackAsList                                                */
  770. /*                                                                        */
  771. /*  Implements an Object stack, with the full semantics of                */
  772. /*  the BC 2.0 style stack, using a list as the underlying                */
  773. /*  implementation.                                                       */
  774. /*                                                                        */
  775. /*------------------------------------------------------------------------*/
  776.  
  777. class _CLASSTYPE BI_TCStackAsList : public Container
  778. {
  779.  
  780. public:
  781.  
  782.     friend class _CLASSTYPE BI_TCStackAsListIterator;
  783.  
  784.     void push( Object _FAR & o )
  785.         {
  786.         stk.push( &o );
  787.         }
  788.  
  789.     Object _FAR & pop()
  790.         {
  791.         return ptrToRef(stk.pop());
  792.         }
  793.  
  794.     Object _FAR & top() const
  795.         {
  796.         return ptrToRef(stk.top());
  797.         }
  798.  
  799.     virtual int isEmpty() const
  800.         {
  801.         return stk.isEmpty();
  802.         }
  803.  
  804.     virtual countType getItemsInContainer() const
  805.         {
  806.         return stk.getItemsInContainer();
  807.         }
  808.  
  809.     virtual void flush( DeleteType dt = DefDelete )
  810.         {
  811.         stk.flush( dt );
  812.         }
  813.  
  814.     virtual ContainerIterator _FAR & initIterator() const;
  815.  
  816.     virtual classType isA() const
  817.         {
  818.         return stackClass;
  819.         }
  820.  
  821.     virtual char _FAR * nameOf() const
  822.         {
  823.         return "BI_TCStackAsList";
  824.         }
  825.  
  826.     virtual void forEach( iterFuncType f, void _FAR *args )
  827.         {
  828.         stk.forEach( f, args );
  829.         }
  830.  
  831.     virtual Object _FAR & firstThat( condFuncType f, void _FAR *args ) const
  832.         {
  833.         return ptrToRef(stk.firstThat( f, args ));
  834.         }
  835.  
  836.     virtual Object _FAR & lastThat( condFuncType f, void _FAR *args ) const
  837.         {
  838.         return ptrToRef(stk.lastThat( f, args ));
  839.         }
  840.  
  841. private:
  842.  
  843.     BI_OStackAsList stk;
  844.  
  845. };
  846.  
  847. class _CLASSTYPE BI_TCStackAsListIterator : public ContainerIterator
  848. {
  849.  
  850. public:
  851.  
  852.     BI_TCStackAsListIterator( const BI_TCStackAsList _FAR & s ) :
  853.         iter(s.stk)
  854.         {
  855.         }
  856.  
  857.     virtual operator int()
  858.         {
  859.         return int(iter);
  860.         }
  861.  
  862.     virtual Object _FAR & current()
  863.         {
  864.         return Object::ptrToRef(iter.current());
  865.         }
  866.  
  867.     virtual Object _FAR & operator ++ ( int )
  868.         {
  869.         return Object::ptrToRef(iter++);
  870.         }
  871.  
  872.     virtual Object _FAR & operator ++ ()
  873.         {
  874.         return Object::ptrToRef(++iter);
  875.         }
  876.  
  877.     virtual void restart()
  878.         {
  879.         iter.restart();
  880.         }
  881.  
  882. private:
  883.  
  884.     BI_OStackAsListIterator iter;
  885.  
  886. };
  887.  
  888. inline ContainerIterator _FAR & BI_TCStackAsList::initIterator() const
  889. {
  890.     return *new BI_TCStackAsListIterator( *this );
  891. }
  892.  
  893. #endif  // __STACKS_H
  894.  
  895.