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

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 HXLIST_H_
  36. #define HXLIST_H_
  37. #include "hxcom.h"
  38. #include "hxstring.h"
  39. #include "hxassert.h"
  40. typedef void* LISTPOSITION;
  41. //
  42. // CHXSimpleList
  43. //
  44. class CHXSimpleList {
  45. public:
  46.     CHXSimpleList();
  47.     
  48.     virtual ~CHXSimpleList();
  49. // TRUE if list is internally consistent
  50.     virtual BOOL IsPtrListValid();
  51.     
  52. // return number of elements in list
  53.     int GetCount() const;
  54. // return TRUE if number of elements == 0
  55.     BOOL IsEmpty() const;
  56. // poke at first element
  57.     void*& GetHead();
  58. // peek at first element
  59.     void* GetHead() const;
  60. // poke at last element
  61.     void*& GetTail();
  62. // peek at last element
  63.     void* GetTail() const;
  64. // remove first element
  65.     void* RemoveHead();
  66. // remove last element
  67.     void* RemoveTail();
  68. // insert value before first element
  69.     LISTPOSITION AddHead(void* value);
  70. // insert value after last element
  71.     LISTPOSITION AddTail(void* value);
  72. // insert list before first element
  73.     void AddHead(CHXSimpleList* pList);
  74. // insert list after last element
  75.     void AddTail(CHXSimpleList* pTail);
  76. // clear all elements from the list
  77.     virtual void RemoveAll();
  78. // get LISTPOSITION at start of list
  79.     LISTPOSITION GetHeadPosition() const;
  80. // get LISTPOSITION at end of list
  81.     LISTPOSITION GetTailPosition() const;
  82. // return value at current position and incr
  83.     void*& GetNext(LISTPOSITION& pos);
  84. // return value at current position and incr
  85.     void* GetNext(LISTPOSITION& pos) const;
  86. // return value at current position and decr
  87.     void*& GetPrev(LISTPOSITION& pos);
  88. // return value at current position and decr
  89.     void* GetPrev(LISTPOSITION& pos) const;
  90. // incr and return value at current position 
  91.     void*& GetAtNext(LISTPOSITION& pos);
  92. // incr and return value at current position
  93.     void* GetAtNext(LISTPOSITION& pos) const;
  94. // decr and return value at current position
  95.     void*& GetAtPrev(LISTPOSITION& pos);
  96. // decr and return value at current position
  97.     void* GetAtPrev(LISTPOSITION& pos) const;
  98. // get value at LISTPOSITION
  99.     void*& GetAt(LISTPOSITION pos);
  100. // get value at LISTPOSITION
  101.     void* GetAt(LISTPOSITION pos) const;
  102. // set value at LISTPOSITION
  103.     void SetAt(LISTPOSITION pos, void* value);
  104. // remove value at LISTPOSITION
  105.     virtual LISTPOSITION RemoveAt(LISTPOSITION pos);
  106.     
  107. // insert before LISTPOSITION
  108.     virtual LISTPOSITION InsertBefore(LISTPOSITION pos, void* value);
  109. // insert after LISTPOSITION
  110.     virtual LISTPOSITION InsertAfter(LISTPOSITION pos, void* value);
  111.     
  112. // search for value in list
  113.     virtual LISTPOSITION Find(void* value, LISTPOSITION start=NULL);
  114. // get the LISTPOSITION for element at index
  115.     LISTPOSITION FindIndex(int index) const;
  116.     typedef BOOL (*ConditionFunc)(void* pUser, void* pData);
  117.     LISTPOSITION ForEach(LISTPOSITION start, LISTPOSITION end, void* pUser,
  118.  ConditionFunc func);
  119.     class Iterator {
  120. friend class CHXSimpleList;
  121.     public:
  122. Iterator();
  123. // increment
  124. Iterator& operator++();
  125. // comparison
  126. BOOL operator==(const Iterator& iter) const;
  127. // comparison
  128. BOOL operator!=(const Iterator& iter) const;
  129. // get value
  130. void* operator*();
  131.     private:
  132. Iterator(CHXSimpleList* pList, LISTPOSITION pos);
  133. CHXSimpleList* m_pList;
  134. LISTPOSITION m_pos;
  135.     };
  136. // return iterator pointing to start of list
  137.     Iterator Begin();
  138. // return iterator pointing to end of list
  139.     Iterator End();
  140.     struct CNode {
  141. CNode* m_prev;
  142. CNode* m_next;
  143. void* m_value;
  144. CNode() : m_prev(NULL), m_next(NULL), m_value(NULL) {}
  145. CNode(void* value) : m_prev(NULL), m_next(NULL), m_value(value) {}
  146. void* GetValue() const { return m_value; }
  147. void*& GetValue() { return m_value; }
  148. void SetValue(void* value) { m_value = value; }
  149. CNode* GetPrev() const { return m_prev; }
  150. CNode* GetNext() const { return m_next; }
  151. void SetPrev(CNode* pPrev) { m_prev = pPrev; }
  152. void SetNext(CNode* pNext) { m_next = pNext; }
  153.     };
  154.     // If _DEBUG, Dump() will do a bunch of printf()'s...
  155.     virtual void Dump(const char* label = "Dump: ") const;
  156. protected:
  157.     CNode* CreateNode(void* value);
  158.     typedef BOOL (*ConditionNodeFunc)(void* pUser, const CNode* pNode);
  159.     LISTPOSITION ForEach(LISTPOSITION start, LISTPOSITION end, void* pUser,
  160.  ConditionNodeFunc func) const;
  161.     // Remove an item from the list without doing deallocations of
  162.     // contained data.
  163.     CNode* RemoveNode(CNode* pNode);
  164. private:
  165. // number of elements in the list
  166.     int m_nelems;
  167. // pointer to head node
  168.     CNode* m_pHead;
  169. // pointer to tail node
  170.     CNode* m_pTail;
  171.     inline static const void* const& _nil()
  172. {
  173.     static const void* const m_nil = NULL;
  174.     return (const void*&)m_nil;
  175. }
  176. };
  177. //
  178. // CHXStringList
  179. //
  180. class CHXString;
  181. class CHXStringList : public CHXSimpleList {
  182. public:
  183.     virtual ~CHXStringList() { RemoveAll(); }
  184.     // find a string in the list
  185.     LISTPOSITION FindString(const char* pString,
  186.     LISTPOSITION start=NULL,
  187.     BOOL caseSensitive=TRUE);
  188.     // find a string that starts with 'pPrefix'
  189.     LISTPOSITION FindPrefixSubstring(const char* pPrefix,
  190.     LISTPOSITION start=NULL,
  191.     BOOL caseSensitive=TRUE);
  192.     // add string at head
  193.     LISTPOSITION AddHeadString(const char* pString);
  194.     // add string at tail
  195.     LISTPOSITION AddTailString(const char* pTail);
  196.     // add string in sorted alpha order.
  197.     // NOTE: The 'caseSensitive' flag defaults to FALSE to maintain
  198.     //       backwards compat with previous incarnations of this class.
  199.     LISTPOSITION AddStringAlphabetic(const char* pString,
  200.                                      BOOL caseSensitive=FALSE);
  201.     // get the next string in the list
  202.     CHXString* GetNext(LISTPOSITION& pos) const;
  203.     // clear all elements from the list
  204.     virtual void RemoveAll();
  205.     // Override so we can delete the contained CHXString*
  206.     virtual LISTPOSITION RemoveAt(LISTPOSITION pos);
  207.     // remove head string and free mem
  208.     void RemoveHeadString();
  209.     // remove tail string and free mem
  210.     void RemoveTailString();
  211.     // If _DEBUG, Dump() will do a bunch of printf()'s...
  212.     virtual void Dump(const char* label = "Dump: ") const;
  213. private:
  214.     CHXSimpleList* m_pStrings;
  215. };
  216. //
  217. // CHXSimpleList inline methods
  218. //    
  219. // return number of elements in list
  220. inline int 
  221. CHXSimpleList::GetCount() const
  222. {
  223.     return m_nelems;
  224. }
  225. // return TRUE if number of elements == 0
  226. inline BOOL 
  227. CHXSimpleList::IsEmpty() const
  228. {
  229.     return m_nelems == 0;
  230. }
  231. // poke at first element
  232. inline void*& 
  233. CHXSimpleList::GetHead()
  234. {
  235.     HX_ASSERT(m_pHead != NULL);
  236.     return m_pHead->GetValue();
  237. }
  238. // peek at first element
  239. inline void* 
  240. CHXSimpleList::GetHead() const
  241. {
  242.     HX_ASSERT(m_pHead != NULL);
  243.     return m_pHead->GetValue();
  244. }
  245. // poke at last element
  246. inline void*& 
  247. CHXSimpleList::GetTail()
  248. {
  249.     HX_ASSERT(m_pTail != NULL);
  250.     return m_pTail->GetValue();
  251. }
  252. // peek at last element
  253. inline void* 
  254. CHXSimpleList::GetTail() const
  255. {
  256.     HX_ASSERT(m_pTail != NULL);
  257.     return m_pTail->GetValue();
  258. }
  259. inline LISTPOSITION
  260. CHXSimpleList::RemoveAt(LISTPOSITION pos)
  261. {
  262.     HX_ASSERT(pos);
  263.     if (! pos) return NULL;
  264.     return (LISTPOSITION)RemoveNode((CNode*)pos);
  265. }
  266. // remove first element
  267. inline void* 
  268. CHXSimpleList::RemoveHead()
  269. {
  270.     HX_ASSERT(m_pHead != NULL);
  271.     void* value = m_pHead->GetValue();
  272.     // Don't call RemoveAt() - that's a virtual method that subclasses
  273.     // might use to deallocate the data contained in this item, but we
  274.     // want to return that data to the caller
  275.     (void)RemoveNode(m_pHead);
  276.     return value;
  277. }
  278. // remove last element
  279. inline void* 
  280. CHXSimpleList::RemoveTail()
  281. {
  282.     HX_ASSERT(m_pTail != NULL);
  283.     void* value = m_pTail->GetValue();
  284.     // Don't call RemoveAt() - that's a virtual method that subclasses
  285.     // might use to deallocate the data contained in this item, but we
  286.     // want to return that data to the caller
  287.     (void)RemoveNode(m_pTail);
  288.     return value;
  289. }
  290. // insert value before first element
  291. inline LISTPOSITION 
  292. CHXSimpleList::AddHead(void* value)
  293. {
  294.     return InsertBefore((LISTPOSITION)m_pHead, value);
  295. }
  296. // insert value after last element
  297. inline LISTPOSITION 
  298. CHXSimpleList::AddTail(void* value)
  299. {
  300.     return InsertAfter((LISTPOSITION)m_pTail, value);
  301. }
  302. // get LISTPOSITION at start of list
  303. inline LISTPOSITION 
  304. CHXSimpleList::GetHeadPosition() const
  305. {
  306.     return (LISTPOSITION)m_pHead;
  307. }
  308. // get LISTPOSITION at end of list
  309. inline LISTPOSITION 
  310. CHXSimpleList::GetTailPosition() const
  311. {
  312.     return (LISTPOSITION)m_pTail;
  313. }
  314. // return iterator pointing to start of list
  315. inline CHXSimpleList::Iterator 
  316. CHXSimpleList::Begin()
  317. {
  318.     return Iterator(this, m_pHead);
  319. }
  320. // return iterator pointing to end of list
  321. inline CHXSimpleList::Iterator 
  322. CHXSimpleList::End()
  323. {
  324.     return Iterator(this, NULL);
  325. }
  326. ///
  327. /// CHXSimpleList::Iterator methods
  328. ///
  329. inline 
  330. CHXSimpleList::Iterator::Iterator()
  331.     : m_pList(0),
  332.       m_pos(NULL)
  333. {
  334. }
  335. inline 
  336. CHXSimpleList::Iterator::Iterator(CHXSimpleList* pList, LISTPOSITION pos)
  337.     : m_pList(pList),
  338.       m_pos(pos)
  339. {
  340. }
  341. // increment
  342. inline CHXSimpleList::Iterator& 
  343. CHXSimpleList::Iterator::operator++()
  344. {
  345.     HX_ASSERT (m_pos);
  346.     (void)m_pList->GetNext(m_pos);
  347.     return *this;
  348. }
  349. // comparison
  350. inline BOOL 
  351. CHXSimpleList::Iterator::operator==(const Iterator& iter) const
  352. {
  353.     return m_pList == iter.m_pList && m_pos == iter.m_pos;
  354. }
  355. // comparison
  356. inline BOOL 
  357. CHXSimpleList::Iterator::operator!=(const Iterator& iter) const
  358. {
  359.     return !operator==(iter);
  360. }
  361. // get value
  362. inline void* 
  363. CHXSimpleList::Iterator::operator*()
  364. {
  365.     HX_ASSERT (m_pList && m_pos);
  366.     return m_pList->GetAt(m_pos);
  367. }
  368. //
  369. // CHXStringList inline methods
  370. //
  371. // add string at head
  372. inline LISTPOSITION 
  373. CHXStringList::AddHeadString(const char* pString)
  374. {
  375.     return AddHead(new CHXString(pString));
  376. }
  377. // add string at tail
  378. inline LISTPOSITION 
  379. CHXStringList::AddTailString(const char* pString)
  380. {
  381.     return AddTail(new CHXString(pString));
  382. }
  383. // get the next string in the list
  384. inline CHXString* 
  385. CHXStringList::GetNext(LISTPOSITION& pos) const
  386. {
  387.     return (CHXString*)CHXSimpleList::GetNext(pos);
  388. }
  389. #endif /* HXLIST_H_ */