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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
old_hxpckts.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：28k
源码类别：

Symbian

开发平台：

Visual C++

old_hxpckts.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: old_hxpckts.cpp,v 1.6.8.3 2004/07/09 01:45:59 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. /************************************************************************
  51.  *  Defines
  52.  */
  53. #define EXTREME_RTP_TIME    0xFFFFFFFF
  56. /************************************************************************
  57.  *  Includes
  58.  */
  59. #include "hxtypes.h"
  60. #include "hxresult.h"
  61. #include "hxcom.h"
  62. #include "ihxpckts.h"
  63. #include "old_hxpckts.h"
  64. #include "hlxclib/string.h"
  66. #include "hxheap.h"
  67. #ifdef _DEBUG
  68. #undef HX_THIS_FILE
  69. static const char HX_THIS_FILE[] = __FILE__;
  70. #endif
  73. /////////////////////////////////////////////////////////////////////////
  74. // CHXPacket
  75. /////////////////////////////////////////////////////////////////////////
  76. // Method:
  77. // IUnknown::QueryInterface
  78. // Purpose:
  79. // Implement this to export the interfaces supported by your 
  80. // object.
  81. //
  82. STDMETHODIMP CHXPacket::QueryInterface(REFIID riid, void** ppvObj)
  83. {
  84. QInterfaceList qiList[] =
  85. {
  86. { GET_IIDHANDLE(IID_IUnknown), this },
  87. { GET_IIDHANDLE(IID_IHXPacket), (IHXPacket*) this },
  88. };
  89.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);   
  90. }
  92. /////////////////////////////////////////////////////////////////////////
  93. // Method:
  94. // IUnknown::AddRef
  95. // Purpose:
  96. // Everyone usually implements this the same... feel free to use
  97. // this implementation.
  98. //
  99. STDMETHODIMP_(ULONG32) CHXPacket::AddRef()
  100. {
  101.     return InterlockedIncrement(&m_lRefCount);
  102. }
  104. /////////////////////////////////////////////////////////////////////////
  105. // Method:
  106. // IUnknown::Release
  107. // Purpose:
  108. // Everyone usually implements this the same... feel free to use
  109. // this implementation.
  110. //
  111. STDMETHODIMP_(ULONG32) CHXPacket::Release()
  112. {
  113.     if (InterlockedDecrement(&m_lRefCount) > 0)
  114.     {
  115. return m_lRefCount;
  116.     }
  118.     delete this;
  119.     return 0;
  120. }
  122. /************************************************************************
  123.  * Method:
  124.  * IHXPacket::Get
  125.  * Purpose:
  126.  * TBD
  127.  */
  128. STDMETHODIMP CHXPacket::Get
  129. (
  130.     REF(IHXBuffer*) pBuffer, 
  131.     REF(ULONG32) ulTime,
  132.     REF(UINT16) uStreamNumber,
  133.     REF(UINT8) unASMFlags,
  134.     REF(UINT16) unASMRuleNumber
  135. )
  136. {
  137.     return _Get(pBuffer,
  138. ulTime,
  139. uStreamNumber,
  140. unASMFlags,
  141. unASMRuleNumber);
  142. }
  144. /************************************************************************
  145.  * Method:
  146.  * IHXPacket::GetBuffer
  147.  * Purpose:
  148.  * TBD
  149.  */
  150. STDMETHODIMP_(IHXBuffer*) CHXPacket::GetBuffer()
  151. {
  152.     // Whenever a COM object is returned out of an
  153.     // interface, it should be AddRef()'d.
  154.     if (m_pBuffer) m_pBuffer->AddRef();
  155.     return m_pBuffer; 
  156. }
  158. /************************************************************************
  159.  * Method:
  160.  * IHXPacket::GetTime
  161.  * Purpose:
  162.  * TBD
  163.  */
  164. STDMETHODIMP_(ULONG32) CHXPacket::GetTime()
  165. {
  166.     return m_ulTime;
  167. }
  169. /************************************************************************
  170.  * Method:
  171.  * IHXPacket::GetFlags
  172.  * Purpose:
  173.  * TBD
  174.  */
  175. STDMETHODIMP_(UINT8) CHXPacket::GetASMFlags()
  176. {
  177.     return m_unASMFlags;
  178. }
  180. /************************************************************************
  181.  * Method:
  182.  * IHXPacket::GetStreamNumber
  183.  * Purpose:
  184.  * TBD
  185.  */
  186. STDMETHODIMP_(UINT16) CHXPacket::GetStreamNumber()
  187. {
  188.     return m_uStreamNumber;
  189. }
  191. /************************************************************************
  192.  * Method:
  193.  * IHXPacket::GetASMRuleNumber
  194.  * Purpose:
  195.  * TBD
  196.  */
  197. STDMETHODIMP_(UINT16) CHXPacket::GetASMRuleNumber()
  198. {
  199.     return m_unASMRuleNumber;
  200. }
  202. /************************************************************************
  203.  * Method:
  204.  * IHXPacket::IsLost
  205.  * Purpose:
  206.  * TBD
  207.  */
  208. STDMETHODIMP_(BOOL) CHXPacket::IsLost()
  209. { 
  210.     return m_bIsLost;
  211. }
  213. /************************************************************************
  214.  * Method:
  215.  * IHXPacket::SetAsLost
  216.  * Purpose:
  217.  * TBD
  218.  */
  219. STDMETHODIMP CHXPacket::SetAsLost()
  220. {
  221.     HX_ASSERT(m_pBuffer == NULL);
  222.     HX_ASSERT(m_ulTime == 0);
  223.     if (m_pBuffer) return HXR_UNEXPECTED;
  224.     m_bIsLost = TRUE;
  225.     return HXR_OK; 
  226. }
  228. /************************************************************************
  229.  * Method:
  230.  * IHXPacket::Set
  231.  * Purpose:
  232.  * TBD
  233.  */
  234. STDMETHODIMP CHXPacket::Set
  235. (
  236.     IHXBuffer* pBuffer, 
  237.     ULONG32 ulTime,
  238.     UINT16 uStreamNumber,
  239.     UINT8 unASMFlags,
  240.     UINT16 unASMRuleNumber
  241. )
  242. {
  243.     return _Set(pBuffer, 
  244. ulTime,
  245. uStreamNumber,
  246. unASMFlags,
  247. unASMRuleNumber);
  248. }
  250. /************************************************************************
  251.  * Method:
  252.  * IHXRTPPacket::GetRTP
  253.  */
  254. STDMETHODIMP CHXPacket::GetRTP
  255. (
  256.     REF(IHXBuffer*) pBuffer, 
  257.     REF(ULONG32) ulTime,
  258.     REF(ULONG32) ulRTPTime,
  259.     REF(UINT16) uStreamNumber,
  260.     REF(UINT8) unASMFlags,
  261.     REF(UINT16) unASMRuleNumber
  262. )
  263. {
  264.     HX_ASSERT(HXR_UNEXPECTED == HXR_OK);
  265.     return HXR_UNEXPECTED;
  266. }
  268. /************************************************************************
  269.  * Method:
  270.  * IHXRTPPacket::GetRTPTime
  271.  */
  272. STDMETHODIMP_(ULONG32) CHXPacket::GetRTPTime()
  273. {
  274.     HX_ASSERT(HXR_UNEXPECTED == HXR_OK);
  275.     return EXTREME_RTP_TIME;
  276. }
  278. /************************************************************************
  279.  * Method:
  280.  * IHXRTPPacket::SetRTP
  281.  */
  282. STDMETHODIMP CHXPacket::SetRTP
  283. (
  284.     IHXBuffer*     pBuffer, 
  285.     ULONG32     ulTime,
  286.     ULONG32     ulRTPTime,
  287.     UINT16     uStreamNumber,
  288.     UINT8     unASMFlags,
  289.     UINT16     unASMRuleNumber
  290. )
  291. {
  292.     HX_ASSERT(HXR_UNEXPECTED == HXR_OK);
  293.     return HXR_UNEXPECTED;
  294. }
  296. inline HX_RESULT CHXPacket::_Get(IHXBuffer*   &pBuffer,
  297.  ULONG32     &ulTime,
  298.  UINT16     &uStreamNumber,
  299.  UINT8     &unASMFlags,
  300.  UINT16     &unASMRuleNumber)
  301. {
  302.     pBuffer     = m_pBuffer;
  303.     ulTime     = m_ulTime;
  304.     uStreamNumber   = m_uStreamNumber;
  305.     unASMFlags     = m_unASMFlags;
  306.     unASMRuleNumber = m_unASMRuleNumber;
  308.     // Whenever a COM object is returned out of an
  309.     // interface, it should be AddRef()'d.
  310.     if (m_pBuffer) m_pBuffer->AddRef();
  312.     return HXR_OK;
  313. }
  315. inline HX_RESULT CHXPacket::_Set(IHXBuffer*   pBuffer, 
  316.  ULONG32     ulTime,
  317.  UINT16     uStreamNumber,
  318.  UINT8     unASMFlags,
  319.  UINT16     unASMRuleNumber)
  320. {
  321.     /* We allow changing the packet info when it is owned
  322.      * by atmost one user.
  323.      */
  324.     if (m_lRefCount > 1)
  325.     {
  326. HX_ASSERT(FALSE);
  327. return HXR_UNEXPECTED;
  328.     }
  330.     if (m_pBuffer) m_pBuffer->Release();
  331.     m_pBuffer = pBuffer;
  332.     if (m_pBuffer)
  333.     {
  334. m_pBuffer->AddRef();
  335.     }
  337.     m_ulTime = ulTime;
  338.     m_uStreamNumber = uStreamNumber;
  339.     m_unASMFlags = unASMFlags;
  340.     m_unASMRuleNumber = unASMRuleNumber;
  342.     return HXR_OK;
  343. }
  345. // serialization method
  346. void
  347. CHXPacket::Pack(IHXPacket* pPacket, char* pData, UINT32& ulSize)
  348. {
  349.     UINT16 uValue = 0;
  350.     UINT32 ulValue = 0;
  351.     UINT32 ulBufferSize = 0;
  352.     IHXBuffer* pBuffer = NULL;
  354.     if (!pPacket)
  355.     {
  356. goto cleanup;
  357.     }
  359.     pBuffer = pPacket->GetBuffer();
  361.     if (pBuffer)
  362.     {
  363. ulBufferSize = pBuffer->GetSize();
  364.     }
  366.     // figure out the size 
  367.     if (!pData)
  368.     {
  369. ulSize = sizeof(HXPacketInfo) + ulBufferSize;
  370.     }
  371.     // pack the data
  372.     else
  373.     {
  374. *pData++ = (BYTE)pPacket->IsLost(); ulSize++;
  375. *pData++ = (BYTE)pPacket->GetASMFlags(); ulSize++;
  377. uValue = pPacket->GetASMRuleNumber();
  378. *pData++ = (BYTE)uValue; *pData++ = (BYTE)(uValue >> 8);  ulSize += 2;
  380. uValue = pPacket->GetStreamNumber();
  381. *pData++ = (BYTE)uValue; *pData++ = (BYTE)(uValue >> 8);  ulSize += 2;
  383. ulValue = pPacket->GetTime();
  384. *pData++ = (BYTE)ulValue; *pData++ = (BYTE)(ulValue >> 8);
  385. *pData++ = (BYTE)(ulValue >> 16); *pData++ = (BYTE)(ulValue >> 24); ulSize += 4;
  387. if (pBuffer)
  388. {
  389.     memcpy(pData, (char*)pBuffer->GetBuffer(), ulBufferSize); /* Flawfinder: ignore */
  390.     pData += ulBufferSize; ulSize += ulBufferSize;
  391. }
  392.     }
  393.    
  394. cleanup:
  396.     HX_RELEASE(pBuffer);
  398.     return;
  399. }   
  401. void
  402. CHXPacket::UnPack(IHXPacket*& pPacket, char* pData, UINT32 ulSize)
  403. {
  404.     UINT16     uValue = 0;
  405.     UINT32     ulValue = 0;
  406.     IHXBuffer*     pBuffer = NULL;
  407.     HXPacketInfo   packetInfo;
  409.     pPacket = NULL;
  411.     if (!pData || !ulSize)
  412.     {
  413. goto cleanup;
  414.     }
  416.     HX_ASSERT(ulSize >= sizeof(HXPacketInfo));
  418.     packetInfo.lost = (BYTE)*pData++;     ulSize--;
  419.     packetInfo.ASMFlags = (BYTE)*pData++;   ulSize--;
  421.     uValue = (BYTE)*pData++; uValue |= (((BYTE)*pData++) << 8);
  422.     packetInfo.ASMRuleNumber = uValue;     ulSize -= 2;
  424.     uValue = (BYTE)*pData++; uValue |= (((BYTE)*pData++) << 8);
  425.     packetInfo.streamNum = uValue;     ulSize -= 2;
  427.     ulValue = (BYTE)*pData++; ulValue |= (((BYTE)*pData++) << 8);
  428.     ulValue |= (((BYTE)*pData++) << 16); ulValue |= (((BYTE)*pData++) << 24);
  429.     packetInfo.time = ulValue;     ulSize -= 4;
  431.     if (ulSize)
  432.     {
  433. pBuffer = new CHXBuffer();
  434. pBuffer->AddRef();
  436. pBuffer->Set((const UCHAR*)pData, ulSize);
  437.     }
  439.     pPacket = new CHXPacket();
  440.     pPacket->AddRef();
  442.     pPacket->Set(pBuffer, 
  443.  packetInfo.time, 
  444.  packetInfo.streamNum,
  445.  packetInfo.ASMFlags,
  446.  packetInfo.ASMRuleNumber);
  448.     if (packetInfo.lost)
  449.     {
  450. pPacket->SetAsLost();
  451.     }
  453. cleanup:
  455.     HX_RELEASE(pBuffer);
  457.     return;
  458. }
  460. /////////////////////////////////////////////////////////////////////////
  461. // CHXRTPPacket
  462. /////////////////////////////////////////////////////////////////////////
  463. // Method:
  464. // IUnknown::QueryInterface
  465. // Purpose:
  466. // Implement this to export the interfaces supported by your 
  467. // object.
  468. //
  469. STDMETHODIMP CHXRTPPacket::QueryInterface(REFIID riid, void** ppvObj)
  470. {
  471.     if (IsEqualIID(riid, IID_IHXRTPPacket))
  472.     {
  473. AddRef();
  474. *ppvObj = (IHXRTPPacket*) this;
  475. return HXR_OK;
  476.     }
  477.     else if (IsEqualIID(riid, IID_IHXPacket))
  478.     {
  479. AddRef();
  480. *ppvObj = (IHXPacket*) this;
  481. return HXR_OK;
  482.     }
  483.     else if (IsEqualIID(riid, IID_IUnknown))
  484.     {
  485. AddRef();
  486. *ppvObj = this;
  487. return HXR_OK;
  488.     }
  490.     *ppvObj = NULL;
  491.     return HXR_NOINTERFACE;
  492. }
  494. /////////////////////////////////////////////////////////////////////////
  495. // Method:
  496. // IUnknown::Release
  497. // Purpose:
  498. // Everyone usually implements this the same... feel free to use
  499. // this implementation.
  500. //
  501. STDMETHODIMP_(ULONG32) CHXRTPPacket::Release()
  502. {
  503.     if (InterlockedDecrement(&m_lRefCount) > 0)
  504.     {
  505. return m_lRefCount;
  506.     }
  508.     delete this;
  509.     return 0;
  510. }
  512. /************************************************************************
  513.  * Method:
  514.  * IHXPacket::Set
  515.  */
  516. STDMETHODIMP CHXRTPPacket::Set
  517. (
  518.     IHXBuffer* pBuffer, 
  519.     ULONG32 ulTime,
  520.     UINT16 uStreamNumber,
  521.     UINT8 unASMFlags,
  522.     UINT16 unASMRuleNumber
  523. )
  524. {
  525.     m_ulRTPTime = ulTime;
  527.     return _Set(pBuffer, 
  528. ulTime,
  529. uStreamNumber,
  530. unASMFlags,
  531. unASMRuleNumber);
  532. }
  534. /************************************************************************
  535.  * Method:
  536.  * IHXRTPPacket::GetRTP
  537.  */
  538. STDMETHODIMP CHXRTPPacket::GetRTP
  539. (
  540.     REF(IHXBuffer*) pBuffer, 
  541.     REF(ULONG32) ulTime,
  542.     REF(ULONG32) ulRTPTime,
  543.     REF(UINT16) uStreamNumber,
  544.     REF(UINT8) unASMFlags,
  545.     REF(UINT16) unASMRuleNumber
  546. )
  547. {
  548.     ulRTPTime = m_ulRTPTime;
  550.     return _Get(pBuffer,
  551. ulTime,
  552. uStreamNumber,
  553. unASMFlags,
  554. unASMRuleNumber);
  555. }
  557. /************************************************************************
  558.  * Method:
  559.  * IHXRTPPacket::GetRTPTime
  560.  */
  561. STDMETHODIMP_(ULONG32) CHXRTPPacket::GetRTPTime()
  562. {
  563.     return m_ulRTPTime;
  564. }
  566. /************************************************************************
  567.  * Method:
  568.  * IHXRTPPacket::SetRTP
  569.  */
  570. STDMETHODIMP CHXRTPPacket::SetRTP
  571. (
  572.     IHXBuffer*     pBuffer, 
  573.     ULONG32     ulTime,
  574.     ULONG32     ulRTPTime,
  575.     UINT16     uStreamNumber,
  576.     UINT8     unASMFlags,
  577.     UINT16     unASMRuleNumber
  578. )
  579. {
  580.     m_ulRTPTime = ulRTPTime;
  582.     return _Set(pBuffer, 
  583. ulTime,
  584. uStreamNumber,
  585. unASMFlags,
  586. unASMRuleNumber);
  587. }
  589. /////////////////////////////////////////////////////////////////////////
  590. // CHXHeader
  591. //
  592. /////////////////////////////////////////////////////////////////////////
  593. // Method:
  594. // IUnknown::QueryInterface
  595. // Purpose:
  596. // Implement this to export the interfaces supported by your 
  597. // object.
  598. //
  599. STDMETHODIMP CHXHeader::QueryInterface(REFIID riid, void** ppvObj)
  600. {
  601.     if (IsEqualIID(riid, IID_IUnknown))
  602.     {
  603. AddRef();
  604. *ppvObj = this;
  605. return HXR_OK;
  606.     }
  607.     else if (IsEqualIID(riid, IID_IHXValues))
  608.     {
  609. AddRef();
  610. *ppvObj = (IHXValues*)this;
  611. return HXR_OK;
  612.     }
  614.     *ppvObj = NULL;
  615.     return HXR_NOINTERFACE;
  616. }
  618. /////////////////////////////////////////////////////////////////////////
  619. // Method:
  620. // IUnknown::AddRef
  621. // Purpose:
  622. // Everyone usually implements this the same... feel free to use
  623. // this implementation.
  624. //
  625. STDMETHODIMP_(ULONG32) CHXHeader::AddRef()
  626. {
  627.     return InterlockedIncrement(&m_lRefCount);
  628. }
  630. /////////////////////////////////////////////////////////////////////////
  631. // Method:
  632. // IUnknown::Release
  633. // Purpose:
  634. // Everyone usually implements this the same... feel free to use
  635. // this implementation.
  636. //
  637. STDMETHODIMP_(ULONG32) CHXHeader::Release()
  638. {
  639.     if (InterlockedDecrement(&m_lRefCount) > 0)
  640.     {
  641. return m_lRefCount;
  642.     }
  644.     delete this;
  645.     return 0;
  646. }
  648. CHXHeader::~CHXHeader()
  649. {
  650.     CHXMapStringToOb::Iterator i;
  652.     // clean up UINT32 properties
  653.     for (i = m_ULONG32Map.Begin(); i != m_ULONG32Map.End(); ++i)
  654.     {
  655. _CStoreNameUINT32Pair* pnupExpired = (_CStoreNameUINT32Pair*)*i;
  656. delete pnupExpired;
  657.     }
  658.     m_ULONG32Map.RemoveAll();
  660.     // clean up buffer properties
  661.     for (i = m_BufferMap.Begin(); i != m_BufferMap.End(); ++i)
  662.     {
  663. _CStoreNameBufferPair* pnbpExpired = (_CStoreNameBufferPair*)*i;
  664. delete pnbpExpired;
  665.     }
  666.     m_BufferMap.RemoveAll();
  668.     // clean up string properties
  669.     for (i = m_CStringMap.Begin(); i != m_CStringMap.End(); ++i)
  670.     {
  671. _CStoreNameBufferPair* pnbpExpired = (_CStoreNameBufferPair*)*i;
  672. delete pnbpExpired;
  673.     }
  674.     m_CStringMap.RemoveAll();
  675. }
  677. STDMETHODIMP
  678. CHXHeader::SetPropertyULONG32      (
  679. const char*          pPropertyName,
  680. ULONG32              uPropertyValue)
  681. {
  682.     _CStoreNameUINT32Pair* pnupNew = new _CStoreNameUINT32Pair;
  683.     if(!pnupNew)
  684.     {
  685.         return HXR_OUTOFMEMORY;
  686.     }
  688.     pnupNew->SetName(pPropertyName);
  689.     pnupNew->SetValue(uPropertyValue);
  691.     char* pMapString = new_string(pPropertyName);
  692.     if(!pMapString)
  693.     {
  694.         HX_DELETE(pnupNew);
  695.         return HXR_OUTOFMEMORY;
  696.     }
  698.     if(!m_bPreserveCase)
  699.     {
  700. strlwr(pMapString);
  701.     }
  703.     // First make sure there isn't already a property by that name set!
  704.     _CStoreNameUINT32Pair* pnupExpired = NULL;
  705.     if (m_ULONG32Map.Lookup(pMapString, (void*&)pnupExpired))
  706.     {
  707. /* Delete the previously added property */
  708. delete pnupExpired;
  709.     }
  711.     m_ULONG32Map[pMapString] = (void*)pnupNew;
  712.     delete [] pMapString;
  713.     return HXR_OK;
  714. }
  716. STDMETHODIMP
  717. CHXHeader::GetPropertyULONG32      (
  718. const char*          pPropertyName,
  719. REF(ULONG32)         uPropertyValue)
  720. {
  721.     HX_RESULT rc = HXR_OK;
  723.     _CStoreNameUINT32Pair* pnupData = NULL;
  725.     char* pMapString = new_string(pPropertyName);
  726.     if( !pMapString )
  727.     {
  728.         return HXR_OUTOFMEMORY;
  729.     }
  730.    
  731.     if(!m_bPreserveCase)
  732.     {
  733. strlwr(pMapString);
  734.     }
  736.     if (!m_ULONG32Map.Lookup(pMapString, (void*&)pnupData))
  737.     {
  738. rc = HXR_FAILED;
  739.     }
  740.     else
  741.     {
  742. uPropertyValue = pnupData->GetValue();
  743.     }
  745.     delete[] pMapString;
  747.     return rc;
  748. }
  750. STDMETHODIMP
  751. CHXHeader::GetFirstPropertyULONG32   (
  752. REF(const char*)     pPropertyName,
  753. REF(ULONG32)         uPropertyValue)
  754. {
  755.     if ((m_ULONG32Position = m_ULONG32Map.GetStartPosition()) == NULL)
  756. return HXR_FAILED;
  758.     _CStoreNameUINT32Pair* pnupData = NULL;
  760.     m_ULONG32Map.GetNextAssoc(m_ULONG32Position,
  761.                               pPropertyName,
  762.                               (void*&)pnupData);
  764.     pPropertyName = pnupData->GetName();
  765.     uPropertyValue = pnupData->GetValue();
  767.     return HXR_OK;
  768. }
  770. STDMETHODIMP
  771. CHXHeader::GetNextPropertyULONG32   (
  772. REF(const char*)    pPropertyName,
  773. REF(ULONG32)        uPropertyValue)
  774. {
  775.     if (!m_ULONG32Position)
  776. return HXR_FAILED;
  778.     _CStoreNameUINT32Pair* pnupData = NULL;
  780.     m_ULONG32Map.GetNextAssoc(m_ULONG32Position,
  781.                               pPropertyName,
  782.                               (void*&)pnupData);
  784.     pPropertyName = pnupData->GetName();
  785.     uPropertyValue = pnupData->GetValue();
  787.     return HXR_OK;
  788. }
  790. STDMETHODIMP
  791. CHXHeader::SetPropertyBuffer     (
  792. const char*         pPropertyName,
  793. IHXBuffer*         pPropertyValue)
  794. {
  795.     if (!pPropertyValue) return HXR_UNEXPECTED;
  797.     _CStoreNameBufferPair* pnbpNew = new _CStoreNameBufferPair;
  798.     if(!pnbpNew)
  799.     {
  800.         return HXR_OUTOFMEMORY;
  801.     }
  803.     pnbpNew->SetName(pPropertyName);
  804.     pnbpNew->SetValue(pPropertyValue);
  806.     char* pMapString = new_string(pPropertyName);
  807.     if(!pMapString)
  808.     {
  809.         HX_DELETE(pnbpNew);
  810.         return HXR_OUTOFMEMORY;
  811.     }
  813.     if(!m_bPreserveCase)
  814.     {
  815. strlwr(pMapString);
  816.     }
  818.     // First make sure there isn't already a property by that name set!
  819.     _CStoreNameBufferPair* pnbpExpired = NULL;
  820.     if (m_BufferMap.Lookup(pMapString, (void*&)pnbpExpired))
  821.     {
  822. /* Delete the previously added property */
  823. delete pnbpExpired;
  824.     }
  826.     m_BufferMap[pMapString] = (void*)pnbpNew;
  827.     delete [] pMapString;
  828.     return HXR_OK;
  829. }
  831. STDMETHODIMP
  832. CHXHeader::GetPropertyBuffer     (
  833. const char*         pPropertyName,
  834. REF(IHXBuffer*)    pPropertyValue)
  835. {
  836.     HX_RESULT rc = HXR_OK;
  838.     _CStoreNameBufferPair* pnbpData = NULL;
  840.     char* pMapString = new_string(pPropertyName);
  841.     if(!pMapString)
  842.     {
  843.         return HXR_OUTOFMEMORY;
  844.     }
  846.     if(!m_bPreserveCase)
  847.     {
  848. strlwr(pMapString);
  849.     }
  851.     if (!m_BufferMap.Lookup(pMapString, (void*&)pnbpData))
  852.     {
  853. rc = HXR_FAILED;
  854.     }
  855.     else
  856.     {
  857. pPropertyValue = pnbpData->GetValue();
  858.     }
  860.     delete [] pMapString;
  861.     return rc;
  862. }
  864. #if 0
  865. STDMETHODIMP
  866. CHXHeader::GetEncodedPropertyBuffer(
  867. const char*     pPropertyName,
  868. REF(IHXBuffer*)    pPropertyValue)
  869. {
  870.     IHXBuffer* pTempPropertyValue;
  871.     char* lwr;
  872.     lwr = new_string(pPropertyName);
  873.     strlwr(lwr);
  875.     if (!m_BufferMap.Lookup(lwr, (void*&)pTempPropertyValue))
  876.     {
  877. delete [] lwr;
  878. return HXR_FAILED;
  879.     }
  881.     pPropertyValue = encodeBuffer(pTempPropertyValue);
  882.     delete [] lwr;
  883.     return HXR_OK;
  884. } 
  885. #endif
  887. STDMETHODIMP
  888. CHXHeader::GetFirstPropertyBuffer   (
  889. REF(const char*)    pPropertyName,
  890. REF(IHXBuffer*)    pPropertyValue)
  891. {
  892.     if ((m_BufferPosition = m_BufferMap.GetStartPosition()) == NULL)
  893. return HXR_FAILED;
  895.     _CStoreNameBufferPair* pnbpData = NULL;
  897.     m_BufferMap.GetNextAssoc(m_BufferPosition,
  898.                              pPropertyName,
  899.                              (void*&)pnbpData);
  901.     pPropertyName = pnbpData->GetName();
  902.     pPropertyValue = pnbpData->GetValue();
  904.     return HXR_OK;
  905. }
  907. STDMETHODIMP
  908. CHXHeader::GetNextPropertyBuffer    (
  909. REF(const char*)    pPropertyName,
  910. REF(IHXBuffer*)    pPropertyValue)
  911. {
  912.     if (!m_BufferPosition)
  913. return HXR_FAILED;
  915.     _CStoreNameBufferPair* pnbpData = NULL;
  917.     m_BufferMap.GetNextAssoc(m_BufferPosition,
  918.                              pPropertyName,
  919.                              (void*&)pnbpData);
  921.     pPropertyName = pnbpData->GetName();
  922.     pPropertyValue = pnbpData->GetValue();
  925.     return HXR_OK;
  926. }
  928. STDMETHODIMP
  929. CHXHeader::SetPropertyCString     (
  930. const char*         pPropertyName,
  931. IHXBuffer*         pPropertyValue)
  932. {
  933.     if (!pPropertyValue) return HXR_UNEXPECTED;
  935.     _CStoreNameBufferPair* pnbpNew = new _CStoreNameBufferPair;
  936.     if(!pnbpNew)
  937.     {
  938.         return HXR_OUTOFMEMORY;
  939.     }
  941.     pnbpNew->SetName(pPropertyName);
  942.     pnbpNew->SetValue(pPropertyValue);
  944.     char* pMapString = new_string(pPropertyName);
  945.     if(!pMapString)
  946.     {
  947.         HX_DELETE(pnbpNew);
  948.         return HXR_OUTOFMEMORY;
  949.     }
  951.     if(!m_bPreserveCase)
  952.     {
  953. strlwr(pMapString);
  954.     }
  956.     // First make sure there isn't already a property by that name set!
  957.     _CStoreNameBufferPair* pnbpExpired = NULL;
  958.     if (m_CStringMap.Lookup(pMapString, (void*&)pnbpExpired))
  959.     {
  960. /* Delete the previously added property */
  961. delete pnbpExpired;
  962.     }
  964.     m_CStringMap[pMapString] = (void*)pnbpNew;
  965.     delete[] pMapString;
  966.     return HXR_OK;
  967. }
  969. STDMETHODIMP
  970. CHXHeader::GetPropertyCString     (
  971. const char*         pPropertyName,
  972. REF(IHXBuffer*)    pPropertyValue)
  973. {
  974.     HX_RESULT rc = HXR_OK;
  976.     _CStoreNameBufferPair* pnbpData = NULL;
  978.     char* pMapString = new_string(pPropertyName);
  979.     if(!pMapString)
  980.     {
  981.         return HXR_OUTOFMEMORY;
  982.     }
  984.     if(!m_bPreserveCase)
  985.     {
  986. strlwr(pMapString);
  987.     }
  989.     if (!m_CStringMap.Lookup(pMapString, (void*&)pnbpData))
  990.     {
  991. rc = HXR_FAILED;
  992.     }
  993.     else
  994.     {
  995. pPropertyValue = pnbpData->GetValue();
  996.     }
  998.     delete[] pMapString;
  999.     return rc;
  1000. }
  1002. #if 0
  1003. STDMETHODIMP
  1004. CHXHeader::GetEncodedPropertyCString (
  1005. const char*     pPropertyName,
  1006. REF(IHXBuffer*)    pPropertyValue)
  1007. {
  1008.     char* lwr;
  1009.     lwr = new_string(pPropertyName);
  1010.     strlwr(lwr);
  1012.     IHXBuffer* pTempPropertyValue;
  1014.     if (!m_CStringMap.Lookup(lwr, (void*&)pTempPropertyValue))
  1015.     {
  1016. delete[] lwr;
  1017. return HXR_FAILED;
  1018.     }
  1020.     pPropertyValue = encodeCString(pTempPropertyValue);
  1022.     delete[] lwr;
  1023.     return HXR_OK;
  1024. }
  1025. #endif
  1027. STDMETHODIMP
  1028. CHXHeader::GetFirstPropertyCString   (
  1029. REF(const char*)    pPropertyName,
  1030. REF(IHXBuffer*)    pPropertyValue)
  1031. {
  1032.     if ((m_CStringPosition = m_CStringMap.GetStartPosition()) == NULL)
  1033. return HXR_FAILED;
  1035.     _CStoreNameBufferPair* pnbpData = NULL;
  1037.     m_CStringMap.GetNextAssoc(m_CStringPosition,
  1038.                               pPropertyName,
  1039.                               (void*&)pnbpData);
  1041.     pPropertyName = pnbpData->GetName();
  1042.     pPropertyValue = pnbpData->GetValue();
  1044.     return HXR_OK;
  1045. }
  1047. STDMETHODIMP
  1048. CHXHeader::GetNextPropertyCString    (
  1049. REF(const char*)    pPropertyName,
  1050. REF(IHXBuffer*)    pPropertyValue)
  1051. {
  1052.     if (!m_CStringPosition)
  1053. return HXR_FAILED;
  1055.     _CStoreNameBufferPair* pnbpData = NULL;
  1057.     m_CStringMap.GetNextAssoc(m_CStringPosition,
  1058.                               pPropertyName,
  1059.                               (void*&)pnbpData);
  1061.     pPropertyName = pnbpData->GetName();
  1062.     pPropertyValue = pnbpData->GetValue();
  1064.     return HXR_OK;
  1065. }
  1067. void
  1068. CHXHeader::mergeHeaders
  1069. (
  1070.     IHXValues* pIHXValuesDestHeaders, 
  1071.     IHXValues* pIHXValuesSourceHeaders
  1072. )
  1073. {
  1074.     if(pIHXValuesSourceHeaders && pIHXValuesDestHeaders)
  1075.     {
  1076. // add these headers to the existing ones
  1077. //
  1079. const char* pPropName = NULL;
  1080. UINT32 ulPropValue = 0;
  1082. HX_RESULT rc = pIHXValuesSourceHeaders->GetFirstPropertyULONG32
  1083. (
  1084.     pPropName, 
  1085.     ulPropValue
  1086. );
  1088. while(SUCCEEDED(rc))
  1089. {
  1090.     pIHXValuesDestHeaders->SetPropertyULONG32
  1091.     (
  1092. pPropName, 
  1093. ulPropValue
  1094.     );
  1096.     rc = pIHXValuesSourceHeaders->GetNextPropertyULONG32
  1097.     (
  1098. pPropName, 
  1099. ulPropValue
  1100.     );
  1101. }
  1103. IHXBuffer* pBuffer = NULL;
  1104. rc = pIHXValuesSourceHeaders->GetFirstPropertyBuffer
  1105. (
  1106.     pPropName, 
  1107.     pBuffer
  1108. );
  1110. while(SUCCEEDED(rc))
  1111. {
  1112.     pIHXValuesDestHeaders->SetPropertyBuffer(pPropName, pBuffer);
  1113.     pBuffer->Release();
  1114.     rc = pIHXValuesSourceHeaders->GetNextPropertyBuffer
  1115.     (
  1116. pPropName, 
  1117. pBuffer
  1118.     );
  1119. }
  1121. rc = pIHXValuesSourceHeaders->GetFirstPropertyCString
  1122. (
  1123.     pPropName, 
  1124.     pBuffer
  1125. );
  1127. while(SUCCEEDED(rc))
  1128. {
  1129.     pIHXValuesDestHeaders->SetPropertyCString(pPropName, pBuffer);
  1130.     pBuffer->Release();
  1131.     rc = pIHXValuesSourceHeaders->GetNextPropertyCString
  1132.     (
  1133. pPropName, 
  1134. pBuffer
  1135.     );
  1136. }
  1137.     }
  1138. }
  1140. _CStoreName::_CStoreName() : m_strName()
  1141. {
  1142. }
  1143. _CStoreName::~_CStoreName()
  1144. {
  1145. }
  1147. const CHXString& _CStoreName::GetName() const
  1148. {
  1149.     return m_strName;
  1150. }
  1151. void _CStoreName::SetName(const char* szName)
  1152. {
  1153.     m_strName = szName;
  1154. }
  1156. _CStoreNameUINT32Pair::_CStoreNameUINT32Pair() : m_ulValue(0)
  1157. {
  1158. }
  1159. _CStoreNameUINT32Pair::~_CStoreNameUINT32Pair()
  1160. {
  1161. }
  1163. UINT32 _CStoreNameUINT32Pair::GetValue()
  1164. {
  1165.     return m_ulValue;
  1166. }
  1167. void _CStoreNameUINT32Pair::SetValue(UINT32 ulValue)
  1168. {
  1169.     m_ulValue = ulValue;
  1170. }
  1172. _CStoreNameBufferPair::_CStoreNameBufferPair() : m_pbufValue(NULL)
  1173. {
  1174. }
  1175. _CStoreNameBufferPair::~_CStoreNameBufferPair()
  1176. {
  1177.     HX_RELEASE(m_pbufValue);
  1178. }
  1180. IHXBuffer* _CStoreNameBufferPair::GetValue()
  1181. {
  1182.     if(m_pbufValue)
  1183.     {
  1184. m_pbufValue->AddRef();
  1185.     }
  1186.     return m_pbufValue;
  1187. }
  1188. void _CStoreNameBufferPair::SetValue(IHXBuffer* pbufValue)
  1189. {
  1190.     HX_RELEASE(m_pbufValue);
  1192.     m_pbufValue = pbufValue;
  1194.     if(m_pbufValue)
  1195.     {
  1196. m_pbufValue->AddRef();
  1197.     }
  1198. }
  1200. #if 0
  1201. IHXBuffer*
  1202. CHXHeader::encodeBuffer(IHXBuffer* pBuffer)
  1203. {
  1204.     //XXXBAB - come back to this soon...
  1205.     CHXBuffer* pEncodedBuffer = new CHXBuffer;
  1206.     pEncodedBuffer->AddRef();
  1207.     pEncodedBuffer->Set(pBuffer->GetBuffer(), pBuffer->GetSize());
  1208.     return pEncodedBuffer;
  1209. }
  1211. IHXBuffer*
  1212. CHXHeader::encodeCString(IHXBuffer* pBuffer)
  1213. {
  1214.     CHXString tmp;
  1215.     const char* pStr = (const char*)pBuffer->GetBuffer();
  1216.     BOOL inEscape = FALSE;
  1217.     for(size_t i=0;i<strlen(pStr);++i)
  1218.     {
  1219. switch(pStr[i])
  1220. {
  1221.     case 'n':
  1222.     {
  1223. tmp += "\n";
  1224.     }
  1225.     break;
  1227.     case 't':
  1228.     {
  1229. tmp += "\t";
  1230.     }
  1231.     break;
  1233.     case 'r':
  1234.     {
  1235. tmp += "\r";
  1236.     }
  1237.     break;
  1239.     case '"':
  1240.     {
  1241. tmp += "\"";
  1242.     }
  1243.     break;
  1245.     case '\':
  1246.     {
  1247. tmp += "\\";
  1248.     }
  1249.     break;
  1251.     default:
  1252.     {
  1253. tmp += pStr[i];
  1254.     }
  1255. }
  1256.     }
  1257.     CHXBuffer* pEncodedBuffer = new CHXBuffer;
  1258.     pEncodedBuffer->AddRef();
  1259.     pEncodedBuffer->Set((const BYTE*)(const char*)tmp, tmp.GetLength()+1);
  1260.     return pEncodedBuffer;
  1261. }
  1262. #endif