hxordval.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:9k
源码类别:

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. #include "hxtypes.h"
  36. #include "hxresult.h"
  37. #include "hxcom.h"
  38. #include "hxordval.h"
  39. #include "hxstrutl.h"
  40. #include "chxpckts.h"
  41. #include "hxheap.h"
  42. #ifdef _DEBUG
  43. #undef HX_THIS_FILE
  44. static const char HX_THIS_FILE[] = __FILE__;
  45. #endif
  46. // IUnknown interface listing
  47. BEGIN_INTERFACE_LIST(CHXOrderedValues)
  48.     INTERFACE_LIST_ENTRY(IID_IHXValues, IHXValues)
  49. END_INTERFACE_LIST
  50. ////////////////////////////////////////////////////////////////
  51. CHXOrderedValues::CHXOrderedValues() : m_CStringPos(NULL)
  52. {
  53. };
  54. ////////////////////////////////////////////////////////////////
  55. CHXOrderedValues::~CHXOrderedValues()
  56. {
  57.     // go through CString list, deleting NameBufferPair objects
  58.     if (!m_CStringList.IsEmpty())
  59.     {
  60.      LISTPOSITION ListPos = m_CStringList.GetHeadPosition();
  61.      _CStoreNameBufferPair* pCandidate = (_CStoreNameBufferPair*) m_CStringList.GetHead();
  62.     
  63.      while ( ListPos != NULL)
  64.      {
  65.     if (pCandidate)
  66.     {
  67.      delete pCandidate;
  68.     }
  69.     
  70.     pCandidate = (_CStoreNameBufferPair*) m_CStringList.GetAtNext(ListPos);
  71.      }
  72.     }
  73. }
  74. ////////////////////////////////////////////////////////////////
  75. STDMETHODIMP
  76. CHXOrderedValues::SetPropertyULONG32      (
  77. const char*          pPropertyName,
  78. ULONG32              pPropertyValue)
  79. {
  80.     return HXR_NOTIMPL;
  81. }
  82. ////////////////////////////////////////////////////////////////
  83. STDMETHODIMP
  84. CHXOrderedValues::GetPropertyULONG32      (
  85. const char*          pPropertyName,
  86. REF(ULONG32)         uPropertyValue)
  87. {
  88.     return HXR_NOTIMPL;
  89. }
  90. ////////////////////////////////////////////////////////////////
  91. STDMETHODIMP
  92. CHXOrderedValues::GetFirstPropertyULONG32   (
  93. REF(const char*)     pPropertyName,
  94. REF(ULONG32)         uPropertyValue)
  95. {
  96.     return HXR_NOTIMPL;
  97. }
  98. ////////////////////////////////////////////////////////////////
  99. STDMETHODIMP
  100. CHXOrderedValues::GetNextPropertyULONG32   (
  101. REF(const char*)    pPropertyName,
  102. REF(ULONG32)        uPropertyValue)
  103. {
  104.     return HXR_NOTIMPL;
  105. }
  106. ////////////////////////////////////////////////////////////////
  107. STDMETHODIMP
  108. CHXOrderedValues::SetPropertyBuffer     (
  109. const char*         pPropertyName,
  110. IHXBuffer*         pPropertyValue)
  111. {
  112.     return HXR_NOTIMPL;
  113. }
  114. ////////////////////////////////////////////////////////////////
  115. STDMETHODIMP
  116. CHXOrderedValues::GetPropertyBuffer     (
  117. const char*         pPropertyName,
  118. REF(IHXBuffer*)    pPropertyValue)
  119. {
  120.     return HXR_NOTIMPL;
  121. }
  122. ////////////////////////////////////////////////////////////////
  123. STDMETHODIMP
  124. CHXOrderedValues::GetFirstPropertyBuffer   (
  125. REF(const char*)    pPropertyName,
  126. REF(IHXBuffer*)    pPropertyValue)
  127. {
  128.     return HXR_NOTIMPL;
  129. }
  130. ////////////////////////////////////////////////////////////////
  131. STDMETHODIMP
  132. CHXOrderedValues::GetNextPropertyBuffer    (
  133. REF(const char*)    pPropertyName,
  134. REF(IHXBuffer*)    pPropertyValue)
  135. {
  136.     return HXR_NOTIMPL;
  137. }
  138. ////////////////////////////////////////////////////////////////
  139. STDMETHODIMP
  140. CHXOrderedValues::SetPropertyCString     (
  141. const char*         pPropertyName,
  142. IHXBuffer*         pPropertyValue)
  143. {
  144.     if (!pPropertyValue) return HXR_UNEXPECTED;
  145.     HX_ASSERT(pPropertyName);
  146.     if (!pPropertyName)  return HXR_UNEXPECTED;
  147.     
  148.     _CStoreNameBufferPair* pnbpNew = NULL;
  149.     // search list to see if name already exists.
  150.     LISTPOSITION pos = FindCStringName(pPropertyName);
  151.     if ( pos != NULL)
  152.     {
  153. // we found an existing name/value pair with same name
  154. pnbpNew = (_CStoreNameBufferPair*) m_CStringList.GetAt(pos);
  155. // remove from list, we'll reuse the NameBufferPair object below
  156.      m_CStringList.RemoveAt(pos);
  157.     }
  158.     else
  159.     {
  160.      pnbpNew = new _CStoreNameBufferPair;
  161.         if(!pnbpNew)
  162.         {
  163.             return HXR_OUTOFMEMORY;
  164.         }
  165.      pnbpNew->SetName(pPropertyName);
  166.     }
  167.     
  168.     pnbpNew->SetValue(pPropertyValue);
  169.     
  170.     // add to tail of list
  171.     m_CStringList.AddTail( (void*)pnbpNew );
  172.     return HXR_OK;
  173. }
  174. ////////////////////////////////////////////////////////////////
  175. STDMETHODIMP
  176. CHXOrderedValues::GetPropertyCString     (
  177. const char*         pPropertyName,
  178. REF(IHXBuffer*)    pPropertyValue)
  179. {
  180.     if (!pPropertyName) return HXR_UNEXPECTED;
  181.     HX_RELEASE(pPropertyValue);
  182.     
  183.     // search list to see if name exists.
  184.     LISTPOSITION pos = FindCStringName(pPropertyName);
  185.     if ( pos == NULL)
  186.     {
  187. return HXR_FAIL;
  188.     }
  189.     
  190.     // we found an existing name/value pair with same name
  191.     _CStoreNameBufferPair* pnbpValue = (_CStoreNameBufferPair*) m_CStringList.GetAt(pos);
  192.     pPropertyValue = pnbpValue->GetValue();
  193.     return HXR_OK;
  194. }
  195. ////////////////////////////////////////////////////////////////
  196. STDMETHODIMP
  197. CHXOrderedValues::GetFirstPropertyCString   (
  198. REF(const char*)    pPropertyName,
  199. REF(IHXBuffer*)    pPropertyValue)
  200. {
  201.     pPropertyName = NULL;
  202.     HX_RELEASE(pPropertyValue);
  203.     
  204.     if (m_CStringList.IsEmpty())
  205. return HXR_FAIL;
  206.     m_CStringPos = m_CStringList.GetHeadPosition();
  207.     _CStoreNameBufferPair* pnbpValue = (_CStoreNameBufferPair*) m_CStringList.GetAt(m_CStringPos);
  208.     if (pnbpValue == NULL)
  209. return HXR_FAIL;
  210.     pPropertyName = pnbpValue->GetName();
  211.     pPropertyValue = pnbpValue->GetValue();
  212.     
  213.     return HXR_OK;
  214. }
  215. ////////////////////////////////////////////////////////////////
  216. STDMETHODIMP
  217. CHXOrderedValues::GetNextPropertyCString    (
  218. REF(const char*)    pPropertyName,
  219. REF(IHXBuffer*)    pPropertyValue)
  220. {
  221.     pPropertyName = NULL;
  222.     HX_RELEASE(pPropertyValue);
  223.     
  224.     if (m_CStringList.IsEmpty() || m_CStringPos==NULL )
  225. return HXR_FAIL;
  226.     _CStoreNameBufferPair* pnbpValue = (_CStoreNameBufferPair*) m_CStringList.GetAtNext(m_CStringPos);
  227.     if (pnbpValue == NULL)
  228. return HXR_FAIL;
  229.     pPropertyName = pnbpValue->GetName();
  230.     pPropertyValue = pnbpValue->GetValue();
  231.     
  232.     return HXR_OK;
  233. }
  234. ////////////////////////////////////////////////////////////////
  235. LISTPOSITION
  236. CHXOrderedValues::FindCStringName (const char* pPropertyName)
  237. {
  238.     LISTPOSITION    ListPos = NULL;
  239.     
  240.     // search list to see if name already exists.
  241.     if ( !m_CStringList.IsEmpty() )
  242.     {
  243. BOOL bFound  = FALSE;
  244.      ListPos = m_CStringList.GetHeadPosition();
  245. _CStoreNameBufferPair* pCandidate = (_CStoreNameBufferPair*) m_CStringList.GetHead();
  246.      while ( ListPos != NULL)
  247.      {
  248.          // if we find the same name, delete it
  249.          if (  (pCandidate != NULL) &&
  250.               !(pCandidate->GetName().CompareNoCase(pPropertyName)) &&
  251.        (pCandidate->GetName().GetLength() == strlen(pPropertyName)) )
  252.          {
  253.      bFound = TRUE;
  254.      break;
  255.          }
  256.     else
  257. pCandidate = (_CStoreNameBufferPair*) m_CStringList.GetAtNext(ListPos);
  258. }
  259.      if (!bFound)
  260.     ListPos = NULL;
  261.     }
  262.     return ListPos;
  263. }