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

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

Symbian

开发平台：

Visual C++

statinfo.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: statinfo.cpp,v 1.8.32.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. #include "safestring.h"
  51. #include "hxtypes.h"
  52. #include "hxresult.h"
  53. #include "hxcom.h"
  54. #include "hxcomm.h"
  55. #include "hxbuffer.h"
  56. #include "hxmon.h"
  57. #include "hxstrutl.h"
  58. #include "watchlst.h"
  59. #include "statinfo.h"
  61. #include "hxheap.h"
  62. #ifdef _DEBUG
  63. #undef HX_THIS_FILE
  64. static const char HX_THIS_FILE[] = __FILE__;
  65. #endif
  67. CStatisticEntry::CStatisticEntry(IHXRegistry*    pRegistry,
  68.  char*     pszRegKey,
  69.  UINT32     ulType)
  70.     : m_bAddKey(FALSE)
  71.     , m_ulRegistryID(0)
  72.     , m_pRegistry(NULL)
  73.     , m_ulType(REG_TYPE_UNKNOWN)
  74. {
  75.     if (pRegistry)
  76.     {
  77. m_pRegistry = pRegistry;
  78. m_pRegistry->AddRef();
  80. m_ulType = ulType;
  82. /*
  83.  * Check to see if this Registry ID already exists
  84.          */
  86. m_ulRegistryID = m_pRegistry->GetId(pszRegKey);
  88. if (!m_ulRegistryID)
  89. {
  90.     m_bAddKey = TRUE;
  92.     if (REG_TYPE_STRING == ulType)
  93.     {
  94. m_ulRegistryID = m_pRegistry->AddStr(pszRegKey, NULL);
  95.     }
  96.     else if (REG_TYPE_NUMBER == ulType)
  97.     {
  98. m_ulRegistryID = m_pRegistry->AddInt(pszRegKey, 0);
  99.     }
  100.     else if (REG_TYPE_COMPOSITE == ulType)
  101.     {
  102. m_ulRegistryID = m_pRegistry->AddComp(pszRegKey);
  103.     }     
  104.     else
  105.     {
  106. m_ulType = REG_TYPE_UNKNOWN;
  107. m_ulRegistryID = 0;
  108.     }
  109. }
  110.     }
  111.     else
  112.     {
  113. m_pRegistry = NULL;
  114. m_ulRegistryID = 0;
  115.     }
  116. }
  118. CStatisticEntry::~CStatisticEntry(void)
  119. {
  120.     if (m_pRegistry)
  121.     {
  122. if (m_ulRegistryID && m_bAddKey)
  123. {
  124.     m_pRegistry->DeleteById(m_ulRegistryID);
  125.     m_ulRegistryID = 0;
  126. }
  128. m_pRegistry->Release();
  129. m_pRegistry = NULL;
  130.     }
  131. }
  133. HX_RESULT
  134. CStatisticEntry::SetInt(INT32 lValue)
  135. {    
  136.     HX_RESULT theErr = HXR_OK;
  138.     if (!m_pRegistry || !m_ulRegistryID ||
  139. (REG_TYPE_NUMBER != m_ulType))
  140.     {
  141. theErr = HXR_FAILED;
  142. goto cleanup;
  143.     }
  145.     theErr = m_pRegistry->SetIntById(m_ulRegistryID, lValue);
  147. cleanup:
  148.     
  149.     return theErr;
  150. }
  152. HX_RESULT
  153. CStatisticEntry::SetStr(char* pszValue)
  154. {    
  155.     IHXBuffer* pValue = NULL;
  156.     HX_RESULT theErr = HXR_OK;
  158.     if (!m_pRegistry || !m_ulRegistryID ||
  159. (REG_TYPE_STRING != m_ulType))
  160.     {
  161. theErr = HXR_FAILED;
  162. goto cleanup;
  163.     }
  165.     if (NULL == pszValue)
  166.     {
  167. theErr = m_pRegistry->SetStrById(m_ulRegistryID, NULL);
  168.     }
  169.     else
  170.     {
  171. if (!(pValue = new CHXBuffer()))
  172. {
  173.     theErr = HXR_OUTOFMEMORY;
  174.     goto cleanup;
  175. }
  176. pValue->AddRef();
  178. pValue->Set((const UCHAR*)pszValue, strlen(pszValue)+1);
  179. theErr = m_pRegistry->SetStrById(m_ulRegistryID, pValue);
  181. pValue->Release();
  182.     }
  184. cleanup:
  185.     
  186.     return theErr;
  187. }
  189. INT32
  190. CStatisticEntry::GetInt(void)
  191. {
  192.     INT32 lValue = 0;
  194.     if (!m_pRegistry || !m_ulRegistryID || (REG_TYPE_NUMBER != m_ulType))
  195.     {
  196. goto cleanup;
  197.     }
  199.     m_pRegistry->GetIntById(m_ulRegistryID, lValue);
  200.    
  201. cleanup:
  203.     return lValue;
  204. }
  206. char*
  207. CStatisticEntry::GetStr(void)
  208. {
  209.     HX_RESULT theErr = HXR_OK;
  210.     IHXBuffer* pValue = NULL;
  211.     char*       pszValue = new char[MAX_DISPLAY_NAME];
  213.     if (!pszValue || !m_pRegistry || !m_ulRegistryID || (REG_TYPE_STRING != m_ulType))
  214.     {
  215. theErr = HXR_UNEXPECTED;
  216. goto cleanup;
  217.     }
  219.     if (HXR_OK != m_pRegistry->GetStrById(m_ulRegistryID, pValue) || !pValue)
  220.     {
  221. theErr = HXR_UNEXPECTED;
  222. goto cleanup;
  223.     }
  225.     SafeStrCpy(pszValue, (const char*)pValue->GetBuffer(), MAX_DISPLAY_NAME);
  226.     
  227. cleanup:
  229.     HX_RELEASE(pValue);
  231.     if (HXR_OK != theErr)
  232.     {
  233. if (pszValue) delete [] pszValue;
  234. pszValue = NULL;
  236. return NULL;
  237.     }
  239.     return pszValue;
  240. }
  242. STATS::STATS(IHXRegistry* /*IN*/  pRegistry,
  243.      UINT32      /*IN*/  ulRegistryID)
  244.     : m_pRegistry(NULL)
  245.     , m_ulRegistryID(0)
  246.     , m_bInitialized(FALSE)
  247.     , m_lastError(HXR_OK)
  248.     , m_pNormal(0)
  249.     , m_pRecovered(0)
  250.     , m_pReceived(0)
  251.     , m_pOutOfOrder(0)
  252.     , m_pLost(0)
  253.     , m_pLate(0)
  254.     , m_pDuplicate(0)
  255.     , m_pTotal(0)
  256.     , m_pLost30(0)
  257.     , m_pTotal30(0)
  258.     , m_pResendRequested(0)
  259.     , m_pResendReceived(0)
  260.     , m_pClipBandwidth(0)
  261.     , m_pAvgBandwidth(0)
  262.     , m_pCurBandwidth(0)
  263.     , m_pHighLatency(0)
  264.     , m_pLowLatency(0)
  265.     , m_pAvgLatency(0)
  266. {
  267.     HX_RESULT theErr = HXR_OK;
  268.     IHXBuffer* pszParentName = NULL;
  269.     char szRegKeyName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  271.     if (!pRegistry)
  272.     {
  273. goto cleanup;
  274.     }
  275.     
  276.     m_pRegistry = pRegistry;
  277.     m_pRegistry->AddRef();
  278.  
  279.     m_ulRegistryID = ulRegistryID;
  281.     if (HXR_OK == m_pRegistry->GetPropName(m_ulRegistryID, pszParentName))
  282.     {
  283. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Normal", pszParentName->GetBuffer());
  284. if (!(m_pNormal = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  285. {
  286.     theErr = HXR_OUTOFMEMORY;
  287.     goto cleanup;
  288. }
  290. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Recovered", pszParentName->GetBuffer());
  291. if (!(m_pRecovered = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  292. {
  293.     theErr = HXR_OUTOFMEMORY;
  294.     goto cleanup;
  295. }
  297. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Received", pszParentName->GetBuffer());
  298. if (!(m_pReceived = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  299. {
  300.     theErr = HXR_OUTOFMEMORY;
  301.     goto cleanup;
  302. }
  304. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.OutOfOrder", pszParentName->GetBuffer());
  305. if (!(m_pOutOfOrder = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  306. {
  307.     theErr = HXR_OUTOFMEMORY;
  308.     goto cleanup;
  309. }
  311. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Lost", pszParentName->GetBuffer());
  312. if (!(m_pLost = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  313. {
  314.     theErr = HXR_OUTOFMEMORY;
  315.     goto cleanup;
  316. }
  318. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Late", pszParentName->GetBuffer());
  319. if (!(m_pLate = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  320. {
  321.     theErr = HXR_OUTOFMEMORY;
  322.     goto cleanup;
  323. }
  325. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Duplicate", pszParentName->GetBuffer());
  326. if (!(m_pDuplicate = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  327. {
  328.     theErr = HXR_OUTOFMEMORY;
  329.     goto cleanup;
  330. }
  332. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Total", pszParentName->GetBuffer());
  333. if (!(m_pTotal = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  334. {
  335.     theErr = HXR_OUTOFMEMORY;
  336.     goto cleanup;
  337. }
  339. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Lost30", pszParentName->GetBuffer());
  340. if (!(m_pLost30 = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  341. {
  342.     theErr = HXR_OUTOFMEMORY;
  343.     goto cleanup;
  344. }
  346. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Total30", pszParentName->GetBuffer());
  347. if (!(m_pTotal30 = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  348. {
  349.     theErr = HXR_OUTOFMEMORY;
  350.     goto cleanup;
  351. }
  353. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.ResendRequested", pszParentName->GetBuffer());
  354. if (!(m_pResendRequested = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  355. {
  356.     theErr = HXR_OUTOFMEMORY;
  357.     goto cleanup;
  358. }
  360. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.ResendReceived", pszParentName->GetBuffer());
  361. if (!(m_pResendReceived = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  362. {
  363.     theErr = HXR_OUTOFMEMORY;
  364.     goto cleanup;
  365. }
  367. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.ClipBandwidth", pszParentName->GetBuffer());
  368. if (!(m_pClipBandwidth = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  369. {
  370.     theErr = HXR_OUTOFMEMORY;
  371.     goto cleanup;
  372. }
  374. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.AverageBandwidth", pszParentName->GetBuffer());
  375. if (!(m_pAvgBandwidth = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  376. {
  377.     theErr = HXR_OUTOFMEMORY;
  378.     goto cleanup;
  379. }
  381. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.CurrentBandwidth", pszParentName->GetBuffer());
  382. if (!(m_pCurBandwidth = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  383. {
  384.     theErr = HXR_OUTOFMEMORY;
  385.     goto cleanup;
  386. }
  388. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.HighLatency", pszParentName->GetBuffer());
  389. if (!(m_pHighLatency = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  390. {
  391.     theErr = HXR_OUTOFMEMORY;
  392.     goto cleanup;
  393. }
  395. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.LowLatency", pszParentName->GetBuffer());
  396. if (!(m_pLowLatency = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  397. {
  398.     theErr = HXR_OUTOFMEMORY;
  399.     goto cleanup;
  400. }
  402. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.AverageLatency", pszParentName->GetBuffer());
  403. if (!(m_pAvgLatency = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  404. {
  405.     theErr = HXR_OUTOFMEMORY;
  406.     goto cleanup;
  407. }
  408.     }
  409.   
  410. cleanup:
  412.     HX_RELEASE(pszParentName);
  414.     if (HXR_OK == theErr)
  415.     {
  416. m_lastError = HXR_OK;
  417. m_bInitialized = TRUE;
  418.     }
  419.     else
  420.     {
  421. m_lastError = theErr;
  422. m_bInitialized = FALSE;
  423.     }
  424. }
  426. STATS::~STATS()
  427. {
  428.     HX_RELEASE(m_pRegistry);
  430.     HX_DELETE(m_pNormal);
  431.     HX_DELETE(m_pRecovered);
  432.     HX_DELETE(m_pReceived);
  433.     HX_DELETE(m_pOutOfOrder);
  434.     HX_DELETE(m_pLost);
  435.     HX_DELETE(m_pLate);
  436.     HX_DELETE(m_pDuplicate);
  437.     HX_DELETE(m_pTotal);
  438.     HX_DELETE(m_pLost30);
  439.     HX_DELETE(m_pTotal30);
  440.     HX_DELETE(m_pClipBandwidth);
  441.     HX_DELETE(m_pResendRequested);
  442.     HX_DELETE(m_pResendReceived);
  443.     HX_DELETE(m_pAvgBandwidth);
  444.     HX_DELETE(m_pCurBandwidth);
  445.     HX_DELETE(m_pHighLatency);
  446.     HX_DELETE(m_pLowLatency);
  447.     HX_DELETE(m_pAvgLatency);
  448. }
  450. STATS& STATS::operator=(const STATS& rhs )
  451. {
  452.     if( this != &rhs )
  453.     {
  454.         m_pNormal->SetInt( rhs.m_pNormal->GetInt());
  455.         m_pRecovered->SetInt( rhs.m_pRecovered->GetInt());
  456.         m_pReceived->SetInt( rhs.m_pReceived->GetInt());
  457.         m_pOutOfOrder->SetInt( rhs.m_pOutOfOrder->GetInt());
  458.         m_pLost->SetInt( rhs.m_pLost->GetInt());
  459.         m_pLate->SetInt( rhs.m_pLate->GetInt());
  460. m_pDuplicate->SetInt( rhs.m_pDuplicate->GetInt());
  461.         m_pTotal->SetInt( rhs.m_pTotal->GetInt());
  462.         m_pLost30->SetInt( rhs.m_pLost30->GetInt());
  463.         m_pTotal30->SetInt( rhs.m_pTotal30->GetInt());
  464.         m_pClipBandwidth->SetInt( rhs.m_pClipBandwidth->GetInt());
  465.         m_pResendRequested->SetInt( rhs.m_pResendRequested->GetInt());
  466.         m_pResendReceived->SetInt( rhs.m_pResendReceived->GetInt());
  467.         m_pAvgBandwidth->SetInt( rhs.m_pAvgBandwidth->GetInt());
  468.         m_pCurBandwidth->SetInt( rhs.m_pCurBandwidth->GetInt());
  469.         m_pHighLatency->SetInt( rhs.m_pHighLatency->GetInt());
  470.         m_pLowLatency->SetInt( rhs.m_pLowLatency->GetInt());
  471.         m_pAvgLatency->SetInt( rhs.m_pAvgLatency->GetInt());
  472.     }
  473.     
  474.     return *this;
  475. }
  477. void
  478. STATS::Reset()
  479. {
  480.     if (m_bInitialized)
  481.     {
  482. m_pNormal->SetInt(0);
  483. m_pRecovered->SetInt(0);
  484. m_pReceived->SetInt(0);
  485. m_pOutOfOrder->SetInt(0);
  486. m_pLost->SetInt(0);
  487. m_pLate->SetInt(0);
  488. m_pDuplicate->SetInt(0);
  489. m_pTotal->SetInt(0);
  490. m_pLost30->SetInt(0);
  491. m_pTotal30->SetInt(0);
  492. m_pClipBandwidth->SetInt(0);
  493. m_pResendRequested->SetInt(0);
  494. m_pResendReceived->SetInt(0);
  495. m_pAvgBandwidth->SetInt(0);
  496. m_pCurBandwidth->SetInt(0);
  497. m_pHighLatency->SetInt(0);
  498. m_pLowLatency->SetInt(0);
  499. m_pAvgLatency->SetInt(0);
  500.     }
  501. }
  503. PLAYER_STATS::PLAYER_STATS(IHXRegistry*   /*IN*/  pRegistry, 
  504.    UINT32      /*IN*/  ulRegistryID) 
  505.      :STATS(pRegistry, ulRegistryID)
  506.      ,m_pBufferingMode(NULL)
  507. {
  508.     HX_RESULT theErr = HXR_OK;
  509.     IHXBuffer* pszParentName = NULL;
  510.     char szRegKeyName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  512.     if (!pRegistry)
  513.     {
  514. goto cleanup;
  515.     }
  517.     if (HXR_OK == m_pRegistry->GetPropName(m_ulRegistryID, pszParentName))
  518.     {
  519. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.BufferingMode", pszParentName->GetBuffer());
  520. if (!(m_pBufferingMode = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  521. {
  522.     theErr = HXR_OUTOFMEMORY;
  523.     goto cleanup;
  524. }
  525.     }
  527. cleanup:
  529.     HX_RELEASE(pszParentName);
  531.     if (HXR_OK == theErr)
  532.     {
  533. m_lastError = HXR_OK;
  534. m_bInitialized = TRUE;
  535.     }
  536.     else
  537.     {
  538. m_lastError = theErr;
  539. m_bInitialized = FALSE;
  540.     }
  541. }
  543. PLAYER_STATS::~PLAYER_STATS()
  544. {
  545.     HX_DELETE(m_pBufferingMode);
  546. }
  548. PLAYER_STATS& PLAYER_STATS::operator=(const PLAYER_STATS& rhs )
  549. {
  550.     if( this != &rhs )
  551.     {
  552.         STATS::operator=(rhs);
  553.         m_pBufferingMode->SetInt( rhs.m_pBufferingMode->GetInt() );
  554.     }
  555.     
  556.     return *this;
  557. }
  559. void
  560. PLAYER_STATS::Reset()
  561. {
  562.     if (m_bInitialized)
  563.     {
  564. m_pBufferingMode->SetInt(0);
  566. STATS::Reset();
  567.     }
  568. }
  570. SOURCE_STATS::SOURCE_STATS(IHXRegistry*   /*IN*/  pRegistry,
  571.    UINT32      /*IN*/  ulRegistryID)
  572.      :STATS(pRegistry, ulRegistryID)
  573. {
  574.     HX_RESULT theErr = HXR_OK;
  575.     IHXBuffer* pszParentName = NULL;
  576.     char szRegKeyName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  578.     m_pTransportMode = NULL;
  579.     m_pBufferingMode = NULL;
  580.     m_pTitle = NULL;
  581.     m_pAuthor = NULL;
  582.     m_pCopyright = NULL;
  583.     m_pAbstract = NULL;
  584.     m_pDescription = NULL;
  585.     m_pKeywords = NULL;
  586.     m_pSourceName = NULL;
  587.     m_pServerInfo = NULL;
  588.     m_pProtocolVersion = NULL;
  589.     m_pProtocol = NULL;
  591.     if (!pRegistry)
  592.     {
  593. goto cleanup;
  594.     }
  595.    
  596.     if (HXR_OK == m_pRegistry->GetPropName(m_ulRegistryID, pszParentName))
  597.     {
  598. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.TransportMode", pszParentName->GetBuffer());
  599. if (!(m_pTransportMode = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  600. {
  601.     theErr = HXR_OUTOFMEMORY;
  602.     goto cleanup;
  603. }
  605. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.BufferingMode", pszParentName->GetBuffer());
  606. if (!(m_pBufferingMode = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  607. {
  608.     theErr = HXR_OUTOFMEMORY;
  609.     goto cleanup;
  610. }
  612. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.SourceName", pszParentName->GetBuffer());
  613. if (!(m_pSourceName = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  614. {
  615.     theErr = HXR_OUTOFMEMORY;
  616.     goto cleanup;
  617. }
  619. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.ServerInfo", pszParentName->GetBuffer());
  620. if (!(m_pServerInfo = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  621. {
  622.     theErr = HXR_OUTOFMEMORY;
  623.     goto cleanup;
  624. }
  626. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.ProtocolVersion", pszParentName->GetBuffer());
  627. if (!(m_pProtocolVersion = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_NUMBER)))
  628. {
  629.     theErr = HXR_OUTOFMEMORY;
  630.     goto cleanup;
  631. }
  633. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Protocol", pszParentName->GetBuffer());
  634. if (!(m_pProtocol = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  635. {
  636.     theErr = HXR_OUTOFMEMORY;
  637.     goto cleanup;
  638. }
  640. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Title", pszParentName->GetBuffer());
  641. if (!(m_pTitle = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  642. {
  643.     theErr = HXR_OUTOFMEMORY;
  644.     goto cleanup;
  645. }
  647. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Author", pszParentName->GetBuffer());
  648. if (!(m_pAuthor = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  649. {
  650.     theErr = HXR_OUTOFMEMORY;
  651.     goto cleanup;
  652. }
  654. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Copyright", pszParentName->GetBuffer());
  655. if (!(m_pCopyright = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  656. {
  657.     theErr = HXR_OUTOFMEMORY;
  658.     goto cleanup;
  659. }
  661. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Abstract", pszParentName->GetBuffer());
  662. if (!(m_pAbstract = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  663. {
  664.     theErr = HXR_OUTOFMEMORY;
  665.     goto cleanup;
  666. }
  667.     
  668. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Description", pszParentName->GetBuffer());
  669. if (!(m_pDescription = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  670. {
  671.     theErr = HXR_OUTOFMEMORY;
  672.     goto cleanup;
  673. }
  675. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Keywords", pszParentName->GetBuffer());
  676. if (!(m_pKeywords = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  677. {
  678.     theErr = HXR_OUTOFMEMORY;
  679.     goto cleanup;
  680. }
  681.     }
  683. cleanup:
  685.     HX_RELEASE(pszParentName);
  687.     if (HXR_OK == theErr)
  688.     {
  689. m_lastError = HXR_OK;
  690. m_bInitialized = TRUE;
  691.     }
  692.     else
  693.     {
  694. m_lastError = theErr;
  695. m_bInitialized = FALSE;
  696.     }
  697. }
  699. SOURCE_STATS::~SOURCE_STATS()
  700. {
  701.     HX_DELETE(m_pTransportMode);
  702.     HX_DELETE(m_pBufferingMode);
  703.     HX_DELETE(m_pSourceName);
  704.     HX_DELETE(m_pServerInfo);
  705.     HX_DELETE(m_pProtocolVersion);
  706.     HX_DELETE(m_pProtocol);
  707.     HX_DELETE(m_pTitle);
  708.     HX_DELETE(m_pAuthor);
  709.     HX_DELETE(m_pCopyright);
  710.     HX_DELETE(m_pAbstract);
  711.     HX_DELETE(m_pDescription);
  712.     HX_DELETE(m_pKeywords);
  713. }
  715. SOURCE_STATS& SOURCE_STATS::operator=(const SOURCE_STATS& rhs )
  716. {
  717.     if( this != &rhs )
  718.     {
  719.         STATS::operator=(rhs);
  721.         HX_ASSERT( m_bInitialized );
  722.         if (m_bInitialized)
  723.         {
  724.             m_pTransportMode->SetStr(rhs.m_pTransportMode->GetStr());
  725.             m_pBufferingMode->SetInt(rhs.m_pBufferingMode->GetInt());
  726.             m_pSourceName->SetStr(rhs.m_pSourceName->GetStr());
  727.             m_pServerInfo->SetStr(rhs.m_pServerInfo->GetStr());
  728.             m_pProtocolVersion->SetInt(rhs.m_pProtocolVersion->GetInt());
  729.             m_pProtocol->SetStr(rhs.m_pProtocol->GetStr());
  730.             m_pTitle->SetStr(rhs.m_pTitle->GetStr());
  731.             m_pAuthor->SetStr(rhs.m_pAuthor->GetStr());
  732.             m_pCopyright->SetStr(rhs.m_pCopyright->GetStr());
  733.             m_pAbstract->SetStr(rhs.m_pAbstract->GetStr());
  734.             m_pDescription->SetStr(rhs.m_pDescription->GetStr());
  735.             m_pKeywords->SetStr(rhs.m_pKeywords->GetStr());
  736.         }
  737.     }
  738.     
  739.     return *this;
  740. }
  742. void
  743. SOURCE_STATS::Reset()
  744. {
  745.     if (m_bInitialized)
  746.     {
  747. m_pTransportMode->SetStr(NULL);
  748. m_pBufferingMode->SetInt(0);
  749. m_pSourceName->SetStr(NULL);
  750. m_pServerInfo->SetStr(NULL);
  751. m_pProtocolVersion->SetInt(0);
  752. m_pProtocol->SetStr(NULL);
  753. m_pTitle->SetStr(NULL);
  754. m_pAuthor->SetStr(NULL);
  755. m_pCopyright->SetStr(NULL);
  756. m_pAbstract->SetStr(NULL);
  757. m_pDescription->SetStr(NULL);
  758. m_pKeywords->SetStr(NULL);
  760. STATS::Reset();
  761.     }
  762. }
  764. STREAM_STATS::STREAM_STATS(IHXRegistry*   /*IN*/  pRegistry,
  765.    UINT32      /*IN*/  ulRegistryID)
  766.      :STATS(pRegistry, ulRegistryID)
  767. {
  768.     HX_RESULT theErr = HXR_OK;
  769.     IHXBuffer* pszParentName = NULL;
  770.     char szRegKeyName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  771.     
  772.     m_pRenderer = NULL;
  773.     m_pMimeType = NULL;
  775.     if (!pRegistry)
  776.     {
  777. goto cleanup;
  778.     }
  779.     
  780.     if (HXR_OK == m_pRegistry->GetPropName(m_ulRegistryID, pszParentName))
  781.     {
  782. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.Renderer", pszParentName->GetBuffer());
  783. if (!(m_pRenderer = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_COMPOSITE)))
  784. {
  785.     theErr = HXR_OUTOFMEMORY;
  786.     goto cleanup;
  787. }
  789. SafeSprintf(szRegKeyName, MAX_DISPLAY_NAME, "%s.MimeType", pszParentName->GetBuffer());
  790. if (!(m_pMimeType = new CStatisticEntry(m_pRegistry, szRegKeyName, REG_TYPE_STRING)))
  791. {
  792.     theErr = HXR_OUTOFMEMORY;
  793.     goto cleanup;
  794. }
  796.     }
  797.         
  798. cleanup:
  800.     HX_RELEASE(pszParentName);
  802.     if (HXR_OK == theErr)
  803.     {
  804. m_lastError = HXR_OK;
  805. m_bInitialized = TRUE;
  806.     }
  807.     else
  808.     {
  809. m_lastError = theErr;
  810. m_bInitialized = FALSE;
  811.     }
  812. }
  814. STREAM_STATS::~STREAM_STATS()
  815. {
  816.     HX_DELETE(m_pRenderer);
  817.     HX_DELETE(m_pMimeType);
  818. }
  820. STREAM_STATS& STREAM_STATS::operator=(const STREAM_STATS& rhs )
  821. {
  822.     if( this != &rhs )
  823.     {
  824.         HX_ASSERT( m_bInitialized );
  825.         if (m_bInitialized)
  826.         {
  827.     STATS::operator=(rhs);
  828.             m_pMimeType->SetStr( rhs.m_pMimeType->GetStr() );
  829.         }
  830.     }
  831.     
  832.     return *this;
  833. }
  835. void
  836. STREAM_STATS::Reset()
  837. {
  838.     if (m_bInitialized)
  839.     {
  840. m_pMimeType->SetStr(NULL);
  841. STATS::Reset();
  842.     }
  843. }
  845. BOOL SetIntIfNecessary(CStatisticEntry* pEntry, INT32 lValue)
  846. {
  847.     BOOL bResult = FALSE;
  849.     if (!pEntry)
  850.     {
  851. goto cleanup;
  852.     }
  854.     if (pEntry->GetInt() != lValue)
  855.     {
  856. pEntry->SetInt(lValue);
  857. bResult = TRUE;
  858.     }
  860. cleanup:
  862.     return bResult;
  863. }