home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c063 / 1.ddi / CLASSINC.ZIP / QUEUES.H < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-18  |  12.3 KB  |  446 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  QUEUES.H                                                              */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1991                                  */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __QUEUES_H )
  11. #define __QUEUES_H
  12.  
  13. #if !defined( ___DEFS_H )
  14. #include <_defs.h>
  15. #endif  // ___DEFS_H
  16.  
  17. #if !defined( __DEQUES_H )
  18. #include <Deques.h>
  19. #endif  // __DEQUES_H
  20.  
  21. /*------------------------------------------------------------------------*/
  22. /*                                                                        */
  23. /*  template <class T> class BI_QueueAsVector                             */
  24. /*                                                                        */
  25. /*  Implements a queue of objects of type T, using a vector as            */
  26. /*  the underlying implementation.                                        */
  27. /*                                                                        */
  28. /*------------------------------------------------------------------------*/
  29.  
  30. template <class T> class _CLASSTYPE BI_QueueAsVector :
  31.     public BI_DequeAsVector<T>
  32. {
  33.  
  34. public:
  35.  
  36.     BI_QueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  37.         BI_DequeAsVector<T>(sz)
  38.         {
  39.         }
  40.  
  41.     T get()
  42.         {
  43.         return BI_DequeAsVector<T>::getRight();
  44.         }
  45.  
  46.     void put( T t )
  47.         {
  48.         BI_DequeAsVector<T>::putLeft( t );
  49.         }
  50.  
  51. private:
  52.  
  53.     T getLeft();
  54.     T getRight();
  55.  
  56.     void putLeft( T );
  57.     void putRight( T );
  58.  
  59. };
  60.  
  61. template <class T> class _CLASSTYPE BI_QueueAsVectorIterator :
  62.     public BI_DequeAsVectorIterator<T>
  63. {
  64.  
  65. public:
  66.  
  67.     BI_QueueAsVectorIterator( const BI_DequeAsVector<T> _FAR &q ) :
  68.         BI_DequeAsVectorIterator<T>(q) {}
  69.  
  70. };
  71.  
  72. /*------------------------------------------------------------------------*/
  73. /*                                                                        */
  74. /*  template <class T> class BI_IQueueAsVector                            */
  75. /*                                                                        */
  76. /*  Implements a queue of pointers to objects of type T,                  */
  77. /*  using a vector as the underlying implementation.                      */
  78. /*                                                                        */
  79. /*------------------------------------------------------------------------*/
  80.  
  81. template <class T> class _CLASSTYPE BI_IQueueAsVector :
  82.     public BI_IDequeAsVector<T>
  83. {
  84.  
  85. public:
  86.  
  87.     BI_IQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  88.         BI_IDequeAsVector<T>(sz)
  89.         {
  90.         }
  91.  
  92.     T _FAR *get()
  93.         {
  94.         return BI_IDequeAsVector<T>::getRight();
  95.         }
  96.  
  97.     void put( T _FAR *t )
  98.         {
  99.         BI_IDequeAsVector<T>::putLeft( t );
  100.         }
  101.  
  102. private:
  103.  
  104.     T _FAR *getLeft();
  105.     T _FAR *getRight();
  106.  
  107.     void putLeft( T _FAR * );
  108.     void putRight( T _FAR * );
  109.  
  110. };
  111.  
  112. template <class T> class _CLASSTYPE BI_IQueueAsVectorIterator :
  113.     public BI_IDequeAsVectorIterator<T>
  114. {
  115.  
  116. public:
  117.  
  118.     BI_IQueueAsVectorIterator( const BI_IDequeAsVector<T> _FAR &q ) :
  119.         BI_IDequeAsVectorIterator<T>(q) {}
  120.  
  121. };
  122.  
  123. /*------------------------------------------------------------------------*/
  124. /*                                                                        */
  125. /*  class BI_OQueueAsVector                                               */
  126. /*                                                                        */
  127. /*  Implements a queue of pointers to Object,                             */
  128. /*  using a vector as the underlying implementation.                      */
  129. /*                                                                        */
  130. /*------------------------------------------------------------------------*/
  131.  
  132. class _CLASSTYPE BI_OQueueAsVector : public BI_ODequeAsVector
  133. {
  134.  
  135. public:
  136.  
  137.     BI_OQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  138.         BI_ODequeAsVector(sz)
  139.         {
  140.         }
  141.  
  142.     Object _FAR *get()
  143.         {
  144.         return BI_ODequeAsVector::getRight();
  145.         }
  146.  
  147.     void put( Object _FAR *t )
  148.         {
  149.         BI_ODequeAsVector::putLeft( t );
  150.         }
  151.  
  152. private:
  153.  
  154.     Object _FAR *getLeft();
  155.     Object _FAR *getRight();
  156.  
  157.     void putLeft( Object _FAR * );
  158.     void putRight( Object _FAR * );
  159.  
  160. };
  161.  
  162. class _CLASSTYPE BI_OQueueAsVectorIterator :
  163.     public BI_ODequeAsVectorIterator
  164. {
  165.  
  166. public:
  167.  
  168.     BI_OQueueAsVectorIterator( const BI_ODequeAsVector _FAR &q ) :
  169.         BI_ODequeAsVectorIterator(q) {}
  170.  
  171. };
  172.  
  173. /*------------------------------------------------------------------------*/
  174. /*                                                                        */
  175. /*  class BI_TCQueueAsVector                                              */
  176. /*                                                                        */
  177. /*  Implements an Object queue, with the full semantics of                */
  178. /*  the BC 2.0 style queue, using a vector as the underlying              */
  179. /*  implementation.                                                       */
  180. /*                                                                        */
  181. /*------------------------------------------------------------------------*/
  182.  
  183. class _CLASSTYPE BI_TCQueueAsVector : public BI_TCDequeAsVector
  184. {
  185.  
  186. public:
  187.  
  188.     BI_TCQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  189.         BI_TCDequeAsVector(sz)
  190.         {
  191.         }
  192.  
  193.     Object _FAR & get()
  194.         {
  195.         return BI_TCDequeAsVector::getRight();
  196.         }
  197.  
  198.     void put( Object _FAR & t )
  199.         { BI_TCDequeAsVector::putLeft( t );
  200.         }
  201.  
  202.     virtual classType isA() const
  203.         {
  204.         return queueClass;
  205.         }
  206.  
  207.     virtual char _FAR *nameOf() const
  208.         {
  209.         return "BI_TCQueueAsDoubleList";
  210.         }
  211.  
  212.     virtual ContainerIterator _FAR & initIterator() const;
  213.  
  214. private:
  215.  
  216.     Object _FAR & getLeft();
  217.     Object _FAR & getRight();
  218.  
  219.     void putLeft( Object _FAR & );
  220.     void putRight( Object _FAR & );
  221.  
  222. };
  223.  
  224. class _CLASSTYPE BI_TCQueueAsVectorIterator :
  225.     public BI_TCDequeAsVectorIterator
  226. {
  227.  
  228. public:
  229.  
  230.     BI_TCQueueAsVectorIterator( const BI_TCQueueAsVector _FAR &q ) :
  231.         BI_TCDequeAsVectorIterator(q)
  232.         {
  233.         }
  234.  
  235. };
  236.  
  237. inline ContainerIterator _FAR & BI_TCQueueAsVector::initIterator() const
  238. {
  239.     return *new BI_TCQueueAsVectorIterator( *this );
  240. }
  241.  
  242. /*------------------------------------------------------------------------*/
  243. /*                                                                        */
  244. /*  template <class T> class BI_QueueAsDoubleList                         */
  245. /*                                                                        */
  246. /*  Implements a queue of objects of type T, using a double linked list   */
  247. /*  as the underlying implementation.                                     */
  248. /*                                                                        */
  249. /*------------------------------------------------------------------------*/
  250.  
  251. template <class T> class _CLASSTYPE BI_QueueAsDoubleList :
  252.     public BI_DequeAsDoubleList<T>
  253. {
  254.  
  255. public:
  256.  
  257.     T get()
  258.         {
  259.         return BI_DequeAsDoubleList<T>::getRight();
  260.         }
  261.  
  262.     void put( T t )
  263.         {
  264.         BI_DequeAsDoubleList<T>::putLeft( t );
  265.         }
  266.  
  267. private:
  268.  
  269.     T getLeft();
  270.     T getRight();
  271.  
  272.     void putLeft( T );
  273.     void putRight( T );
  274.  
  275. };
  276.  
  277. template <class T> class _CLASSTYPE BI_QueueAsDoubleListIterator :
  278.     public BI_DequeAsDoubleListIterator<T>
  279. {
  280.  
  281. public:
  282.  
  283.     BI_QueueAsDoubleListIterator( const BI_QueueAsDoubleList<T> _FAR & q ) :
  284.         BI_DequeAsDoubleListIterator<T>(q)
  285.         {
  286.         }
  287.  
  288. };
  289.  
  290. /*------------------------------------------------------------------------*/
  291. /*                                                                        */
  292. /*  template <class T> class BI_IQueueAsDoubleList                        */
  293. /*                                                                        */
  294. /*  Implements a queue of pointers to objects of type T,                  */
  295. /*  using a double linked list as the underlying implementation.          */
  296. /*                                                                        */
  297. /*------------------------------------------------------------------------*/
  298.  
  299. template <class T> class _CLASSTYPE BI_IQueueAsDoubleList :
  300.     public BI_IDequeAsDoubleList<T>
  301. {
  302.  
  303. public:
  304.  
  305.     T _FAR *get()
  306.         {
  307.         return BI_IDequeAsDoubleList<T>::getRight();
  308.         }
  309.  
  310.     void put( T _FAR *t )
  311.         {
  312.         BI_IDequeAsDoubleList<T>::putLeft( t );
  313.         }
  314.  
  315. private:
  316.  
  317.     T _FAR *getLeft();
  318.     T _FAR *getRight();
  319.  
  320.     void putLeft( T _FAR * );
  321.     void putRight( T _FAR * );
  322.  
  323. };
  324.  
  325. template <class T> class _CLASSTYPE BI_IQueueAsDoubleListIterator :
  326.     public BI_IDequeAsDoubleListIterator<T>
  327. {
  328.  
  329. public:
  330.  
  331.     BI_IQueueAsDoubleListIterator( const BI_IQueueAsDoubleList<T> _FAR& q ) :
  332.         BI_IDequeAsDoubleListIterator<T>(q) {}
  333.  
  334. };
  335.  
  336. /*------------------------------------------------------------------------*/
  337. /*                                                                        */
  338. /*  class BI_OQueueAsDoubleList                                           */
  339. /*                                                                        */
  340. /*  Implements a queue of pointers to Object,                             */
  341. /*  using a double linked list as the underlying implementation.          */
  342. /*                                                                        */
  343. /*------------------------------------------------------------------------*/
  344.  
  345. class _CLASSTYPE BI_OQueueAsDoubleList : public BI_ODequeAsDoubleList
  346. {
  347.  
  348. public:
  349.  
  350.     Object _FAR *get()
  351.         {
  352.         return BI_ODequeAsDoubleList::getRight();
  353.         }
  354.  
  355.     void put( Object _FAR *t )
  356.         {
  357.         BI_ODequeAsDoubleList::putLeft( t );
  358.         }
  359.  
  360. private:
  361.  
  362.     Object _FAR *getLeft();
  363.     Object _FAR *getRight();
  364.  
  365.     void putLeft( Object _FAR * );
  366.     void putRight( Object _FAR * );
  367.  
  368. };
  369.  
  370. class _CLASSTYPE BI_OQueueAsDoubleListIterator :
  371.     public BI_ODequeAsDoubleListIterator
  372. {
  373.  
  374. public:
  375.  
  376.     BI_OQueueAsDoubleListIterator( const BI_OQueueAsDoubleList _FAR & q ) :
  377.         BI_ODequeAsDoubleListIterator(q) {}
  378.  
  379. };
  380.  
  381. /*------------------------------------------------------------------------*/
  382. /*                                                                        */
  383. /*  class BI_TCQueueAsDoubleList                                          */
  384. /*                                                                        */
  385. /*  Implements an Object queue, with the full semantics of                */
  386. /*  the BC 2.0 style queue, using a double linked list as the underlying  */
  387. /*  implementation.                                                       */
  388. /*                                                                        */
  389. /*------------------------------------------------------------------------*/
  390.  
  391. class _CLASSTYPE BI_TCQueueAsDoubleList : public BI_TCDequeAsDoubleList
  392. {
  393.  
  394. public:
  395.  
  396.     Object _FAR & get()
  397.         {
  398.         return BI_TCDequeAsDoubleList::getRight();
  399.         }
  400.  
  401.     void put( Object _FAR & t )
  402.         {
  403.         BI_TCDequeAsDoubleList::putLeft( t );
  404.         }
  405.  
  406.     virtual classType isA() const
  407.         {
  408.         return queueClass;
  409.         }
  410.  
  411.     virtual char _FAR *nameOf() const
  412.         {
  413.         return "BI_TCQueueAsDoubleList";
  414.         }
  415.  
  416.     virtual ContainerIterator _FAR & initIterator() const;
  417.  
  418. private:
  419.  
  420.     Object _FAR & getLeft();
  421.     Object _FAR & getRight();
  422.  
  423.     void putLeft( Object _FAR & );
  424.     void putRight( Object _FAR & );
  425.  
  426. };
  427.  
  428. class _CLASSTYPE BI_TCQueueAsDoubleListIterator :
  429.     public BI_TCDequeAsDoubleListIterator
  430. {
  431.  
  432. public:
  433.  
  434.     BI_TCQueueAsDoubleListIterator( const BI_TCQueueAsDoubleList _FAR &q ) :
  435.         BI_TCDequeAsDoubleListIterator(q) {}
  436.  
  437. };
  438.  
  439. inline ContainerIterator _FAR & BI_TCQueueAsDoubleList::initIterator() const
  440. {
  441.     return *new BI_TCQueueAsDoubleListIterator( *this );
  442. }
  443.  
  444. #endif  // __QUEUES_H
  445.  
  446.