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

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. #ifndef CARRAY_H_
  36. #define CARRAY_H_
  37. #include "hxcom.h"
  38. #include "hxassert.h"
  39. class HXEXPORT_CLASS CHXPtrArray {
  40. public:
  41.     CHXPtrArray();
  42.     ~CHXPtrArray();
  43. // return num elements == 0
  44.     BOOL IsEmpty() const;
  45. // return number of elements
  46.     int GetSize() const;
  47. // return largest index
  48.     int GetUpperBound() const;
  49. // set size and grow by size
  50.     void SetSize(int nelems, int growSize=-1);
  51. // free un-assigned slots
  52.     void FreeExtra();
  53. // free the entire array
  54.     void RemoveAll();
  55. // return the value at the given index
  56.     void* GetAt(int index) const;
  57. // set the value at the given index
  58.     void SetAt(int index, void* value);
  59. // return reference to value at given index
  60.     void*& ElementAt(int index);
  61. // set value, grow array if needed
  62.     void SetAtGrow(int index, void* value);
  63. // add the element, ret index of added element
  64.     int Add(void* value);
  65. // add the element if not already in array
  66.     BOOL AddIfUnique(void* value);
  67. // same as GetAt()
  68.     void* operator[](int index) const;
  69. // same as ElementAt()
  70.     void*& operator[](int index);
  71. // insert value at index
  72.     void InsertAt(int index, void* value, int repeat=1);
  73. // insert array at index
  74.     void InsertAt(int index, CHXPtrArray* pPtrArray);
  75. // remove value(s) at index
  76.     void RemoveAt(int index, int repeat=1);
  77. // search for value in array
  78.     BOOL Find(void* value, int* index=NULL);
  79. // search for and remove first occurence
  80.     BOOL FindAndRemoveOne(void* value);
  81. // search for and remove all occurences
  82.     BOOL FindAndRemoveAll(void* value);
  83. private:
  84. // not implemented
  85.     CHXPtrArray(const CHXPtrArray&);
  86. // not implemented
  87.     void operator=(const CHXPtrArray&);
  88. // resize the array to given size
  89.     void Resize(int size);
  90. // get the size to grow array by
  91.     int GetGrowSize(int newSize);
  92. // common code for insertions
  93.     void InsertCommon(int index, int len);
  94.     
  95. // total slots allocated
  96.     int m_size;
  97. // number of elements in array
  98.     int m_nelems;
  99. // use set grow size for resizing ops
  100.     int m_userGrowSize;
  101. // default grow size if user does not set
  102.     int m_defGrowSize;
  103. // data array
  104.     void** m_pData;
  105.     
  106. };
  107. ///
  108. /// IsEmpty() const
  109. ///
  110. /// return num elements == 0
  111. ///
  112. inline BOOL 
  113. CHXPtrArray::IsEmpty() const
  114. {
  115.     return m_nelems == 0;
  116. }
  117. ///
  118. /// GetSize() const
  119. ///
  120. /// return size of the array
  121. ///
  122. inline int 
  123. CHXPtrArray::GetSize() const
  124. {
  125.     return m_nelems;
  126. }
  127. ///
  128. /// GetUpperBound() const
  129. ///
  130. /// return largest index
  131. ///
  132. inline int 
  133. CHXPtrArray::GetUpperBound() const
  134. {
  135.     return m_nelems - 1;
  136. }
  137. ///
  138. /// GetAt(int index) const
  139. ///
  140. /// return the value at the given index
  141. ///
  142. inline void* 
  143. CHXPtrArray::GetAt(int index) const
  144. {
  145.     HX_ASSERT(index >= 0 && index < m_nelems);
  146.     return m_pData[index];
  147. }
  148. ///
  149. /// SetAt(int index, void* value)
  150. ///
  151. /// set the value at the given index
  152. ///
  153. inline void
  154. CHXPtrArray::SetAt(int index, void* value)
  155. {
  156.     HX_ASSERT(index >= 0 && index < m_nelems);
  157.     m_pData[index] = value;
  158. }
  159. ///
  160. /// ElementAt(int index)
  161. ///
  162. /// return reference to value at given index
  163. ///
  164. inline void*& 
  165. CHXPtrArray::ElementAt(int index)
  166. {
  167.     HX_ASSERT(index >= 0 && index < m_nelems);
  168.     return m_pData[index];
  169. }
  170. ///
  171. /// Add(void* value)
  172. ///
  173. /// append the element to the array
  174. ///
  175. inline int
  176. CHXPtrArray::Add(void* value)
  177. {
  178.     int ret = m_nelems;
  179.     SetAtGrow(m_nelems, value);
  180.     return ret;
  181. }
  182. ///
  183. /// void* operator[]
  184. ///
  185. /// same as GetAt()
  186. ///
  187. inline void*
  188. CHXPtrArray::operator[] (int index) const
  189. {
  190.     return GetAt(index);
  191. }
  192. ///
  193. /// void*& operator[]
  194. ///
  195. /// same as ElementAt()
  196. ///
  197. inline void*&
  198. CHXPtrArray::operator[] (int index)
  199. {
  200.     return ElementAt(index);
  201. }
  202. ///
  203. /// AddIfUnique(void* value)
  204. ///
  205. /// add the element if not already in array
  206. ///
  207. inline BOOL 
  208. CHXPtrArray::AddIfUnique(void* value)
  209. {
  210.     int index;
  211.     if (Find(value, &index)) return FALSE;
  212.     Add(value);
  213.     return TRUE;
  214. }
  215. ///
  216. /// Find(void* value, int* index=NULL)
  217. ///
  218. /// search for value in array
  219. ///
  220. inline BOOL 
  221. CHXPtrArray::Find(void* value, int* index)
  222. {
  223.     int i = 0;
  224.     for (void** cur = m_pData; i < m_nelems; ++i, ++cur)
  225.     {
  226.         if (*cur == value)
  227.         {
  228.             if (index) *index = i;
  229.             return TRUE;
  230.         }
  231.     }
  232.     return FALSE;
  233. }
  234. ///
  235. /// FindAndRemoveOne(void* value)
  236. ///
  237. /// search for and remove first occurence
  238. ///
  239. inline BOOL 
  240. CHXPtrArray::FindAndRemoveOne(void* value)
  241. {
  242.     int index = -1;
  243.     if (Find(value, &index) && index >= 0)
  244.     {
  245.         RemoveAt(index, 1);
  246.         return TRUE;
  247.     }
  248.     return FALSE;
  249. }
  250. ///
  251. /// FindAndRemoveAll(void* value)
  252. ///
  253. /// search for and remove all occurences
  254. ///
  255. inline BOOL 
  256. CHXPtrArray::FindAndRemoveAll(void* value)
  257. {
  258.     void** src = m_pData;
  259.     void** dest = m_pData;
  260.     for (int i = 0; i < m_nelems; ++i, ++src)
  261.         if (value == *src) *dest++ = *src;
  262.     if (src != dest)
  263.     {
  264.         SetSize(dest - m_pData);
  265.         return TRUE;
  266.     }
  267.     return FALSE;
  268. }
  269. #endif /* CARRAY_H_ */