home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / CLASSINC.PAK / QUEUES.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  16.2 KB  |  554 lines
  1. //----------------------------------------------------------------------------
  2. // Borland BIDS Container Library
  3. // Copyright (c) 1991, 1996 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   5.7  $
  6. //
  7. //----------------------------------------------------------------------------
  8. #if !defined( CLASSLIB_QUEUES_H )
  9. #define CLASSLIB_QUEUES_H
  10.  
  11. #if !defined( CLASSLIB_DEFS_H )
  12. #include <classlib/defs.h>
  13. #endif
  14.  
  15. #if !defined( CLASSLIB_DEQUES_H )
  16. #include <classlib/deques.h>
  17. #endif
  18.  
  19. #pragma option -Vo-
  20. #if defined( BI_CLASSLIB_NO_po )
  21. #pragma option -po-
  22. #endif
  23.  
  24. #if defined(BI_NAMESPACE)
  25. namespace ClassLib {
  26. #endif
  27.  
  28. /*------------------------------------------------------------------------*/
  29. /*                                                                        */
  30. /*  template <class T,class Alloc> class TMQueueAsVector                  */
  31. /*  template <class T,class Alloc> class TMQueueAsVectorIterator          */
  32. /*                                                                        */
  33. /*  Implements a managed queue of objects of type T, using a vector as    */
  34. /*  the underlying implementation.                                        */
  35. /*                                                                        */
  36. /*------------------------------------------------------------------------*/
  37.  
  38. template <class T,class Alloc> class TMQueueAsVectorIterator;
  39.  
  40. template <class T,class Alloc> class TMQueueAsVector :
  41.     private TMDequeAsVector<T,Alloc>
  42. {
  43.  
  44.     typedef TMDequeAsVector<T,Alloc> Parent;
  45.  
  46. public:
  47.  
  48.     friend class TMQueueAsVectorIterator<T,Alloc>;
  49.  
  50.     TMQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  51.         TMDequeAsVector<T,Alloc>(sz)
  52.         {
  53.         }
  54.  
  55.     const T& Peek() const
  56.         {
  57.         return Parent::PeekRight();
  58.         }
  59.  
  60.     T Get()
  61.         {
  62.         return Parent::GetRight();
  63.         }
  64.  
  65.     void Put( const T& t )
  66.         {
  67.         Parent::PutLeft( t );
  68.         }
  69.  
  70.     Parent::IterFunc;
  71.     Parent::CondFunc;
  72.     Parent::ForEach;
  73.     Parent::FirstThat;
  74.     Parent::LastThat;
  75.     Parent::Flush;
  76.     Parent::IsFull;
  77.     Parent::IsEmpty;
  78.     Parent::GetItemsInContainer;
  79.  
  80. #if defined( BI_OLDNAMES )
  81.     T get() { return Get(); }
  82.     void put( const T& t ) { Put(t); }
  83.     Parent::forEach;
  84.     Parent::firstThat;
  85.     Parent::lastThat;
  86.     Parent::flush;
  87.     Parent::isFull;
  88.     Parent::isEmpty;
  89.     Parent::getItemsInContainer;
  90. #endif  // BI_OLDNAMES
  91.  
  92. };
  93.  
  94. template <class T,class Alloc> class TMQueueAsVectorIterator :
  95.     public TMDequeAsVectorIterator<T,Alloc>
  96. {
  97.  
  98. public:
  99.  
  100.     TMQueueAsVectorIterator( const TMQueueAsVector<T,Alloc>& q ) :
  101.         TMDequeAsVectorIterator<T,Alloc>(q)
  102.         {
  103.         }
  104.  
  105. };
  106.  
  107. #if defined( BI_OLDNAMES )
  108. #define BI_MQueueAsVector TMQueueAsVector
  109. #define BI_MQueueAsVectorIterator TMQueueAsVectorIterator
  110. #endif
  111.  
  112. /*------------------------------------------------------------------------*/
  113. /*                                                                        */
  114. /*  template <class T> class TQueueAsVector                               */
  115. /*  template <class T> class TQueueAsVectorIterator                       */
  116. /*                                                                        */
  117. /*  Implements a queue of objects of type T, using a vector as            */
  118. /*  the underlying implementation and TStandardAllocator as its memory    */
  119. /*  manager.                                                              */
  120. /*                                                                        */
  121. /*------------------------------------------------------------------------*/
  122.  
  123. template <class T> class TQueueAsVector :
  124.     public TMQueueAsVector<T,TStandardAllocator>
  125. {
  126.  
  127. public:
  128.  
  129.     TQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  130.         TMQueueAsVector<T,TStandardAllocator>(sz)
  131.         {
  132.         }
  133.  
  134. };
  135.  
  136. template <class T> class TQueueAsVectorIterator :
  137.     public TMQueueAsVectorIterator<T,TStandardAllocator>
  138. {
  139.  
  140. public:
  141.  
  142.     TQueueAsVectorIterator( const TQueueAsVector<T>& q ) :
  143.         TMQueueAsVectorIterator<T,TStandardAllocator>(q)
  144.         {
  145.         }
  146.  
  147. };
  148.  
  149. #if defined( BI_OLDNAMES )
  150. #define BI_QueueAsVector TQueueAsVector
  151. #define BI_QueueAsVectorIterator TQueueAsVectorIterator
  152. #endif
  153.  
  154. /*------------------------------------------------------------------------*/
  155. /*                                                                        */
  156. /*  template <class T,class Alloc> class TMIQueueAsVector                 */
  157. /*  template <class T,class Alloc> class TMIQueueAsVectorIterator         */
  158. /*                                                                        */
  159. /*  Implements a managed queue of pointers to objects of type T,          */
  160. /*  using a vector as the underlying implementation.                      */
  161. /*                                                                        */
  162. /*------------------------------------------------------------------------*/
  163.  
  164. template <class T,class Alloc> class TMIQueueAsVectorIterator;
  165.  
  166. template <class T,class Alloc> class TMIQueueAsVector :
  167.     private TMIDequeAsVector<T,Alloc>
  168. {
  169.  
  170.     typedef TMIDequeAsVector<T,Alloc> Parent;
  171.  
  172. public:
  173.  
  174.     friend class TMIQueueAsVectorIterator<T,Alloc>;
  175.  
  176.     TMIQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  177.         TMIDequeAsVector<T,Alloc>(sz)
  178.         {
  179.         }
  180.  
  181.     T *Peek() const
  182.         {
  183.         return Parent::PeekRight();
  184.         }
  185.  
  186.     T *Get()
  187.         {
  188.         return Parent::GetRight();
  189.         }
  190.  
  191.     void Put( T *t )
  192.         {
  193.         Parent::PutLeft( t );
  194.         }
  195.  
  196.     Parent::IterFunc;
  197.     Parent::CondFunc;
  198.     Parent::IsFull;
  199.     Parent::IsEmpty;
  200.     Parent::GetItemsInContainer;
  201.     Parent::Flush;
  202.     Parent::ForEach;
  203.     Parent::FirstThat;
  204.     Parent::LastThat;
  205.     Parent::OwnsElements;
  206.  
  207. #if defined( BI_OLDNAMES )
  208.     T *peek() const { return Peek(); }
  209.     T *get() { return Get(); }
  210.     void put( T *t ) { Put(t); }
  211.     Parent::isFull;
  212.     Parent::isEmpty;
  213.     Parent::getItemsInContainer;
  214.     Parent::flush;
  215.     Parent::forEach;
  216.     Parent::firstThat;
  217.     Parent::lastThat;
  218.     Parent::ownsElements;
  219. #endif  // BI_OLDNAMES
  220.  
  221. };
  222.  
  223. template <class T,class Alloc> class TMIQueueAsVectorIterator :
  224.     public TMIDequeAsVectorIterator<T,Alloc>
  225. {
  226.  
  227. public:
  228.  
  229.     TMIQueueAsVectorIterator( const TMIQueueAsVector<T,Alloc>& q ) :
  230.         TMIDequeAsVectorIterator<T,Alloc>(q) {}
  231.  
  232. };
  233.  
  234. #if defined( BI_OLDNAMES )
  235. #define BI_MIQueueAsVector TMIQueueAsVector
  236. #define BI_MIQueueAsVectorIterator TMIQueueAsVectorIterator
  237. #endif
  238.  
  239. /*------------------------------------------------------------------------*/
  240. /*                                                                        */
  241. /*  template <class T> class TIQueueAsVector                              */
  242. /*  template <class T> class TIQueueAsVectorIterator                      */
  243. /*                                                                        */
  244. /*  Implements a queue of pointers to objects of type T,                  */
  245. /*  using a vector as the underlying implementation and                   */
  246. /*  TStandardAllocator as its memory manager.                             */
  247. /*                                                                        */
  248. /*------------------------------------------------------------------------*/
  249.  
  250. template <class T> class TIQueueAsVector :
  251.     public TMIQueueAsVector<T,TStandardAllocator>
  252. {
  253.  
  254. public:
  255.  
  256.     TIQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
  257.         TMIQueueAsVector<T,TStandardAllocator>(sz)
  258.         {
  259.         }
  260.  
  261. };
  262.  
  263. template <class T> class TIQueueAsVectorIterator :
  264.     public TMIQueueAsVectorIterator<T,TStandardAllocator>
  265. {
  266.  
  267. public:
  268.  
  269.     TIQueueAsVectorIterator( const TIQueueAsVector<T>& q ) :
  270.         TMIQueueAsVectorIterator<T,TStandardAllocator>(q)
  271.         {
  272.         }
  273.  
  274. };
  275.  
  276. #if defined( BI_OLDNAMES )
  277. #define BI_IQueueAsVector TIQueueAsVector
  278. #define BI_IQueueAsVectorIterator TIQueueAsVectorIterator
  279. #endif
  280.  
  281. /*------------------------------------------------------------------------*/
  282. /*                                                                        */
  283. /*  template <class T,class Alloc> class TMQueueAsDoubleList              */
  284. /*  template <class T,class Alloc> class TMQueueAsDoubleListIterator      */
  285. /*                                                                        */
  286. /*  Implements a managed queue of objects of type T, using a double       */
  287. /*  linked list as the underlying implementation.                         */
  288. /*                                                                        */
  289. /*------------------------------------------------------------------------*/
  290.  
  291. template <class T,class Alloc> class TMQueueAsDoubleListIterator;
  292.  
  293. template <class T,class Alloc> class TMQueueAsDoubleList :
  294.     private TMDequeAsDoubleList<T,Alloc>
  295. {
  296.  
  297.     typedef TMDequeAsDoubleList<T,Alloc> Parent;
  298.  
  299. public:
  300.  
  301.     friend class TMQueueAsDoubleListIterator<T,Alloc>;
  302.  
  303.     const T& Peek() const
  304.         {
  305.         return Parent::PeekRight();
  306.         }
  307.  
  308.     T Get()
  309.         {
  310.         return Parent::GetRight();
  311.         }
  312.  
  313.     void Put( const T& t )
  314.         {
  315.         Parent::PutLeft( t );
  316.         }
  317.  
  318.     Parent::IterFunc;
  319.     Parent::CondFunc;
  320.     Parent::IsFull;
  321.     Parent::IsEmpty;
  322.     Parent::GetItemsInContainer;
  323.     Parent::Flush;
  324.     Parent::ForEach;
  325.     Parent::FirstThat;
  326.     Parent::LastThat;
  327.  
  328. #if defined( BI_OLDNAMES )
  329.     T peek() const { return Peek(); }
  330.     T get() { return Get(); }
  331.     void put( const T& t ) { Put(t); }
  332.     Parent::isFull;
  333.     Parent::isEmpty;
  334.     Parent::getItemsInContainer;
  335.     Parent::flush;
  336.     Parent::forEach;
  337.     Parent::firstThat;
  338.     Parent::lastThat;
  339. #endif  // BI_OLDNAMES
  340.  
  341. };
  342.  
  343. template <class T,class Alloc> class TMQueueAsDoubleListIterator :
  344.     public TMDequeAsDoubleListIterator<T,Alloc>
  345. {
  346.  
  347. public:
  348.  
  349.     TMQueueAsDoubleListIterator( const TMQueueAsDoubleList<T,Alloc>& q ) :
  350.         TMDequeAsDoubleListIterator<T,Alloc>(q)
  351.         {
  352.         }
  353.  
  354. };
  355.  
  356. #if defined( BI_OLDNAMES )
  357. #define BI_QueueAsDoubleList TQueueAsDoubleList
  358. #define BI_QueueAsDoubleListIterator TQueueAsDoubleListIterator
  359. #endif
  360.  
  361. /*------------------------------------------------------------------------*/
  362. /*                                                                        */
  363. /*  template <class T> class TQueueAsDoubleList                           */
  364. /*  template <class T> class TQueueAsDoubleListIterator                   */
  365. /*                                                                        */
  366. /*  Implements a queue of objects of type T, using a double linked list   */
  367. /*  as the underlying implementation and TStandardAllocator as its        */
  368. /*  memory manager.                                                       */
  369. /*                                                                        */
  370. /*------------------------------------------------------------------------*/
  371.  
  372. template <class T> class TQueueAsDoubleList :
  373.     public TMQueueAsDoubleList<T,TStandardAllocator>
  374. {
  375. };
  376.  
  377. template <class T> class TQueueAsDoubleListIterator :
  378.     public TMQueueAsDoubleListIterator<T,TStandardAllocator>
  379. {
  380.  
  381. public:
  382.  
  383.     TQueueAsDoubleListIterator( const TQueueAsDoubleList<T>& q ) :
  384.         TMQueueAsDoubleListIterator<T,TStandardAllocator>(q)
  385.         {
  386.         }
  387.  
  388. };
  389.  
  390. #if defined( BI_OLDNAMES )
  391. #define BI_QueueAsDoubleList TQueueAsDoubleList
  392. #define BI_QueueAsDoubleListIterator TQueueAsDoubleListIterator
  393. #endif
  394.  
  395. /*------------------------------------------------------------------------*/
  396. /*                                                                        */
  397. /*  template <class T,class Alloc> class TMIQueueAsDoubleList             */
  398. /*  template <class T,class Alloc> class TMIQueueAsDoubleListIterator     */
  399. /*                                                                        */
  400. /*  Implements a managed queue of pointers to objects of type T,          */
  401. /*  using a double linked list as the underlying implementation.          */
  402. /*                                                                        */
  403. /*------------------------------------------------------------------------*/
  404.  
  405. template <class T,class Alloc> class TMIQueueAsDoubleListIterator;
  406.  
  407. template <class T,class Alloc> class TMIQueueAsDoubleList :
  408.     private TMIDequeAsDoubleList<T,Alloc>
  409. {
  410.  
  411.     typedef TMIDequeAsDoubleList<T,Alloc> Parent;
  412.  
  413. public:
  414.  
  415.     friend class TMIQueueAsDoubleListIterator<T,Alloc>;
  416.  
  417.     T *Peek() const
  418.         {
  419.         return Parent::PeekRight();
  420.         }
  421.  
  422.     T *Get()
  423.         {
  424.         return Parent::GetRight();
  425.         }
  426.  
  427.     void Put( T *t )
  428.         {
  429.         Parent::PutLeft( t );
  430.         }
  431.  
  432.     Parent::IterFunc;
  433.     Parent::CondFunc;
  434.     Parent::IsFull;
  435.     Parent::IsEmpty;
  436.     Parent::GetItemsInContainer;
  437.     Parent::Flush;
  438.     Parent::ForEach;
  439.     Parent::FirstThat;
  440.     Parent::LastThat;
  441.     Parent::OwnsElements;
  442.  
  443. #if defined( BI_OLDNAMES )
  444.     T *peek() const { return Peek(); }
  445.     T *get() { return Get(); }
  446.     void put( T *t ) { Put(t); }
  447.     Parent::isFull;
  448.     Parent::isEmpty;
  449.     Parent::getItemsInContainer;
  450.     Parent::flush;
  451.     Parent::forEach;
  452.     Parent::firstThat;
  453.     Parent::lastThat;
  454.     Parent::ownsElements;
  455. #endif  // BI_OLDNAMES
  456.  
  457. };
  458.  
  459. template <class T,class Alloc> class TMIQueueAsDoubleListIterator :
  460.     public TMIDequeAsDoubleListIterator<T,Alloc>
  461. {
  462.  
  463. public:
  464.  
  465.     TMIQueueAsDoubleListIterator( const TMIQueueAsDoubleList<T,Alloc>& q ) :
  466.         TMIDequeAsDoubleListIterator<T,Alloc>(q) {}
  467.  
  468. };
  469.  
  470. #if defined( BI_OLDNAMES )
  471. #define BI_MIQueueAsDoubleList TMIQueueAsDoubleList
  472. #define BI_MIQueueAsDoubleListIterator TMIQueueAsDoubleListIterator
  473. #endif
  474.  
  475. /*------------------------------------------------------------------------*/
  476. /*                                                                        */
  477. /*  template <class T> class TIQueueAsDoubleList                          */
  478. /*  template <class T> class TIQueueAsDoubleListIterator                  */
  479. /*                                                                        */
  480. /*  Implements a queue of pointers to objects of type T, using a double   */
  481. /*  linked list as the underlying implementation and TStandardAllocator   */
  482. /*  as its memory manager.                                                */
  483. /*                                                                        */
  484. /*------------------------------------------------------------------------*/
  485.  
  486. template <class T> class TIQueueAsDoubleList :
  487.     public TMIQueueAsDoubleList<T,TStandardAllocator>
  488. {
  489. };
  490.  
  491. template <class T> class TIQueueAsDoubleListIterator :
  492.     public TMIQueueAsDoubleListIterator<T,TStandardAllocator>
  493. {
  494.  
  495. public:
  496.  
  497.     TIQueueAsDoubleListIterator( const TIQueueAsDoubleList<T>& q ) :
  498.         TMIQueueAsDoubleListIterator<T,TStandardAllocator>(q) {}
  499.  
  500. };
  501.  
  502. #if defined( BI_OLDNAMES )
  503. #define BI_IQueueAsDoubleList TIQueueAsDoubleList
  504. #define BI_IQueueAsDoubleListIterator TIQueueAsDoubleListIterator
  505. #endif
  506.  
  507. /*------------------------------------------------------------------------*/
  508. /*                                                                        */
  509. /*  template <class T> class TQueue                                       */
  510. /*  template <class T> class TQueueIterator                               */
  511. /*                                                                        */
  512. /*  Easy names for TQueueAsVector and TQueueAsVectorIterator              */
  513. /*                                                                        */
  514. /*------------------------------------------------------------------------*/
  515.  
  516. template <class T> class TQueue :
  517.     public TQueueAsVector<T>
  518. {
  519.  
  520. public:
  521.  
  522.     TQueue( unsigned max = DEFAULT_QUEUE_SIZE ) :
  523.         TQueueAsVector<T>( max )
  524.         {
  525.         }
  526.  
  527. };
  528.  
  529. template <class T> class TQueueIterator :
  530.     public TQueueAsVectorIterator<T>
  531. {
  532.  
  533. public:
  534.  
  535.  
  536.     TQueueIterator( const TQueue<T>& a ) :
  537.         TQueueAsVectorIterator<T>(a)
  538.         {
  539.         }
  540.  
  541. };
  542.  
  543. #if defined(BI_NAMESPACE)
  544. }   // namespace ClassLib
  545. #endif
  546.  
  547. #if defined( BI_CLASSLIB_NO_po )
  548. #pragma option -po.
  549. #endif
  550.  
  551. #pragma option -Vo.
  552.  
  553. #endif  // CLASSLIB_QUEUES_H
  554.