cbqueue.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:20k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. /*******************************************************************
  36.  *
  37.  * NAME: CBQueue.h
  38.  *
  39.  * CLASS:
  40.  * CByteQueue class declaration.
  41.  *
  42.  * DESCRIPTION:
  43.  * Class declaration for a 'Queue of bytes' object.
  44.  * This object is meant to serve the needs of either clients as
  45.  * an abstract object, or of subclasses as a base object.
  46.  *
  47.  * That is a client may use this instances of this class directly,
  48.  * or they may inherit from the class and provide expanded
  49.  * functionality.
  50.  *
  51.  * NOTES:
  52.  * See the CPQueue.h file for an example of a minimal subclass
  53.  * that changes the size of the queue'd items.
  54.  *
  55.  * The only time a subclass MUST provide a virtual override
  56.  * is for the GetElementSize() method when the subclass changes
  57.  * the size of queued elements.  All other virtual methods
  58.  * provide fully functional default behavior that will ramain
  59.  * functional even when the ElementSize changes.
  60.  *
  61.  * The assignment operator is one of the few cases where a
  62.  * subclass will need to provide new functionality by virtue of
  63.  * inheriting from the base.  Subclasses should use the base
  64.  * method for assigning the bits of the base class prior to
  65.  * performing their own assignment related operations.
  66.  *
  67.  *******************************************************************/
  68. #if !defined( _CBQUEUE_H )
  69. #define _CBQUEUE_H
  70.  
  71. #include "hxtypes.h"
  72. #include "hxassert.h"
  73. #if !defined( NULL )
  74. #define NULL 0
  75. #endif
  76. #if !defined( FALSE )
  77. #define FALSE 0
  78. #endif // !defined( FALSE )
  79. #if !defined( TRUE )
  80. #define TRUE !FALSE
  81. #endif // !defined( TRUE )
  82. class CByteQueue
  83. {
  84. /*
  85.  * Our public interface.
  86.  * These are the methods we export to the world.
  87.  * These methods are primarily used by our clients.
  88.  */
  89. public:
  90.    /*
  91. ** CByteQueue( nSize, nGranularity )
  92. *
  93. *  PARAMETERS:
  94. * nSize Size of the bytequeue in bytes.
  95. * nGranularity For subclasses we ensure our size is a multiple of this.
  96. *
  97. *  DESCRIPTION:
  98. * Parameterized constructor.
  99. * This is the primary means of creating an instance of CByteQueue.
  100. *
  101. *  RETURNS:
  102. * void
  103. */
  104. CByteQueue( UINT16 nSize, UINT16 nGranularity = 1);
  105.    /*
  106. ** CByteQueue( rReferent )
  107. *
  108. *  PARAMETERS:
  109. * rReferent Constant reference to another CByteQueue object.
  110. *
  111. *  DESCRIPTION:
  112.     * Copy constructor (ctor).  Copies a CByteQueue into
  113. * another CByteQueue that is under construction.
  114. * This guy is called in construction situations like this:
  115. * CByteQueue rQueueOrig( 10 ); // Call param ctor
  116. * CByteQueue rQueueCopy = rQueueOrig; // Call copy ctor
  117. *
  118. *  RETURNS:
  119. * void
  120. */
  121. CByteQueue( const CByteQueue &rReferent );
  122.    /*********************************************************
  123.     * Here are are non-virtual methods that provide
  124. * primitive functionality to all queues.
  125. *********************************************************/
  126.    /*
  127. ** GetQueuedItemCount()
  128. *
  129. *  PARAMETERS:
  130. * void
  131. *
  132. *  DESCRIPTION:
  133. * Returns a count of the items we have queue'd up.
  134. * This function is accurate even in subclasses with
  135. * elements that are a different size from a UCHAR.
  136. *
  137. *  RETURNS:
  138. * Returns the number of ITEMS we have queued up.
  139. *
  140. */
  141. UINT16 GetQueuedItemCount() const
  142. {
  143. HX_ASSERT( this );
  144. HX_ASSERT( IsQueueValid() );    
  145. return( Base_GetUsedByteCount() / GetElementSize() );
  146. }
  147.    /*
  148. ** UINT16 GetAvailableElements()
  149. *
  150. *  PARAMETERS:
  151. * void
  152. *
  153. *  DESCRIPTION:
  154.     * Returns the number of ITEMS we can EnQueue w/o failing.
  155. *
  156. *  RETURNS:
  157. * 0 if the queue is full
  158. * non-zero to indicate how many ITEMS we can EnQueue.
  159. */
  160. UINT16 GetAvailableElements() const
  161. {
  162. HX_ASSERT( this );
  163. HX_ASSERT( IsQueueValid() );    
  164. return( Base_GetAvailableBytes() / GetElementSize() );
  165. }
  166.    /*
  167. ** UINT16 GetMaxAvailableElements()
  168. *
  169. *  PARAMETERS:
  170. * void
  171. *
  172. *  DESCRIPTION:
  173. * Returns the number of ITEMS we can EnQueue w/o failing AFTER 
  174. * we have grown the queue to its Maximum size.
  175. *
  176. *  RETURNS:
  177. * 0 if the queue is full AND there is no more room to grow
  178. * beyond the max size
  179. * non-zero to indicate how many ITEMS we can EnQueue.
  180. */
  181. UINT16 GetMaxAvailableElements() const
  182. {
  183. HX_ASSERT( this );
  184. HX_ASSERT( IsQueueValid() );    
  185. return( Base_GetMaxAvailableBytes() / GetElementSize() );
  186. }
  187.    /*
  188. ** BOOL IsEmpty()
  189. *
  190. *  PARAMETERS:
  191. * void
  192. *
  193. *  DESCRIPTION:
  194. * Tells us if the queue is empty.
  195. *
  196. *  RETURNS:
  197.     * Returns TRUE if the queue is empty.
  198. *
  199. */
  200. BOOL IsEmpty() const
  201. {
  202. HX_ASSERT( this );
  203. HX_ASSERT( IsQueueValid() );    
  204. return( m_pTail == m_pHead );
  205. }
  206.    /*
  207. ** CByteQueue &operator=( rReferent )
  208. *
  209. *  PARAMETERS:
  210. * Constant reference to the CByteQueue object we are assigning from
  211. * (the rValue).
  212. *
  213. *  DESCRIPTION:
  214.     * Assignment operator.
  215. * This guy gets called when we assign a CByteQueue.
  216. * This guy creates a fully functional copy of the source queue.
  217. *
  218. * Subclasses that want an assignment operator SHOULD redefine
  219. * this guy, but they should use the base method to copy the 
  220. * bits of the base class.
  221. *
  222. *  RETURNS:
  223. * A reference to the object we are assigning into.
  224. */
  225. CByteQueue &operator=( const CByteQueue &rReferent );
  226.    /*
  227. ** UINT16 PeekAt( nIndex, pOutBuffer )
  228. *
  229. *  PARAMETERS:
  230. * nIndex The nIndex'th object from the head of the queue
  231. * that we are interested in.
  232. * pOutBuffer Pointer to the buffer to receive the contents of the
  233. * element.
  234. *
  235. *  DESCRIPTION:
  236.     * Peeks at a particular index off of the first element in the queue.
  237.     * The index is 0 based, hence an index of 0 will indicate the queue
  238.     * Head element.
  239. * Will copy the element of size GetElementSize() into the pOutBuffer.
  240. * *pbIsValid is set to FALSE if the element is not valid data.
  241. * Notice that the client needn't redifine this guy if the default
  242. * is satisfactory.
  243. * In particular this method will remain valid even across changes
  244. * of object size in the subclass.
  245. * The client will only NEED to imlement an override if they need
  246. * to provide another level of indirection.
  247. *
  248. *  RETURNS:
  249. * Returns the number of bytes copied into pOutBuffer.
  250. * 0 if nIndex specifies an invalid position in the queue.
  251. * (for instance if nIndex is 3, but there are only 2 elements
  252. * queued up we wil return 0)
  253. */
  254. UINT16 PeekAt( UINT16 nIndex, void *pOutBuffer ) const;
  255.    /*
  256. ** FlushQueue()
  257. *
  258. *  PARAMETERS:
  259. * void
  260. *
  261. *  DESCRIPTION:
  262.     * Instantly flush all elements from the queue.
  263. *
  264. *  RETURNS:
  265. * void
  266. */
  267. void FlushQueue()
  268. {
  269. HX_ASSERT( this );
  270. HX_ASSERT( IsQueueValid() );    
  271. Base_SetEmpty();
  272. }
  273.    /*********************************************************
  274.     * The rest of these public methods are virtual.
  275. *
  276. * HOWEVER, the default behavior is will remain fully
  277. * functional across all changes in object size.
  278. *
  279. * The only reason to provide overrides in subclasses
  280. * is to provide additional behavior.  If you do
  281. * implement an override make sure it calls the base
  282. * virtual method.
  283. *********************************************************/
  284.    /*
  285. ** UINT16 GetElementSize()
  286. *
  287. *  PARAMETERS:
  288. * void
  289. *
  290. *  DESCRIPTION:
  291. * Subclasses that redefine the element size MUST provide
  292. * an implementation for this.
  293. *
  294. *  RETURNS:
  295. * The queue element size.
  296. * For a queue of pointers we'd return sizeof( void * ).
  297. */
  298. virtual UINT16 GetElementSize() const
  299. {
  300. HX_ASSERT( this );
  301. HX_ASSERT( IsQueueValid() );    
  302. return( sizeof( UCHAR ) );
  303. }
  304.    /*
  305. ** ~CByteQueue()
  306. *
  307. *  PARAMETERS:
  308. * void
  309. *
  310. *  DESCRIPTION:
  311. * Destructor
  312. * Notice that this is a virtual destructor.  
  313. * The base class CByteQueue will delete the buffer.
  314. * The subclass need only implement on override if they
  315. * need additional cleanup besides the buffer.
  316. *
  317. *  RETURNS:
  318. * void
  319. */
  320. virtual ~CByteQueue();
  321.    /*
  322. ** BOOL IsQueueValid()
  323. *
  324. *  PARAMETERS:
  325. * void
  326. *
  327. *  DESCRIPTION:
  328. * This method allows the client to test the queue object for
  329. * validity.  The base class implements default behavior that
  330. * tests it's internal buffer pointers. 
  331. * The subclass will only need to implement an override if they
  332. * have additional validity checks.
  333. *
  334. * Any override of this funcion MUST return the logical AND of
  335. * it's validity checks and the checks of the base method.
  336. * Sort of like:
  337. * return( CByteQueue::IsQueueValid() && CSubClass::IsQueueValid() )
  338. *
  339. *  RETURNS:
  340. * TRUE If the queue is valid.
  341. * FALSE If there is an error in the queue members.
  342. */
  343. virtual BOOL IsQueueValid() const;
  344.    /*
  345. ** UINT16 DeQueue( pOutBuffer, nItemCount )
  346. *
  347. *  PARAMETERS:
  348. * pOutBuffer Pointer to buffer to receive bytes we're pulling
  349. * out of the queue.
  350. * nItemCount Number of items we want to dequeue.
  351. *
  352. *  DESCRIPTION:
  353. * One of our primary operations.
  354. * The client can redefine this function, but it is NOT necessary
  355. * as the default implementation will suffice for most cases.
  356. * In particular this method will remain valid even across changes
  357. * of object size in subclasses.
  358. * The client will only NEED to imlement an override if they need
  359. * to perform additional processing besides the block move of
  360. * bits.
  361. *
  362. *  RETURNS:
  363. * Number of bytes read out of the queue.
  364. */
  365. virtual UINT16 DeQueue( void *pOutBuffer, UINT16 nItemCount )
  366. {
  367. HX_ASSERT( this );
  368. HX_ASSERT( IsQueueValid() );
  369. HX_ASSERT( pOutBuffer );
  370. if (GetElementSize() > 1)
  371. {
  372. return( Base_DeQueueBytes( pOutBuffer, nItemCount * GetElementSize() ) );
  373. }
  374. else
  375. {
  376. return( Base_DeQueueBytes( pOutBuffer, nItemCount ) );
  377. }
  378. }
  379.    /*
  380. ** UINT16 EnQueue( pInBuffer, nItemCount )
  381. *
  382. *  PARAMETERS:
  383. * pInBuffer Pointer to bytes we want to enqueue.
  384. * nItemCount Number of items we want to enqueue.
  385. *
  386. *  DESCRIPTION:
  387.     * One of our primary operations.
  388. * The client can redefine this function, but it is NOT necessary
  389. * as the default implementation will suffice for most cases.
  390. * In particular this method will remain valid even across changes
  391. * of object size in subclasses.
  392. * The client will only NEED to imlement an override if they need
  393. * to perform additional processing besides the block move of
  394. * bits.
  395. *
  396. *  RETURNS:
  397. * 0 If there was not enough room to EnQueue() all the items 
  398. * specified.
  399. * Non-Zero  To indicate that all items specified were enqueue'd.
  400. *
  401. */
  402. virtual UINT16 EnQueue( void *pInBuffer, UINT16 nItemCount )
  403. {
  404. HX_ASSERT( this );
  405. HX_ASSERT( IsQueueValid() );
  406. HX_ASSERT( pInBuffer );
  407. if (GetElementSize() > 1)
  408. {
  409. return( Base_EnQueueBytes( pInBuffer, nItemCount * GetElementSize() ) );
  410. }
  411. else
  412. {
  413. return( Base_EnQueueBytes( pInBuffer, nItemCount ) );
  414. }
  415. }
  416. /*
  417.  * Grow the queue to twice its size or at least big enough to hold n more,
  418.  * whichever is greater.  Returns 1 for good, 0 for bad.
  419.  */
  420. int Grow(UINT16 nItems);
  421. void SetMaxSize(UINT16 ulMax);
  422. /*
  423.  * Protected primitives for accessing the buffer and it's 
  424.  * pointers directly.
  425.  * These methods are available to our subclasses, but NOT to our
  426.  * clients.
  427.  */
  428. protected:
  429.    /*
  430. ** UINT16 Base_GetBufferSize()
  431. *
  432. *  PARAMETERS:
  433. * void
  434. *
  435. *  DESCRIPTION:
  436.     * Returns the actual allocated size of the buffer.
  437. *
  438. *  RETURNS:
  439. * Size of the allocated buffer.
  440. */
  441. UINT16 Base_GetBufferSize() const
  442. {
  443. HX_ASSERT( this );
  444. return( m_nSize );
  445. }
  446.    /*
  447. ** UINT16 Base_GetMaxBufferSize()
  448. *
  449. *  PARAMETERS:
  450. * void
  451. *
  452. *  DESCRIPTION:
  453. * Returns the max size of the queue.
  454. *
  455. *  RETURNS:
  456. * Returns the max size of the queue.
  457. */
  458. UINT16 Base_GetMaxBufferSize() const
  459. {
  460. HX_ASSERT( this );
  461. return( m_nMaxSize );
  462. }
  463.    /*
  464. ** UINT16 Base_GetUsedByteCount()
  465. *
  466. *  PARAMETERS:
  467. * void
  468. *
  469. *  DESCRIPTION:
  470. * Returns the actual number of bytes we've enqueued.
  471. *
  472. *  RETURNS:
  473. * Number of bytes in USE in the queue.
  474. */
  475. UINT16 Base_GetUsedByteCount() const
  476. {
  477. LONG32 iItemCount;
  478. HX_ASSERT( this );
  479. HX_ASSERT( IsQueueValid() );    
  480. iItemCount = (LONG32)(m_pTail - m_pHead);
  481. // If iItemCount < 0 then we need to add m_nSize
  482. iItemCount += (iItemCount < 0) ? Base_GetBufferSize() : 0;
  483. HX_ASSERT(iItemCount <= (LONG32)Base_GetBufferSize());
  484. return( (UINT16)iItemCount );
  485. }
  486.    /*
  487. ** UINT16 Base_GetAvailableBytes()
  488. *
  489. *  PARAMETERS:
  490. * void
  491. *
  492. *  DESCRIPTION:
  493. * Returns the number of bytes we can enqueue w/o failing.
  494. *
  495. *  RETURNS:
  496. * Returns the number of bytes we can enqueue w/o failing.
  497. */
  498. UINT16 Base_GetAvailableBytes() const
  499. {
  500. HX_ASSERT( this );
  501. HX_ASSERT( IsQueueValid() );    
  502. return( Base_GetBufferSize() - Base_GetUsedByteCount() - 1 );
  503. }
  504.    /*
  505. ** UINT16 Base_GetMaxAvailableBytes()
  506. *
  507. *  PARAMETERS:
  508. * void
  509. *
  510. *  DESCRIPTION:
  511. * Returns the number of bytes we can enqueue w/o failing AFTER
  512. * the queue has been grown to its maximum capacity.
  513. *
  514. *  RETURNS:
  515. * Returns the number of bytes we can enqueue w/o failing.
  516. */
  517. UINT16 Base_GetMaxAvailableBytes() const
  518. {
  519. HX_ASSERT( this );
  520. HX_ASSERT( IsQueueValid() );    
  521. return( Base_GetMaxBufferSize() - Base_GetUsedByteCount() - 1 );
  522. }
  523.    /*
  524. ** UINT16 Base_EnQueueBytes( pInBuffer, nByteCount )
  525. *
  526. *  PARAMETERS:
  527. * pInBuffer Pointer to bytes to enqueue.
  528. * nByteCount Number of bytes to enqueue.
  529. *
  530. *  DESCRIPTION:
  531. * Enqueue's a stream of bytes.
  532. * (Puts bytes INTO the queue)
  533. *
  534. *  RETURNS:
  535. * 0 if there was insufficient room to enqueue nByteCount bytes.
  536. * Number of bytes enqueued.
  537. *
  538. */
  539. UINT16 Base_EnQueueBytes( void *pInBuffer, UINT16 nByteCount );
  540.    /*
  541. ** UINT16 Base_DeQueueBytes( pOutBuffer, nByteCount )
  542. *
  543. *  PARAMETERS:
  544. * pOutBuffer Pointer to buffer to receive bytes from queue.
  545. * nByteCount Number of bytes to remove from queue.
  546. *
  547. *  DESCRIPTION:
  548. * DeQueue's a stream of bytes.
  549. * (Takes bytes OUT of the queue)
  550. *
  551. *  RETURNS:
  552. * The number of bytes dequeued from the queue.
  553. */
  554. UINT16 Base_DeQueueBytes( void *pOutBuffer, UINT16 nByteCount );
  555. /*
  556.  * Private Implementation data.  We don't share this stuff w/ our subclasses.
  557.  * this way we can enforce our public and protected interface.
  558.  */
  559. private:
  560. UCHAR *m_pData;   // the actual buffer pointer.
  561. UCHAR *m_pHead; // points one byte before the next bytes to be
  562. // dequeue'd() from the queue (if !Empty).
  563. UCHAR *m_pTail; // points at last byte of valid data in queue.
  564. // actually one byte before the next byte to receive new queue'd data
  565. UCHAR *m_pMax; // pointer to one position beyond what we've allocated
  566. // helps us limit check m_pHead & mpTail.
  567. UINT16 m_nSize; // # of bytes in alloacated buffer
  568. UINT16 m_nGranularity; // For our subclasses it's the size of an element
  569. // We'll make our buffer a multiple of this
  570. UINT16 m_nMaxSize; // if set, max size queue can grow to.
  571. enum
  572. {
  573. FILLER_BYTE = 0xCC
  574. };
  575.    /*
  576. ** void Base_SetEmpty()
  577. *
  578. *  PARAMETERS:
  579. * void
  580. *
  581. *  DESCRIPTION:
  582. * Instantly empty the queue.
  583. *
  584. *  RETURNS:
  585. *
  586. */
  587. void Base_SetEmpty()
  588. {
  589. HX_ASSERT( this );
  590. m_pTail = m_pHead = m_pMax - 1;
  591. }
  592.    /*
  593. ** PBYTE Base_Normalize( pBuffer )
  594. *
  595. *  PARAMETERS:
  596. * pBuffer Pointer to our buffer that we want to normalize.
  597. *
  598. *  DESCRIPTION:
  599. * Used to keep buffer pointer elements (m_pHead & m_pTail) in range 
  600. * of m_pData to m_pMax-1.
  601. * Basically this method helps us implement the mod function except
  602. * we work w/ pointers, and we don't actually divide.
  603. *
  604. *  RETURNS:
  605. * Normalized pointer.
  606. */
  607. UCHAR * Base_Normalize( UCHAR * pBuffer, UINT16 offset ) const
  608. {
  609. HX_ASSERT( this );
  610. HX_ASSERT( IsQueueValid() );
  611. HX_ASSERT( pBuffer );
  612. #if defined(_WINDOWS) && !defined(_WIN32)
  613. ULONG32 nNewBufferOffset = (((ULONG32)(UCHAR far*)pBuffer & 0x0000FFFF) + (ULONG32)(UCHAR far*)offset);
  614. // wrap-up the buffer pointer
  615. if ( nNewBufferOffset > 0xFFFF)
  616. {
  617. pBuffer = m_pData + (offset - (m_pMax - pBuffer));
  618. }
  619. else
  620. {
  621. #endif
  622. pBuffer += offset;
  623. while (pBuffer >= m_pMax)
  624. {
  625. pBuffer -= m_nSize;
  626. }
  627. #if defined(_WINDOWS) && !defined(_WIN32)
  628. }
  629. #endif
  630. return( pBuffer );
  631. }
  632.    /*
  633. ** UINT16 Base_GranulatedSize( nSize, nGranularity )
  634. *
  635. *  PARAMETERS:
  636. * nSize A "proposed" size for our buffer.
  637. * nGranularity The multiplier (for subclasses this is the size
  638. * of one of our elements).
  639. *
  640. *  DESCRIPTION:
  641. * Performs calcs to ensure our size is a multiple of our granularity.
  642. * This is done by rounding UP to the next even multiple of nGranularity
  643. * that is >= nSize.
  644. *
  645. *  RETURNS:
  646. * A rounded up quantity.
  647. */
  648. static UINT16 Base_GranulatedSize( UINT16 nSize, UINT16 nGranularity = 1 )
  649. {
  650. if (nGranularity == 1)
  651. {
  652. return( nSize );
  653. }
  654. else
  655. {
  656. return( ((nSize + nGranularity - 1) / nGranularity) * nGranularity );
  657. }
  658. }
  659.    /*
  660. ** CByteQueue()
  661. *
  662. *  PARAMETERS:
  663. * void
  664. *
  665. *  DESCRIPTION:
  666. * Default constructor:  We hide this guy because we want to enforce
  667. * the parameterized constructor.
  668. * We might at some later time relax that restriction and allow
  669. * a two step creation process, but not for now.
  670. *
  671. *  RETURNS:
  672. * void
  673. */
  674. CByteQueue() {}
  675.    /*
  676. ** UINT16 Base_PeekBuff( pOutBuffer, nByteCount )
  677. *
  678. *  PARAMETERS:
  679. * pOutBuffer Pointer to buffer to receive bytes.
  680. * nByteCount Desired max bytes to copy out of queue.
  681. *
  682. *  DESCRIPTION:
  683. * Copies bytes (nByteCount) from the Queue head to pOutBuffer.
  684. * returns the number of bytess actually copied into pOutBuffer.
  685. * This function does NOT modify the queue.  It is strictly a 
  686. * peek of the queue bytes specified.
  687. * Our limiting factor is:
  688. *  min( nByteCount, Base_GetUsedByteCount() ).
  689. *
  690. *  RETURNS:
  691. * Number of bytes copied into pOutBuffer.
  692. */
  693. UINT16 Base_PeekBuff( void *pOutBuffer, UINT16 nByteCount ) const;
  694. }; // class CByteQueue
  695. #endif // if !defined( _CBQUEUE_H )