开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
old_hxpckts.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：27k
源码类别：

Symbian

开发平台：

C/C++

old_hxpckts.cpp：源码内容
  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 ***** */ 
  36. /************************************************************************
  37.  *  Defines
  38.  */
  39. #define EXTREME_RTP_TIME    0xFFFFFFFF
  42. /************************************************************************
  43.  *  Includes
  44.  */
  45. #include "hxtypes.h"
  46. #include "hxresult.h"
  47. #include "hxcom.h"
  48. #include "ihxpckts.h"
  49. #include "old_hxpckts.h"
  50. #include "hlxclib/string.h"
  52. #include "hxheap.h"
  53. #ifdef _DEBUG
  54. #undef HX_THIS_FILE
  55. static const char HX_THIS_FILE[] = __FILE__;
  56. #endif
  59. /////////////////////////////////////////////////////////////////////////
  60. // CHXPacket
  61. /////////////////////////////////////////////////////////////////////////
  62. // Method:
  63. // IUnknown::QueryInterface
  64. // Purpose:
  65. // Implement this to export the interfaces supported by your 
  66. // object.
  67. //
  68. STDMETHODIMP CHXPacket::QueryInterface(REFIID riid, void** ppvObj)
  69. {
  70. QInterfaceList qiList[] =
  71. {
  72. { GET_IIDHANDLE(IID_IUnknown), this },
  73. { GET_IIDHANDLE(IID_IHXPacket), (IHXPacket*) this },
  74. };
  75.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);   
  76. }
  78. /////////////////////////////////////////////////////////////////////////
  79. // Method:
  80. // IUnknown::AddRef
  81. // Purpose:
  82. // Everyone usually implements this the same... feel free to use
  83. // this implementation.
  84. //
  85. STDMETHODIMP_(ULONG32) CHXPacket::AddRef()
  86. {
  87.     return InterlockedIncrement(&m_lRefCount);
  88. }
  90. /////////////////////////////////////////////////////////////////////////
  91. // Method:
  92. // IUnknown::Release
  93. // Purpose:
  94. // Everyone usually implements this the same... feel free to use
  95. // this implementation.
  96. //
  97. STDMETHODIMP_(ULONG32) CHXPacket::Release()
  98. {
  99.     if (InterlockedDecrement(&m_lRefCount) > 0)
  100.     {
  101. return m_lRefCount;
  102.     }
  104.     delete this;
  105.     return 0;
  106. }
  108. /************************************************************************
  109.  * Method:
  110.  * IHXPacket::Get
  111.  * Purpose:
  112.  * TBD
  113.  */
  114. STDMETHODIMP CHXPacket::Get
  115. (
  116.     REF(IHXBuffer*) pBuffer, 
  117.     REF(ULONG32) ulTime,
  118.     REF(UINT16) uStreamNumber,
  119.     REF(UINT8) unASMFlags,
  120.     REF(UINT16) unASMRuleNumber
  121. )
  122. {
  123.     return _Get(pBuffer,
  124. ulTime,
  125. uStreamNumber,
  126. unASMFlags,
  127. unASMRuleNumber);
  128. }
  130. /************************************************************************
  131.  * Method:
  132.  * IHXPacket::GetBuffer
  133.  * Purpose:
  134.  * TBD
  135.  */
  136. STDMETHODIMP_(IHXBuffer*) CHXPacket::GetBuffer()
  137. {
  138.     // Whenever a COM object is returned out of an
  139.     // interface, it should be AddRef()'d.
  140.     if (m_pBuffer) m_pBuffer->AddRef();
  141.     return m_pBuffer; 
  142. }
  144. /************************************************************************
  145.  * Method:
  146.  * IHXPacket::GetTime
  147.  * Purpose:
  148.  * TBD
  149.  */
  150. STDMETHODIMP_(ULONG32) CHXPacket::GetTime()
  151. {
  152.     return m_ulTime;
  153. }
  155. /************************************************************************
  156.  * Method:
  157.  * IHXPacket::GetFlags
  158.  * Purpose:
  159.  * TBD
  160.  */
  161. STDMETHODIMP_(UINT8) CHXPacket::GetASMFlags()
  162. {
  163.     return m_unASMFlags;
  164. }
  166. /************************************************************************
  167.  * Method:
  168.  * IHXPacket::GetStreamNumber
  169.  * Purpose:
  170.  * TBD
  171.  */
  172. STDMETHODIMP_(UINT16) CHXPacket::GetStreamNumber()
  173. {
  174.     return m_uStreamNumber;
  175. }
  177. /************************************************************************
  178.  * Method:
  179.  * IHXPacket::GetASMRuleNumber
  180.  * Purpose:
  181.  * TBD
  182.  */
  183. STDMETHODIMP_(UINT16) CHXPacket::GetASMRuleNumber()
  184. {
  185.     return m_unASMRuleNumber;
  186. }
  188. /************************************************************************
  189.  * Method:
  190.  * IHXPacket::IsLost
  191.  * Purpose:
  192.  * TBD
  193.  */
  194. STDMETHODIMP_(BOOL) CHXPacket::IsLost()
  195. { 
  196.     return m_bIsLost;
  197. }
  199. /************************************************************************
  200.  * Method:
  201.  * IHXPacket::SetAsLost
  202.  * Purpose:
  203.  * TBD
  204.  */
  205. STDMETHODIMP CHXPacket::SetAsLost()
  206. {
  207.     HX_ASSERT(m_pBuffer == NULL);
  208.     HX_ASSERT(m_ulTime == 0);
  209.     if (m_pBuffer) return HXR_UNEXPECTED;
  210.     m_bIsLost = TRUE;
  211.     return HXR_OK; 
  212. }
  214. /************************************************************************
  215.  * Method:
  216.  * IHXPacket::Set
  217.  * Purpose:
  218.  * TBD
  219.  */
  220. STDMETHODIMP CHXPacket::Set
  221. (
  222.     IHXBuffer* pBuffer, 
  223.     ULONG32 ulTime,
  224.     UINT16 uStreamNumber,
  225.     UINT8 unASMFlags,
  226.     UINT16 unASMRuleNumber
  227. )
  228. {
  229.     return _Set(pBuffer, 
  230. ulTime,
  231. uStreamNumber,
  232. unASMFlags,
  233. unASMRuleNumber);
  234. }
  236. /************************************************************************
  237.  * Method:
  238.  * IHXRTPPacket::GetRTP
  239.  */
  240. STDMETHODIMP CHXPacket::GetRTP
  241. (
  242.     REF(IHXBuffer*) pBuffer, 
  243.     REF(ULONG32) ulTime,
  244.     REF(ULONG32) ulRTPTime,
  245.     REF(UINT16) uStreamNumber,
  246.     REF(UINT8) unASMFlags,
  247.     REF(UINT16) unASMRuleNumber
  248. )
  249. {
  250.     HX_ASSERT(HXR_UNEXPECTED == HXR_OK);
  251.     return HXR_UNEXPECTED;
  252. }
  254. /************************************************************************
  255.  * Method:
  256.  * IHXRTPPacket::GetRTPTime
  257.  */
  258. STDMETHODIMP_(ULONG32) CHXPacket::GetRTPTime()
  259. {
  260.     HX_ASSERT(HXR_UNEXPECTED == HXR_OK);
  261.     return EXTREME_RTP_TIME;
  262. }
  264. /************************************************************************
  265.  * Method:
  266.  * IHXRTPPacket::SetRTP
  267.  */
  268. STDMETHODIMP CHXPacket::SetRTP
  269. (
  270.     IHXBuffer*     pBuffer, 
  271.     ULONG32     ulTime,
  272.     ULONG32     ulRTPTime,
  273.     UINT16     uStreamNumber,
  274.     UINT8     unASMFlags,
  275.     UINT16     unASMRuleNumber
  276. )
  277. {
  278.     HX_ASSERT(HXR_UNEXPECTED == HXR_OK);
  279.     return HXR_UNEXPECTED;
  280. }
  282. inline HX_RESULT CHXPacket::_Get(IHXBuffer*   &pBuffer,
  283.  ULONG32     &ulTime,
  284.  UINT16     &uStreamNumber,
  285.  UINT8     &unASMFlags,
  286.  UINT16     &unASMRuleNumber)
  287. {
  288.     pBuffer     = m_pBuffer;
  289.     ulTime     = m_ulTime;
  290.     uStreamNumber   = m_uStreamNumber;
  291.     unASMFlags     = m_unASMFlags;
  292.     unASMRuleNumber = m_unASMRuleNumber;
  294.     // Whenever a COM object is returned out of an
  295.     // interface, it should be AddRef()'d.
  296.     if (m_pBuffer) m_pBuffer->AddRef();
  298.     return HXR_OK;
  299. }
  301. inline HX_RESULT CHXPacket::_Set(IHXBuffer*   pBuffer, 
  302.  ULONG32     ulTime,
  303.  UINT16     uStreamNumber,
  304.  UINT8     unASMFlags,
  305.  UINT16     unASMRuleNumber)
  306. {
  307.     /* We allow changing the packet info when it is owned
  308.      * by atmost one user.
  309.      */
  310.     if (m_lRefCount > 1)
  311.     {
  312. HX_ASSERT(FALSE);
  313. return HXR_UNEXPECTED;
  314.     }
  316.     if (m_pBuffer) m_pBuffer->Release();
  317.     m_pBuffer = pBuffer;
  318.     if (m_pBuffer)
  319.     {
  320. m_pBuffer->AddRef();
  321.     }
  323.     m_ulTime = ulTime;
  324.     m_uStreamNumber = uStreamNumber;
  325.     m_unASMFlags = unASMFlags;
  326.     m_unASMRuleNumber = unASMRuleNumber;
  328.     return HXR_OK;
  329. }
  331. // serialization method
  332. void
  333. CHXPacket::Pack(IHXPacket* pPacket, char* pData, UINT32& ulSize)
  334. {
  335.     UINT16 uValue = 0;
  336.     UINT32 ulValue = 0;
  337.     UINT32 ulBufferSize = 0;
  338.     IHXBuffer* pBuffer = NULL;
  340.     if (!pPacket)
  341.     {
  342. goto cleanup;
  343.     }
  345.     pBuffer = pPacket->GetBuffer();
  347.     if (pBuffer)
  348.     {
  349. ulBufferSize = pBuffer->GetSize();
  350.     }
  352.     // figure out the size 
  353.     if (!pData)
  354.     {
  355. ulSize = sizeof(HXPacketInfo) + ulBufferSize;
  356.     }
  357.     // pack the data
  358.     else
  359.     {
  360. *pData++ = (BYTE)pPacket->IsLost(); ulSize++;
  361. *pData++ = (BYTE)pPacket->GetASMFlags(); ulSize++;
  363. uValue = pPacket->GetASMRuleNumber();
  364. *pData++ = (BYTE)uValue; *pData++ = (BYTE)(uValue >> 8);  ulSize += 2;
  366. uValue = pPacket->GetStreamNumber();
  367. *pData++ = (BYTE)uValue; *pData++ = (BYTE)(uValue >> 8);  ulSize += 2;
  369. ulValue = pPacket->GetTime();
  370. *pData++ = (BYTE)ulValue; *pData++ = (BYTE)(ulValue >> 8);
  371. *pData++ = (BYTE)(ulValue >> 16); *pData++ = (BYTE)(ulValue >> 24); ulSize += 4;
  373. if (pBuffer)
  374. {
  375.     memcpy(pData, (char*)pBuffer->GetBuffer(), ulBufferSize); /* Flawfinder: ignore */
  376.     pData += ulBufferSize; ulSize += ulBufferSize;
  377. }
  378.     }
  379.    
  380. cleanup:
  382.     HX_RELEASE(pBuffer);
  384.     return;
  385. }   
  387. void
  388. CHXPacket::UnPack(IHXPacket*& pPacket, char* pData, UINT32 ulSize)
  389. {
  390.     UINT16     uValue = 0;
  391.     UINT32     ulValue = 0;
  392.     IHXBuffer*     pBuffer = NULL;
  393.     HXPacketInfo   packetInfo;
  395.     pPacket = NULL;
  397.     if (!pData || !ulSize)
  398.     {
  399. goto cleanup;
  400.     }
  402.     HX_ASSERT(ulSize >= sizeof(HXPacketInfo));
  404.     packetInfo.lost = (BYTE)*pData++;     ulSize--;
  405.     packetInfo.ASMFlags = (BYTE)*pData++;   ulSize--;
  407.     uValue = (BYTE)*pData++; uValue |= (((BYTE)*pData++) << 8);
  408.     packetInfo.ASMRuleNumber = uValue;     ulSize -= 2;
  410.     uValue = (BYTE)*pData++; uValue |= (((BYTE)*pData++) << 8);
  411.     packetInfo.streamNum = uValue;     ulSize -= 2;
  413.     ulValue = (BYTE)*pData++; ulValue |= (((BYTE)*pData++) << 8);
  414.     ulValue |= (((BYTE)*pData++) << 16); ulValue |= (((BYTE)*pData++) << 24);
  415.     packetInfo.time = ulValue;     ulSize -= 4;
  417.     if (ulSize)
  418.     {
  419. pBuffer = new CHXBuffer();
  420. pBuffer->AddRef();
  422. pBuffer->Set((const UCHAR*)pData, ulSize);
  423.     }
  425.     pPacket = new CHXPacket();
  426.     pPacket->AddRef();
  428.     pPacket->Set(pBuffer, 
  429.  packetInfo.time, 
  430.  packetInfo.streamNum,
  431.  packetInfo.ASMFlags,
  432.  packetInfo.ASMRuleNumber);
  434.     if (packetInfo.lost)
  435.     {
  436. pPacket->SetAsLost();
  437.     }
  439. cleanup:
  441.     HX_RELEASE(pBuffer);
  443.     return;
  444. }
  446. /////////////////////////////////////////////////////////////////////////
  447. // CHXRTPPacket
  448. /////////////////////////////////////////////////////////////////////////
  449. // Method:
  450. // IUnknown::QueryInterface
  451. // Purpose:
  452. // Implement this to export the interfaces supported by your 
  453. // object.
  454. //
  455. STDMETHODIMP CHXRTPPacket::QueryInterface(REFIID riid, void** ppvObj)
  456. {
  457.     if (IsEqualIID(riid, IID_IHXRTPPacket))
  458.     {
  459. AddRef();
  460. *ppvObj = (IHXRTPPacket*) this;
  461. return HXR_OK;
  462.     }
  463.     else if (IsEqualIID(riid, IID_IHXPacket))
  464.     {
  465. AddRef();
  466. *ppvObj = (IHXPacket*) this;
  467. return HXR_OK;
  468.     }
  469.     else if (IsEqualIID(riid, IID_IUnknown))
  470.     {
  471. AddRef();
  472. *ppvObj = this;
  473. return HXR_OK;
  474.     }
  476.     *ppvObj = NULL;
  477.     return HXR_NOINTERFACE;
  478. }
  480. /////////////////////////////////////////////////////////////////////////
  481. // Method:
  482. // IUnknown::Release
  483. // Purpose:
  484. // Everyone usually implements this the same... feel free to use
  485. // this implementation.
  486. //
  487. STDMETHODIMP_(ULONG32) CHXRTPPacket::Release()
  488. {
  489.     if (InterlockedDecrement(&m_lRefCount) > 0)
  490.     {
  491. return m_lRefCount;
  492.     }
  494.     delete this;
  495.     return 0;
  496. }
  498. /************************************************************************
  499.  * Method:
  500.  * IHXPacket::Set
  501.  */
  502. STDMETHODIMP CHXRTPPacket::Set
  503. (
  504.     IHXBuffer* pBuffer, 
  505.     ULONG32 ulTime,
  506.     UINT16 uStreamNumber,
  507.     UINT8 unASMFlags,
  508.     UINT16 unASMRuleNumber
  509. )
  510. {
  511.     m_ulRTPTime = ulTime;
  513.     return _Set(pBuffer, 
  514. ulTime,
  515. uStreamNumber,
  516. unASMFlags,
  517. unASMRuleNumber);
  518. }
  520. /************************************************************************
  521.  * Method:
  522.  * IHXRTPPacket::GetRTP
  523.  */
  524. STDMETHODIMP CHXRTPPacket::GetRTP
  525. (
  526.     REF(IHXBuffer*) pBuffer, 
  527.     REF(ULONG32) ulTime,
  528.     REF(ULONG32) ulRTPTime,
  529.     REF(UINT16) uStreamNumber,
  530.     REF(UINT8) unASMFlags,
  531.     REF(UINT16) unASMRuleNumber
  532. )
  533. {
  534.     ulRTPTime = m_ulRTPTime;
  536.     return _Get(pBuffer,
  537. ulTime,
  538. uStreamNumber,
  539. unASMFlags,
  540. unASMRuleNumber);
  541. }
  543. /************************************************************************
  544.  * Method:
  545.  * IHXRTPPacket::GetRTPTime
  546.  */
  547. STDMETHODIMP_(ULONG32) CHXRTPPacket::GetRTPTime()
  548. {
  549.     return m_ulRTPTime;
  550. }
  552. /************************************************************************
  553.  * Method:
  554.  * IHXRTPPacket::SetRTP
  555.  */
  556. STDMETHODIMP CHXRTPPacket::SetRTP
  557. (
  558.     IHXBuffer*     pBuffer, 
  559.     ULONG32     ulTime,
  560.     ULONG32     ulRTPTime,
  561.     UINT16     uStreamNumber,
  562.     UINT8     unASMFlags,
  563.     UINT16     unASMRuleNumber
  564. )
  565. {
  566.     m_ulRTPTime = ulRTPTime;
  568.     return _Set(pBuffer, 
  569. ulTime,
  570. uStreamNumber,
  571. unASMFlags,
  572. unASMRuleNumber);
  573. }
  575. /////////////////////////////////////////////////////////////////////////
  576. // CHXHeader
  577. //
  578. /////////////////////////////////////////////////////////////////////////
  579. // Method:
  580. // IUnknown::QueryInterface
  581. // Purpose:
  582. // Implement this to export the interfaces supported by your 
  583. // object.
  584. //
  585. STDMETHODIMP CHXHeader::QueryInterface(REFIID riid, void** ppvObj)
  586. {
  587.     if (IsEqualIID(riid, IID_IUnknown))
  588.     {
  589. AddRef();
  590. *ppvObj = this;
  591. return HXR_OK;
  592.     }
  593.     else if (IsEqualIID(riid, IID_IHXValues))
  594.     {
  595. AddRef();
  596. *ppvObj = (IHXValues*)this;
  597. return HXR_OK;
  598.     }
  600.     *ppvObj = NULL;
  601.     return HXR_NOINTERFACE;
  602. }
  604. /////////////////////////////////////////////////////////////////////////
  605. // Method:
  606. // IUnknown::AddRef
  607. // Purpose:
  608. // Everyone usually implements this the same... feel free to use
  609. // this implementation.
  610. //
  611. STDMETHODIMP_(ULONG32) CHXHeader::AddRef()
  612. {
  613.     return InterlockedIncrement(&m_lRefCount);
  614. }
  616. /////////////////////////////////////////////////////////////////////////
  617. // Method:
  618. // IUnknown::Release
  619. // Purpose:
  620. // Everyone usually implements this the same... feel free to use
  621. // this implementation.
  622. //
  623. STDMETHODIMP_(ULONG32) CHXHeader::Release()
  624. {
  625.     if (InterlockedDecrement(&m_lRefCount) > 0)
  626.     {
  627. return m_lRefCount;
  628.     }
  630.     delete this;
  631.     return 0;
  632. }
  634. CHXHeader::~CHXHeader()
  635. {
  636.     CHXMapStringToOb::Iterator i;
  638.     // clean up UINT32 properties
  639.     for (i = m_ULONG32Map.Begin(); i != m_ULONG32Map.End(); ++i)
  640.     {
  641. _CStoreNameUINT32Pair* pnupExpired = (_CStoreNameUINT32Pair*)*i;
  642. delete pnupExpired;
  643.     }
  644.     m_ULONG32Map.RemoveAll();
  646.     // clean up buffer properties
  647.     for (i = m_BufferMap.Begin(); i != m_BufferMap.End(); ++i)
  648.     {
  649. _CStoreNameBufferPair* pnbpExpired = (_CStoreNameBufferPair*)*i;
  650. delete pnbpExpired;
  651.     }
  652.     m_BufferMap.RemoveAll();
  654.     // clean up string properties
  655.     for (i = m_CStringMap.Begin(); i != m_CStringMap.End(); ++i)
  656.     {
  657. _CStoreNameBufferPair* pnbpExpired = (_CStoreNameBufferPair*)*i;
  658. delete pnbpExpired;
  659.     }
  660.     m_CStringMap.RemoveAll();
  661. }
  663. STDMETHODIMP
  664. CHXHeader::SetPropertyULONG32      (
  665. const char*          pPropertyName,
  666. ULONG32              uPropertyValue)
  667. {
  668.     _CStoreNameUINT32Pair* pnupNew = new _CStoreNameUINT32Pair;
  669.     if(!pnupNew)
  670.     {
  671.         return HXR_OUTOFMEMORY;
  672.     }
  674.     pnupNew->SetName(pPropertyName);
  675.     pnupNew->SetValue(uPropertyValue);
  677.     char* pMapString = new_string(pPropertyName);
  678.     if(!pMapString)
  679.     {
  680.         HX_DELETE(pnupNew);
  681.         return HXR_OUTOFMEMORY;
  682.     }
  684.     if(!m_bPreserveCase)
  685.     {
  686. strlwr(pMapString);
  687.     }
  689.     // First make sure there isn't already a property by that name set!
  690.     _CStoreNameUINT32Pair* pnupExpired = NULL;
  691.     if (m_ULONG32Map.Lookup(pMapString, (void*&)pnupExpired))
  692.     {
  693. /* Delete the previously added property */
  694. delete pnupExpired;
  695.     }
  697.     m_ULONG32Map[pMapString] = (void*)pnupNew;
  698.     delete [] pMapString;
  699.     return HXR_OK;
  700. }
  702. STDMETHODIMP
  703. CHXHeader::GetPropertyULONG32      (
  704. const char*          pPropertyName,
  705. REF(ULONG32)         uPropertyValue)
  706. {
  707.     HX_RESULT rc = HXR_OK;
  709.     _CStoreNameUINT32Pair* pnupData = NULL;
  711.     char* pMapString = new_string(pPropertyName);
  712.     if( !pMapString )
  713.     {
  714.         return HXR_OUTOFMEMORY;
  715.     }
  716.    
  717.     if(!m_bPreserveCase)
  718.     {
  719. strlwr(pMapString);
  720.     }
  722.     if (!m_ULONG32Map.Lookup(pMapString, (void*&)pnupData))
  723.     {
  724. rc = HXR_FAILED;
  725.     }
  726.     else
  727.     {
  728. uPropertyValue = pnupData->GetValue();
  729.     }
  731.     delete[] pMapString;
  733.     return rc;
  734. }
  736. STDMETHODIMP
  737. CHXHeader::GetFirstPropertyULONG32   (
  738. REF(const char*)     pPropertyName,
  739. REF(ULONG32)         uPropertyValue)
  740. {
  741.     if ((m_ULONG32Position = m_ULONG32Map.GetStartPosition()) == NULL)
  742. return HXR_FAILED;
  744.     _CStoreNameUINT32Pair* pnupData = NULL;
  746.     m_ULONG32Map.GetNextAssoc(m_ULONG32Position,
  747.                               pPropertyName,
  748.                               (void*&)pnupData);
  750.     pPropertyName = pnupData->GetName();
  751.     uPropertyValue = pnupData->GetValue();
  753.     return HXR_OK;
  754. }
  756. STDMETHODIMP
  757. CHXHeader::GetNextPropertyULONG32   (
  758. REF(const char*)    pPropertyName,
  759. REF(ULONG32)        uPropertyValue)
  760. {
  761.     if (!m_ULONG32Position)
  762. return HXR_FAILED;
  764.     _CStoreNameUINT32Pair* pnupData = NULL;
  766.     m_ULONG32Map.GetNextAssoc(m_ULONG32Position,
  767.                               pPropertyName,
  768.                               (void*&)pnupData);
  770.     pPropertyName = pnupData->GetName();
  771.     uPropertyValue = pnupData->GetValue();
  773.     return HXR_OK;
  774. }
  776. STDMETHODIMP
  777. CHXHeader::SetPropertyBuffer     (
  778. const char*         pPropertyName,
  779. IHXBuffer*         pPropertyValue)
  780. {
  781.     if (!pPropertyValue) return HXR_UNEXPECTED;
  783.     _CStoreNameBufferPair* pnbpNew = new _CStoreNameBufferPair;
  784.     if(!pnbpNew)
  785.     {
  786.         return HXR_OUTOFMEMORY;
  787.     }
  789.     pnbpNew->SetName(pPropertyName);
  790.     pnbpNew->SetValue(pPropertyValue);
  792.     char* pMapString = new_string(pPropertyName);
  793.     if(!pMapString)
  794.     {
  795.         HX_DELETE(pnbpNew);
  796.         return HXR_OUTOFMEMORY;
  797.     }
  799.     if(!m_bPreserveCase)
  800.     {
  801. strlwr(pMapString);
  802.     }
  804.     // First make sure there isn't already a property by that name set!
  805.     _CStoreNameBufferPair* pnbpExpired = NULL;
  806.     if (m_BufferMap.Lookup(pMapString, (void*&)pnbpExpired))
  807.     {
  808. /* Delete the previously added property */
  809. delete pnbpExpired;
  810.     }
  812.     m_BufferMap[pMapString] = (void*)pnbpNew;
  813.     delete [] pMapString;
  814.     return HXR_OK;
  815. }
  817. STDMETHODIMP
  818. CHXHeader::GetPropertyBuffer     (
  819. const char*         pPropertyName,
  820. REF(IHXBuffer*)    pPropertyValue)
  821. {
  822.     HX_RESULT rc = HXR_OK;
  824.     _CStoreNameBufferPair* pnbpData = NULL;
  826.     char* pMapString = new_string(pPropertyName);
  827.     if(!pMapString)
  828.     {
  829.         return HXR_OUTOFMEMORY;
  830.     }
  832.     if(!m_bPreserveCase)
  833.     {
  834. strlwr(pMapString);
  835.     }
  837.     if (!m_BufferMap.Lookup(pMapString, (void*&)pnbpData))
  838.     {
  839. rc = HXR_FAILED;
  840.     }
  841.     else
  842.     {
  843. pPropertyValue = pnbpData->GetValue();
  844.     }
  846.     delete [] pMapString;
  847.     return rc;
  848. }
  850. #if 0
  851. STDMETHODIMP
  852. CHXHeader::GetEncodedPropertyBuffer(
  853. const char*     pPropertyName,
  854. REF(IHXBuffer*)    pPropertyValue)
  855. {
  856.     IHXBuffer* pTempPropertyValue;
  857.     char* lwr;
  858.     lwr = new_string(pPropertyName);
  859.     strlwr(lwr);
  861.     if (!m_BufferMap.Lookup(lwr, (void*&)pTempPropertyValue))
  862.     {
  863. delete [] lwr;
  864. return HXR_FAILED;
  865.     }
  867.     pPropertyValue = encodeBuffer(pTempPropertyValue);
  868.     delete [] lwr;
  869.     return HXR_OK;
  870. } 
  871. #endif
  873. STDMETHODIMP
  874. CHXHeader::GetFirstPropertyBuffer   (
  875. REF(const char*)    pPropertyName,
  876. REF(IHXBuffer*)    pPropertyValue)
  877. {
  878.     if ((m_BufferPosition = m_BufferMap.GetStartPosition()) == NULL)
  879. return HXR_FAILED;
  881.     _CStoreNameBufferPair* pnbpData = NULL;
  883.     m_BufferMap.GetNextAssoc(m_BufferPosition,
  884.                              pPropertyName,
  885.                              (void*&)pnbpData);
  887.     pPropertyName = pnbpData->GetName();
  888.     pPropertyValue = pnbpData->GetValue();
  890.     return HXR_OK;
  891. }
  893. STDMETHODIMP
  894. CHXHeader::GetNextPropertyBuffer    (
  895. REF(const char*)    pPropertyName,
  896. REF(IHXBuffer*)    pPropertyValue)
  897. {
  898.     if (!m_BufferPosition)
  899. return HXR_FAILED;
  901.     _CStoreNameBufferPair* pnbpData = NULL;
  903.     m_BufferMap.GetNextAssoc(m_BufferPosition,
  904.                              pPropertyName,
  905.                              (void*&)pnbpData);
  907.     pPropertyName = pnbpData->GetName();
  908.     pPropertyValue = pnbpData->GetValue();
  911.     return HXR_OK;
  912. }
  914. STDMETHODIMP
  915. CHXHeader::SetPropertyCString     (
  916. const char*         pPropertyName,
  917. IHXBuffer*         pPropertyValue)
  918. {
  919.     if (!pPropertyValue) return HXR_UNEXPECTED;
  921.     _CStoreNameBufferPair* pnbpNew = new _CStoreNameBufferPair;
  922.     if(!pnbpNew)
  923.     {
  924.         return HXR_OUTOFMEMORY;
  925.     }
  927.     pnbpNew->SetName(pPropertyName);
  928.     pnbpNew->SetValue(pPropertyValue);
  930.     char* pMapString = new_string(pPropertyName);
  931.     if(!pMapString)
  932.     {
  933.         HX_DELETE(pnbpNew);
  934.         return HXR_OUTOFMEMORY;
  935.     }
  937.     if(!m_bPreserveCase)
  938.     {
  939. strlwr(pMapString);
  940.     }
  942.     // First make sure there isn't already a property by that name set!
  943.     _CStoreNameBufferPair* pnbpExpired = NULL;
  944.     if (m_CStringMap.Lookup(pMapString, (void*&)pnbpExpired))
  945.     {
  946. /* Delete the previously added property */
  947. delete pnbpExpired;
  948.     }
  950.     m_CStringMap[pMapString] = (void*)pnbpNew;
  951.     delete[] pMapString;
  952.     return HXR_OK;
  953. }
  955. STDMETHODIMP
  956. CHXHeader::GetPropertyCString     (
  957. const char*         pPropertyName,
  958. REF(IHXBuffer*)    pPropertyValue)
  959. {
  960.     HX_RESULT rc = HXR_OK;
  962.     _CStoreNameBufferPair* pnbpData = NULL;
  964.     char* pMapString = new_string(pPropertyName);
  965.     if(!pMapString)
  966.     {
  967.         return HXR_OUTOFMEMORY;
  968.     }
  970.     if(!m_bPreserveCase)
  971.     {
  972. strlwr(pMapString);
  973.     }
  975.     if (!m_CStringMap.Lookup(pMapString, (void*&)pnbpData))
  976.     {
  977. rc = HXR_FAILED;
  978.     }
  979.     else
  980.     {
  981. pPropertyValue = pnbpData->GetValue();
  982.     }
  984.     delete[] pMapString;
  985.     return rc;
  986. }
  988. #if 0
  989. STDMETHODIMP
  990. CHXHeader::GetEncodedPropertyCString (
  991. const char*     pPropertyName,
  992. REF(IHXBuffer*)    pPropertyValue)
  993. {
  994.     char* lwr;
  995.     lwr = new_string(pPropertyName);
  996.     strlwr(lwr);
  998.     IHXBuffer* pTempPropertyValue;
  1000.     if (!m_CStringMap.Lookup(lwr, (void*&)pTempPropertyValue))
  1001.     {
  1002. delete[] lwr;
  1003. return HXR_FAILED;
  1004.     }
  1006.     pPropertyValue = encodeCString(pTempPropertyValue);
  1008.     delete[] lwr;
  1009.     return HXR_OK;
  1010. }
  1011. #endif
  1013. STDMETHODIMP
  1014. CHXHeader::GetFirstPropertyCString   (
  1015. REF(const char*)    pPropertyName,
  1016. REF(IHXBuffer*)    pPropertyValue)
  1017. {
  1018.     if ((m_CStringPosition = m_CStringMap.GetStartPosition()) == NULL)
  1019. return HXR_FAILED;
  1021.     _CStoreNameBufferPair* pnbpData = NULL;
  1023.     m_CStringMap.GetNextAssoc(m_CStringPosition,
  1024.                               pPropertyName,
  1025.                               (void*&)pnbpData);
  1027.     pPropertyName = pnbpData->GetName();
  1028.     pPropertyValue = pnbpData->GetValue();
  1030.     return HXR_OK;
  1031. }
  1033. STDMETHODIMP
  1034. CHXHeader::GetNextPropertyCString    (
  1035. REF(const char*)    pPropertyName,
  1036. REF(IHXBuffer*)    pPropertyValue)
  1037. {
  1038.     if (!m_CStringPosition)
  1039. return HXR_FAILED;
  1041.     _CStoreNameBufferPair* pnbpData = NULL;
  1043.     m_CStringMap.GetNextAssoc(m_CStringPosition,
  1044.                               pPropertyName,
  1045.                               (void*&)pnbpData);
  1047.     pPropertyName = pnbpData->GetName();
  1048.     pPropertyValue = pnbpData->GetValue();
  1050.     return HXR_OK;
  1051. }
  1053. void
  1054. CHXHeader::mergeHeaders
  1055. (
  1056.     IHXValues* pIHXValuesDestHeaders, 
  1057.     IHXValues* pIHXValuesSourceHeaders
  1058. )
  1059. {
  1060.     if(pIHXValuesSourceHeaders && pIHXValuesDestHeaders)
  1061.     {
  1062. // add these headers to the existing ones
  1063. //
  1065. const char* pPropName = NULL;
  1066. UINT32 ulPropValue = 0;
  1068. HX_RESULT rc = pIHXValuesSourceHeaders->GetFirstPropertyULONG32
  1069. (
  1070.     pPropName, 
  1071.     ulPropValue
  1072. );
  1074. while(SUCCEEDED(rc))
  1075. {
  1076.     pIHXValuesDestHeaders->SetPropertyULONG32
  1077.     (
  1078. pPropName, 
  1079. ulPropValue
  1080.     );
  1082.     rc = pIHXValuesSourceHeaders->GetNextPropertyULONG32
  1083.     (
  1084. pPropName, 
  1085. ulPropValue
  1086.     );
  1087. }
  1089. IHXBuffer* pBuffer = NULL;
  1090. rc = pIHXValuesSourceHeaders->GetFirstPropertyBuffer
  1091. (
  1092.     pPropName, 
  1093.     pBuffer
  1094. );
  1096. while(SUCCEEDED(rc))
  1097. {
  1098.     pIHXValuesDestHeaders->SetPropertyBuffer(pPropName, pBuffer);
  1099.     pBuffer->Release();
  1100.     rc = pIHXValuesSourceHeaders->GetNextPropertyBuffer
  1101.     (
  1102. pPropName, 
  1103. pBuffer
  1104.     );
  1105. }
  1107. rc = pIHXValuesSourceHeaders->GetFirstPropertyCString
  1108. (
  1109.     pPropName, 
  1110.     pBuffer
  1111. );
  1113. while(SUCCEEDED(rc))
  1114. {
  1115.     pIHXValuesDestHeaders->SetPropertyCString(pPropName, pBuffer);
  1116.     pBuffer->Release();
  1117.     rc = pIHXValuesSourceHeaders->GetNextPropertyCString
  1118.     (
  1119. pPropName, 
  1120. pBuffer
  1121.     );
  1122. }
  1123.     }
  1124. }
  1126. _CStoreName::_CStoreName() : m_strName()
  1127. {
  1128. }
  1129. _CStoreName::~_CStoreName()
  1130. {
  1131. }
  1133. const CHXString& _CStoreName::GetName() const
  1134. {
  1135.     return m_strName;
  1136. }
  1137. void _CStoreName::SetName(const char* szName)
  1138. {
  1139.     m_strName = szName;
  1140. }
  1142. _CStoreNameUINT32Pair::_CStoreNameUINT32Pair() : m_ulValue(0)
  1143. {
  1144. }
  1145. _CStoreNameUINT32Pair::~_CStoreNameUINT32Pair()
  1146. {
  1147. }
  1149. UINT32 _CStoreNameUINT32Pair::GetValue()
  1150. {
  1151.     return m_ulValue;
  1152. }
  1153. void _CStoreNameUINT32Pair::SetValue(UINT32 ulValue)
  1154. {
  1155.     m_ulValue = ulValue;
  1156. }
  1158. _CStoreNameBufferPair::_CStoreNameBufferPair() : m_pbufValue(NULL)
  1159. {
  1160. }
  1161. _CStoreNameBufferPair::~_CStoreNameBufferPair()
  1162. {
  1163.     HX_RELEASE(m_pbufValue);
  1164. }
  1166. IHXBuffer* _CStoreNameBufferPair::GetValue()
  1167. {
  1168.     if(m_pbufValue)
  1169.     {
  1170. m_pbufValue->AddRef();
  1171.     }
  1172.     return m_pbufValue;
  1173. }
  1174. void _CStoreNameBufferPair::SetValue(IHXBuffer* pbufValue)
  1175. {
  1176.     HX_RELEASE(m_pbufValue);
  1178.     m_pbufValue = pbufValue;
  1180.     if(m_pbufValue)
  1181.     {
  1182. m_pbufValue->AddRef();
  1183.     }
  1184. }
  1186. #if 0
  1187. IHXBuffer*
  1188. CHXHeader::encodeBuffer(IHXBuffer* pBuffer)
  1189. {
  1190.     //XXXBAB - come back to this soon...
  1191.     CHXBuffer* pEncodedBuffer = new CHXBuffer;
  1192.     pEncodedBuffer->AddRef();
  1193.     pEncodedBuffer->Set(pBuffer->GetBuffer(), pBuffer->GetSize());
  1194.     return pEncodedBuffer;
  1195. }
  1197. IHXBuffer*
  1198. CHXHeader::encodeCString(IHXBuffer* pBuffer)
  1199. {
  1200.     CHXString tmp;
  1201.     const char* pStr = (const char*)pBuffer->GetBuffer();
  1202.     BOOL inEscape = FALSE;
  1203.     for(size_t i=0;i<strlen(pStr);++i)
  1204.     {
  1205. switch(pStr[i])
  1206. {
  1207.     case 'n':
  1208.     {
  1209. tmp += "\n";
  1210.     }
  1211.     break;
  1213.     case 't':
  1214.     {
  1215. tmp += "\t";
  1216.     }
  1217.     break;
  1219.     case 'r':
  1220.     {
  1221. tmp += "\r";
  1222.     }
  1223.     break;
  1225.     case '"':
  1226.     {
  1227. tmp += "\"";
  1228.     }
  1229.     break;
  1231.     case '\':
  1232.     {
  1233. tmp += "\\";
  1234.     }
  1235.     break;
  1237.     default:
  1238.     {
  1239. tmp += pStr[i];
  1240.     }
  1241. }
  1242.     }
  1243.     CHXBuffer* pEncodedBuffer = new CHXBuffer;
  1244.     pEncodedBuffer->AddRef();
  1245.     pEncodedBuffer->Set((const BYTE*)(const char*)tmp, tmp.GetLength()+1);
  1246.     return pEncodedBuffer;
  1247. }
  1248. #endif