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