home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c083 / 20.ddi / CLOBSH.PAK / DEQUE.H < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-02  |  17.2 KB  |  694 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  DEQUE.H                                                               */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1991, 1993                            */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __DEQUE_H )
  11. #define __DEQUE_H
  12.  
  13. #define BI_OLDNAMES
  14.  
  15. #if !defined( TEMPLATES )
  16.  
  17. #if !defined( __CLSTYPES_H )
  18. #include "classlib\obsolete\ClsTypes.h"
  19. #endif  // __CLSTYPES_H
  20.  
  21. #if !defined( __CONTAIN_H )
  22. #include "classlib\obsolete\Contain.h"
  23. #endif  // __CONTAIN_H
  24.  
  25. #if !defined( __DBLLIST_H )
  26. #include "classlib\obsolete\DblList.h"
  27. #endif  // __DBLLIST_H
  28.  
  29. #pragma option -Vo-
  30. #if defined( __BCOPT__ ) && !defined( _ALLOW_po )
  31. #pragma option -po-
  32. #endif
  33.  
  34. _CLASSDEF(Deque)
  35.  
  36. class _CLASSTYPE Deque : public Container
  37. {
  38.  
  39. public:
  40.  
  41.     ~Deque()
  42.         {
  43.         flush();
  44.         }
  45.  
  46.     Object& peekLeft() const
  47.         {
  48.         return list.peekAtHead();
  49.         }
  50.  
  51.     Object& peekRight() const
  52.         {
  53.         return list.peekAtTail();
  54.         }
  55.  
  56.     Object& getLeft();
  57.     Object& getRight();
  58.  
  59.     void putLeft( Object& o )
  60.         {
  61.         list.addAtHead( o );
  62.         itemsInContainer++;
  63.         }
  64.  
  65.     void putRight( Object& o )
  66.         {
  67.         list.addAtTail( o );
  68.         itemsInContainer++;
  69.         }
  70.  
  71.     virtual void flush( DeleteType dt = DefDelete )
  72.         {
  73.         list.flush( dt );
  74.         }
  75.  
  76.     virtual int isEmpty() const
  77.         {
  78.         return list.isEmpty();
  79.         }
  80.  
  81.     virtual countType getItemsInContainer() const
  82.         {
  83.         return list.getItemsInContainer();
  84.         }
  85.  
  86.     virtual void forEach( iterFuncType f, void _FAR *arg )
  87.         {
  88.         list.forEach( f, arg );
  89.         }
  90.  
  91.     virtual Object _FAR & firstThat( condFuncType f, void _FAR *arg ) const
  92.         {
  93.         return list.firstThat( f, arg );
  94.         }
  95.  
  96.     virtual Object _FAR & lastThat( condFuncType f, void _FAR *arg ) const
  97.         {
  98.         return list.lastThat( f, arg );
  99.         }
  100.  
  101.     virtual classType isA() const
  102.         {
  103.         return dequeClass;
  104.         }
  105.  
  106.     virtual char _FAR *nameOf() const
  107.         {
  108.         return "Deque";
  109.         }
  110.  
  111.     virtual hashValueType hashValue() const
  112.         {
  113.         return list.hashValue();
  114.         }
  115.  
  116.     virtual int isEqual( const Object& obj ) const
  117.         {
  118.         return list.isEqual( obj );
  119.         }
  120.  
  121.     virtual int isSortable() const
  122.         {
  123.         return list.isSortable();
  124.         }
  125.  
  126.     virtual int isAssociation() const
  127.         {
  128.         return list.isAssociation();
  129.         }
  130.  
  131.     virtual void printOn( ostream& os ) const
  132.         {
  133.         list.printOn( os );
  134.         }
  135.  
  136.     virtual void printHeader( ostream& os ) const
  137.         {
  138.         list.printHeader( os );
  139.         }
  140.  
  141.     virtual void printSeparator( ostream& os ) const
  142.         {
  143.         list.printSeparator( os );
  144.         }
  145.  
  146.     virtual void printTrailer( ostream& os ) const
  147.         {
  148.         list.printTrailer( os );
  149.         }
  150.  
  151.     virtual ContainerIterator& initIterator() const;
  152.  
  153.     int ownsElements()
  154.         {
  155.         return list.ownsElements();
  156.         }
  157.  
  158.     void ownsElements( int del )
  159.         { 
  160.         list.ownsElements( del );
  161.         }
  162.  
  163. private:
  164.  
  165.     DoubleList list;
  166.  
  167. };
  168.  
  169. #else   // TEMPLATES
  170.  
  171. #if !defined( __CONTAIN_H )
  172. #include "classlib\obsolete\Contain.h"
  173. #endif  // __CONTAIN_H
  174.  
  175. #if !defined( __DEQUES_H )
  176. #include "classlib\Deques.h"
  177. #endif  // __DEQUES_H
  178.  
  179. #pragma option -Vo-
  180. #if defined( __BCOPT__ ) && !defined( _ALLOW_po )
  181. #pragma option -po-
  182. #endif
  183.  
  184. #define Deque   BI_TCDequeAsDoubleList
  185. #define PDeque  PBI_TCDequeAsDoubleList
  186. #define RDeque  RBI_TCDequeAsDoubleList
  187. #define RPDeque RPBI_TCDequeAsDoubleList
  188. #define PCDeque PCBI_TCDequeAsDoubleList
  189. #define RCDeque RCBI_TCDequeAsDoubleList
  190.  
  191. _CLASSDEF( BI_TCDequeAsDoubleList )
  192.  
  193. #define DequeIterator   BI_TCDequeAsDoubleListIterator
  194. #define PDequeIterator  PBI_TCDequeAsDoubleListIterator
  195. #define RDequeIterator  RBI_TCDequeAsDoubleListIterator
  196. #define RPDequeIterator RPBI_TCDequeAsDoubleListIterator
  197. #define PCDequeIterator PCBI_TCDequeAsDoubleListIterator
  198. #define RCDequeIterator RCBI_TCDequeAsDoubleListIterator
  199.  
  200. _CLASSDEF( BI_TCDequeAsDoubleListIterator )
  201.  
  202. /*------------------------------------------------------------------------*/
  203. /*                                                                        */
  204. /*  class BI_ODequeAsVector                                               */
  205. /*                                                                        */
  206. /*  Implements a dequeue of pointers to Object,                           */
  207. /*  using a vector as the underlying implementation.                      */
  208. /*                                                                        */
  209. /*------------------------------------------------------------------------*/
  210.  
  211. class _CLASSTYPE BI_ODequeAsVector : public BI_IDequeAsVector<Object>
  212. {
  213.  
  214. public:
  215.  
  216.     friend class _CLASSTYPE BI_ODequeAsVectorIterator;
  217.  
  218.     BI_ODequeAsVector( unsigned sz = DEFAULT_DEQUE_SIZE ) :
  219.         BI_IDequeAsVector<Object>( sz )
  220.         {
  221.         }
  222.  
  223.     Object _FAR *peekLeft() const
  224.         {
  225.         return BI_IDequeAsVector<Object>::peekLeft();
  226.         }
  227.  
  228.     Object _FAR *peekRight() const
  229.         {
  230.         return BI_IDequeAsVector<Object>::peekRight();
  231.         }
  232.  
  233.     Object _FAR *getLeft()
  234.         {
  235.         return BI_IDequeAsVector<Object>::getLeft();
  236.         }
  237.  
  238.     Object _FAR *getRight()
  239.         {
  240.         return BI_IDequeAsVector<Object>::getRight();
  241.         }
  242.  
  243.     void putLeft( Object _FAR *o )
  244.         {
  245.         BI_IDequeAsVector<Object>::putLeft( o );
  246.         }
  247.  
  248.     void putRight( Object _FAR *o )
  249.         {
  250.         BI_IDequeAsVector<Object>::putRight( o );
  251.         }
  252.  
  253.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  254.         {
  255.         BI_IDequeAsVector<Object>::flush( dt );
  256.         }
  257.  
  258.     int isFull() const
  259.         {
  260.         return BI_IDequeAsVector<Object>::isFull();
  261.         }
  262.  
  263.     int isEmpty() const
  264.         {
  265.         return BI_IDequeAsVector<Object>::isEmpty();
  266.         }
  267.  
  268.     void forEach( iterFuncType f, void _FAR*), void _FAR*args )
  269.         {
  270.         BI_IDequeAsVector<Object>::forEach( f, args );
  271.         }
  272.  
  273.     Object _FAR *firstThat( condFuncType f, void _FAR *args ) const
  274.         {
  275.         return BI_IDequeAsVector<Object>::firstThat( f, args );
  276.         }
  277.  
  278.     Object _FAR *lastThat( condFuncType f, void _FAR *args ) const
  279.         {
  280.         return BI_IDequeAsVector<Object>::lastThat( f, args );
  281.         }
  282.  
  283.     int getItemsInContainer() const
  284.         {
  285.         return BI_IDequeAsVector<Object>::getItemsInContainer();
  286.         }
  287.  
  288. };
  289.  
  290. class _CLASSTYPE BI_ODequeAsVectorIterator :
  291.     public BI_IDequeAsVectorIterator<Object>
  292. {
  293.  
  294. public:
  295.  
  296.     BI_ODequeAsVectorIterator( const BI_ODequeAsVector _FAR &d ) :
  297.         BI_IDequeAsVectorIterator<Object>((const BI_IDequeAsVector<Object>&)d)
  298.         {
  299.         }
  300.  
  301. };
  302.  
  303. /*------------------------------------------------------------------------*/
  304. /*                                                                        */
  305. /*  class BI_TCDequeAsVector                                              */
  306. /*                                                                        */
  307. /*  Implements an Object dequeue, with the full semantics of              */
  308. /*  the BC 2.0 style deque, using a vector as the underlying              */
  309. /*  implementation.                                                       */
  310. /*                                                                        */
  311. /*------------------------------------------------------------------------*/
  312.  
  313. class _CLASSTYPE BI_TCDequeAsVector : 
  314.     public Container, 
  315.     protected BI_ODequeAsVector
  316. {
  317.  
  318. public:
  319.  
  320.     friend class _CLASSTYPE BI_TCDequeAsVectorIterator;
  321.  
  322.     BI_TCDequeAsVector( int sz = DEFAULT_DEQUE_SIZE ) :
  323.         BI_ODequeAsVector(sz)
  324.         {
  325.         }
  326.  
  327.     Object _FAR & peekLeft() const
  328.         {
  329.         return ptrToRef(BI_ODequeAsVector::peekLeft());
  330.         }
  331.  
  332.     Object _FAR & peekRight() const
  333.         {
  334.         return ptrToRef(BI_ODequeAsVector::peekRight());
  335.         }
  336.  
  337.     Object _FAR & getLeft()
  338.         {
  339.         return ptrToRef(BI_ODequeAsVector::getLeft());
  340.         }
  341.  
  342.     Object _FAR & getRight()
  343.         {
  344.         return ptrToRef(BI_ODequeAsVector::getRight());
  345.         }
  346.  
  347.     void putLeft( Object _FAR & o )
  348.         {
  349.         BI_ODequeAsVector::putLeft( &o );
  350.         }
  351.  
  352.     void putRight( Object _FAR & o )
  353.         {
  354.         BI_ODequeAsVector::putRight( &o );
  355.         }
  356.  
  357.     virtual void flush( DeleteType dt = DefDelete )
  358.         {
  359.         BI_ODequeAsVector::flush(dt);
  360.         }
  361.  
  362.     virtual int isEmpty() const
  363.         {
  364.         return BI_ODequeAsVector::isEmpty();
  365.         }
  366.  
  367.     virtual countType getItemsInContainer() const
  368.         {
  369.         return BI_ODequeAsVector::getItemsInContainer();
  370.         }
  371.  
  372.     void forEach( iterFuncType f, void _FAR*args )
  373.         {
  374.         BI_ODequeAsVector::forEach( f, args );
  375.         }
  376.  
  377.     Object _FAR & firstThat( condFuncType f, void _FAR *args ) const
  378.         {
  379.         return ptrToRef(BI_ODequeAsVector::firstThat( f, args ));
  380.         }
  381.  
  382.     Object _FAR & lastThat( condFuncType f, void _FAR *args ) const
  383.         {
  384.         return ptrToRef(BI_ODequeAsVector::lastThat( f, args ));
  385.         }
  386.  
  387.     virtual ContainerIterator _FAR & initIterator() const;
  388.  
  389.     virtual classType isA() const
  390.         {
  391.         return dequeClass;
  392.         }
  393.  
  394.     virtual char _FAR *nameOf() const
  395.         {
  396.         return "BI_TCDequeAsVector";
  397.         }
  398.  
  399. };
  400.  
  401. class _CLASSTYPE BI_TCDequeAsVectorIterator : public ContainerIterator
  402. {
  403.  
  404. public:
  405.  
  406.     BI_TCDequeAsVectorIterator( const BI_TCDequeAsVector _FAR &d ) :
  407.         iter((const BI_ODequeAsVector&)d)
  408.         {
  409.         }
  410.  
  411.     virtual operator int()
  412.         {
  413.         return int(iter);
  414.         }
  415.  
  416.     virtual Object _FAR & current()
  417.         {
  418.         return Object::ptrToRef(iter.current());
  419.         }
  420.  
  421.     virtual Object _FAR & operator ++ ( int )
  422.         {
  423.         return Object::ptrToRef(iter++);
  424.         }
  425.  
  426.     virtual Object _FAR & operator ++ ()
  427.         {
  428.         return Object::ptrToRef(++iter);
  429.         }
  430.  
  431.     virtual void restart()
  432.         {
  433.         iter.restart();
  434.         }
  435.  
  436. private:
  437.  
  438.     BI_ODequeAsVectorIterator iter;
  439.  
  440. };
  441.  
  442. inline ContainerIterator _FAR & BI_TCDequeAsVector::initIterator() const
  443. {
  444.     return *new BI_TCDequeAsVectorIterator( *this );
  445. }
  446.  
  447. /*------------------------------------------------------------------------*/
  448. /*                                                                        */
  449. /*  class BI_ODequeAsDoubleList                                           */
  450. /*                                                                        */
  451. /*  Implements a dequeue of pointers to Object,                           */
  452. /*  using a double-linked list as the underlying implementation.          */
  453. /*                                                                        */
  454. /*------------------------------------------------------------------------*/
  455.  
  456. class _CLASSTYPE BI_ODequeAsDoubleList : 
  457.     protected BI_IDequeAsDoubleList<Object>
  458. {
  459.  
  460. public:
  461.  
  462.     friend class _CLASSTYPE BI_ODequeAsDoubleListIterator;
  463.  
  464.     ~BI_ODequeAsDoubleList()
  465.         {
  466.         flush();
  467.         }
  468.  
  469.     Object _FAR *peekLeft() const
  470.         {
  471.         return BI_IDequeAsDoubleList<Object>::peekLeft();
  472.         }
  473.  
  474.     Object _FAR *peekRight() const
  475.         {
  476.         return BI_IDequeAsDoubleList<Object>::peekRight();
  477.         }
  478.  
  479.     Object _FAR *getLeft()
  480.         {
  481.         return BI_IDequeAsDoubleList<Object>::getLeft();
  482.         }
  483.  
  484.     Object _FAR *getRight()
  485.         {
  486.         return BI_IDequeAsDoubleList<Object>::getRight();
  487.         }
  488.  
  489.     void putLeft( Object _FAR *o )
  490.         {
  491.         BI_IDequeAsDoubleList<Object>::putLeft( o );
  492.         }
  493.  
  494.     void putRight( Object _FAR *o )
  495.         {
  496.         BI_IDequeAsDoubleList<Object>::putRight( o );
  497.         }
  498.  
  499.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  500.         {
  501.         BI_IDequeAsDoubleList<Object>::flush( dt );
  502.         }
  503.  
  504.     int isFull() const
  505.         {
  506.         return BI_IDequeAsDoubleList<Object>::isFull();
  507.         }
  508.  
  509.     int isEmpty() const
  510.         {
  511.         return BI_IDequeAsDoubleList<Object>::isEmpty();
  512.         }
  513.  
  514.     void forEach( iterFuncType f, void _FAR*args )
  515.         {
  516.         BI_IDequeAsDoubleList<Object>::forEach( f, args );
  517.         }
  518.  
  519.     Object _FAR *firstThat( condFuncType f, void _FAR *args ) const
  520.         {
  521.         return BI_IDequeAsDoubleList<Object>::firstThat( f, args );
  522.         }
  523.  
  524.     Object _FAR *lastThat( condFuncType f, void _FAR *args ) const
  525.         {
  526.         return BI_IDequeAsDoubleList<Object>::lastThat( f, args );
  527.         }
  528.  
  529.     int getItemsInContainer() const { return BI_IDequeAsDoubleList<Object>::getItemsInContainer(); }
  530.  
  531. };
  532.  
  533. class _CLASSTYPE BI_ODequeAsDoubleListIterator :
  534.     public BI_IDequeAsDoubleListIterator<Object>
  535. {
  536.  
  537. public:
  538.  
  539.     BI_ODequeAsDoubleListIterator( const BI_ODequeAsDoubleList _FAR &d ) :
  540.         BI_IDequeAsDoubleListIterator<Object>((const BI_IDequeAsDoubleList<Object>&)d)
  541.         {
  542.         }
  543.  
  544. };
  545.  
  546. /*------------------------------------------------------------------------*/
  547. /*                                                                        */
  548. /*  class BI_TCDequeAsDoubleList                                          */
  549. /*                                                                        */
  550. /*  Implements an Object dequeue, with the full semantics of              */
  551. /*  the BC 2.0 style stack, using a double-linked list as the underlying  */
  552. /*  implementation.                                                       */
  553. /*                                                                        */
  554. /*------------------------------------------------------------------------*/
  555.  
  556. class _CLASSTYPE BI_TCDequeAsDoubleList : 
  557.     public Container,
  558.     protected BI_ODequeAsDoubleList
  559. {
  560.  
  561. public:
  562.  
  563.     friend class _CLASSTYPE BI_TCDequeAsDoubleListIterator;
  564.  
  565.     Object _FAR & peekLeft() const
  566.         {
  567.         return ptrToRef(BI_ODequeAsDoubleList::peekLeft());
  568.         }
  569.  
  570.     Object _FAR & peekRight() const
  571.         {
  572.         return ptrToRef(BI_ODequeAsDoubleList::peekRight());
  573.         }
  574.  
  575.     Object _FAR & getLeft()
  576.         {
  577.         return ptrToRef(BI_ODequeAsDoubleList::getLeft());
  578.         }
  579.  
  580.     Object _FAR & getRight()
  581.         {
  582.         return ptrToRef(BI_ODequeAsDoubleList::getRight());
  583.         }
  584.  
  585.     void putLeft( Object _FAR & o )
  586.         {
  587.         BI_ODequeAsDoubleList::putLeft( &o );
  588.         }
  589.  
  590.     void putRight( Object _FAR & o )
  591.         {
  592.         BI_ODequeAsDoubleList::putRight( &o );
  593.         }
  594.  
  595.     virtual void flush( DeleteType dt = DefDelete )
  596.         {
  597.         BI_ODequeAsDoubleList::flush( dt );
  598.         }
  599.  
  600.     virtual int isEmpty() const
  601.         {
  602.         return BI_ODequeAsDoubleList::isEmpty();
  603.         }
  604.  
  605.     virtual countType getItemsInContainer() const
  606.         {
  607.         return BI_ODequeAsDoubleList::getItemsInContainer();
  608.         }
  609.  
  610.     void forEach( iterFuncType f, void _FAR*args )
  611.         {
  612.         BI_ODequeAsDoubleList::forEach( f, args );
  613.         }
  614.  
  615.     Object _FAR & firstThat( condFuncType f, void _FAR *args ) const
  616.         {
  617.         return ptrToRef(BI_ODequeAsDoubleList::firstThat( f, args ));
  618.         }
  619.  
  620.     Object _FAR & lastThat( condFuncType f, void _FAR *args ) const
  621.         {
  622.         return ptrToRef(BI_ODequeAsDoubleList::lastThat( f, args ));
  623.         }
  624.  
  625.     virtual ContainerIterator _FAR & initIterator() const;
  626.  
  627.     virtual classType isA() const
  628.         {
  629.         return dequeClass;
  630.         }
  631.  
  632.     virtual char _FAR *nameOf() const
  633.         {
  634.         return "BI_DequeAsDoubleList";
  635.         }
  636.  
  637. };
  638.  
  639. class _CLASSTYPE BI_TCDequeAsDoubleListIterator : public ContainerIterator
  640. {
  641.  
  642. public:
  643.  
  644.     BI_TCDequeAsDoubleListIterator( const BI_TCDequeAsDoubleList _FAR &o ) :
  645.         iter((const BI_ODequeAsDoubleList&)o)
  646.         {
  647.         }
  648.  
  649.     virtual operator int()
  650.         {
  651.         return int(iter);
  652.         }
  653.  
  654.     virtual Object _FAR & current()
  655.         {
  656.         return Object::ptrToRef(iter.current());
  657.         }
  658.  
  659.     virtual Object _FAR & operator ++ ( int )
  660.         {
  661.         return Object::ptrToRef(iter++);
  662.         }
  663.  
  664.     virtual Object _FAR & operator ++ ()
  665.         {
  666.         return Object::ptrToRef(++iter);
  667.         }
  668.  
  669.     virtual void restart()
  670.         {
  671.         iter.restart();
  672.         }
  673.  
  674. private:
  675.  
  676.     BI_ODequeAsDoubleListIterator iter;
  677.  
  678. };
  679.  
  680. inline ContainerIterator _FAR & BI_TCDequeAsDoubleList::initIterator() const
  681. {
  682.     return *new BI_TCDequeAsDoubleListIterator( *this );
  683. }
  684.  
  685. #endif  // TEMPLATES
  686.  
  687. #if defined( __BCOPT__ ) && !defined( _ALLOW_po )
  688. #pragma option -po.
  689. #endif
  690. #pragma option -Vo.
  691.  
  692. #endif  // __DEQUE_H
  693.  
  694.