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

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: CPQueue.h
  38.  *
  39.  * CLASS:
  40.  * CPtrQueue class declaration.
  41.  *
  42.  * DESCRIPTION:
  43.  * Class declaration for a 'Queue of pointers' object.
  44.  * This object inherits from the CByteQueue object by
  45.  * overriding the GetElementSize() method, and
  46.  * defining it's own assignemt operator.
  47.  *
  48.  * NOTES (from CByteQueue):
  49.  * The only time a subclass MUST provide a virtual override
  50.  * is for the GetElementSize() method when the subclass changes
  51.  * the size of queued elements.  All other virtual methods
  52.  * provide fully functional default behavior that will ramain
  53.  * functional even when the ElementSize changes.
  54.  *
  55.  * The assignment operator is one of the few cases where a
  56.  * subclass will need to provide new functionality by virtue of
  57.  * inheriting from the base.  Subclasses should use the base
  58.  * method for assigning the bits of the base class prior to
  59.  * performing their own assignment related operations.
  60.  *
  61.  *******************************************************************/
  62.  
  63. #if !defined( _CPQUEUE_H )
  64. #define _CPQUEUE_H
  65. #include "cbqueue.h"
  66. class CPtrQueue : public CByteQueue
  67. {
  68. public:
  69.    /*
  70.     * These are the functions we NEED to implement to get the
  71. * desired functionality out of our base class CByteQueue.
  72. */
  73.    /*
  74. ** CPtrQueue( nMaxPtrs )
  75. *
  76. *  PARAMETERS:
  77. * nMaxPtrs The maximum number of pointers we want to be able
  78. * to enqueue.
  79. *
  80. *  DESCRIPTION:
  81. * Parameterized constructor.
  82. * This is the primary means of constructing a Pointer Queue.
  83. *
  84. *  RETURNS:
  85. * void
  86. */
  87. CPtrQueue( UINT16 nMaxPtrs ) :
  88.  CByteQueue( nMaxPtrs * sizeof( void * ), sizeof( void * ) )
  89. {
  90. // Deliberately empty
  91. }
  92. /*
  93. ** UINT16 GetElementSize()
  94. *
  95. *  PARAMETERS:
  96. * void
  97. *
  98. *  DESCRIPTION:
  99. * Returns the size of one of our queue elements.
  100. * In this case it's the size of a pointer.
  101. *
  102. *  RETURNS:
  103. * The size of a queue element.
  104. */
  105. virtual UINT16 GetElementSize() const
  106. {
  107. return( sizeof( void * ) );
  108. }
  109. /*
  110. ** CPtrQueue &operator=( rReferent )
  111. *
  112. *  PARAMETERS:
  113. * Constant reference to a queue we want to copy.
  114. *
  115. *  DESCRIPTION:
  116. * Custom assignment operator allows us to assign Queues.
  117. *
  118. *  RETURNS:
  119. * A reference to the queue we've assigned into.
  120. */
  121. CPtrQueue &operator=( const CPtrQueue &rReferent )
  122. {
  123. // return( CByteQueue::operator=( rReferent ) );
  124. this->CByteQueue::operator=( rReferent );
  125. return( *this );
  126. }
  127.    /*
  128.     * These are the functions we've added to provide
  129. * some of the semantics that are in the problem
  130. * domain of a queue of pointers.
  131. */
  132. /*
  133. ** UINT16 EnQueuePtr( pPtr )
  134. *
  135. *  PARAMETERS:
  136. * A pointer we want to enqueue.
  137. *
  138. *  DESCRIPTION:
  139. * Takes the value assigned to pPtr and enqueues it.
  140. *
  141. *  RETURNS:
  142. * The number of bytes we put into the queue.
  143. */
  144. UINT16 EnQueuePtr( void *pPtr )
  145. {
  146. return( Base_EnQueueBytes( &pPtr, sizeof( pPtr ) ) );
  147. }
  148. /*
  149. ** void *DeQueuePtr( BOOL &bIsValid )
  150. *
  151. *  PARAMETERS:
  152. * A reference to a boolean flag indicating if the return is valid.
  153. *
  154. *  DESCRIPTION:
  155. * Dequeues the head pointer element in the queue.
  156. *
  157. *  RETURNS:
  158. * The value of the head pointer element we've dequeue'd.
  159. */
  160. void *DeQueuePtr( BOOL &bIsValid )
  161. {
  162. UINT16 iWrote;
  163. void *pPtr;
  164. iWrote = Base_DeQueueBytes( &pPtr, sizeof( pPtr ) );
  165. if (iWrote)
  166. {
  167. bIsValid = TRUE;
  168. return( pPtr );
  169. }
  170. else
  171. {
  172. bIsValid = FALSE;
  173. return( NULL );
  174. }
  175. }
  176. /*
  177. ** void *PeekPtrAt( nIndex, BOOL &bIsValid )
  178. *
  179. *  PARAMETERS:
  180. * nIndex The index of the element off of the head
  181. * queue element we want to peek at.
  182. *
  183. *  DESCRIPTION:
  184. * Peeks at an element offset from the queue head.
  185. *
  186. *  RETURNS:
  187. * The value of the pointer element we're peeking at
  188. * (if it's a valid element).
  189. * bIsValid is set to true or false to indicate the
  190. * validity of the return value.
  191. * (since a NULL pointer might be a valid queue entry.
  192. */
  193. void *PeekPtrAt( UINT16 nIndex, BOOL &bIsValid )
  194. {
  195. UINT16 iCount;
  196. void *pPtr;
  197. iCount = PeekAt( nIndex, &pPtr );
  198. if (iCount)
  199. {
  200. bIsValid = TRUE;
  201. return( pPtr );
  202. }
  203. else
  204. {
  205. bIsValid = FALSE;
  206. return( NULL );
  207. }
  208. }
  209. };
  210. #endif // !defined( _CPQUEUE_H )