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

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "hxtypes.h"
  36. #include "hxassert.h"
  37. #include "hxcom.h"
  38. #include "ihxpckts.h"
  39. #include "hxstrutl.h"
  40. #include "hxheap.h"
  41. #ifdef _DEBUG
  42. #undef HX_THIS_FILE
  43. static const char HX_THIS_FILE[] = __FILE__;
  44. #endif
  45. #include "rlstate.h"
  46. static const char WAITFORSWITCHOFF[] = "WaitForSwitchOff";
  47. static const size_t WAITFORSWITCHOFFLEN = sizeof(WAITFORSWITCHOFF) - 1;
  48. static const char ONDEPEND[] = "OnDepend";
  49. static const size_t ONDEPENDLEN = sizeof(ONDEPEND) - 1;
  50. static const char OFFDEPEND[] = "OffDepend";
  51. static const size_t OFFDEPENDLEN = sizeof(OFFDEPEND) - 1;
  52. #define NO_DEPEND_SET 0xFFFF
  53. inline void SKIP_WHITE_SPACE(char* __x)
  54. {
  55.     while (*__x == ' ' || *__x == 't' || *__x == 'n' || *__x == 'r')
  56.     {
  57. __x++;
  58.     }
  59. }
  60. /****************************************************************************
  61.  *  Method:
  62.  *    CASMRuleState::CASMRuleState
  63.  *
  64.  */
  65. CASMRuleState::CASMRuleState(UINT16 nNumRules, char* pRuleBook, 
  66.      UINT16 usBookSize)
  67. {
  68.     m_nNumRules = nNumRules;
  69.     m_bNeedSwitchOff = new BOOL[nNumRules];
  70.     m_bSubscribePending = new BOOL[nNumRules];     
  71.     m_bSubscribed = new BOOL[nNumRules];
  72.     m_bUnsubscribePending = new BOOL[nNumRules];
  73.     m_lastASMFlagsForThisRule = new UINT8[nNumRules];
  74.     m_OnDepends = new UINT16*[nNumRules];
  75.     m_OffDepends = new UINT16*[nNumRules];
  76.     for (UINT16 i = 0; i < nNumRules; i++)
  77.     {
  78. m_bNeedSwitchOff[i] = FALSE;
  79. m_bSubscribePending[i] = FALSE;
  80. m_bSubscribed[i] = FALSE;
  81. m_bUnsubscribePending[i] = FALSE;
  82. m_lastASMFlagsForThisRule[i] = 0;
  83. m_OnDepends[i] = NULL;
  84. m_OffDepends[i] = NULL;
  85.     }
  86.     ParseRuleBookForDirectives(m_nNumRules, pRuleBook, usBookSize,
  87. m_bNeedSwitchOff, m_OffDepends, m_OnDepends);
  88. }
  89. /****************************************************************************
  90.  *  Method:
  91.  *    CASMRuleState::~CASMRuleState
  92.  *
  93.  */
  94. CASMRuleState::~CASMRuleState()
  95. {
  96.     HX_VECTOR_DELETE(m_bSubscribePending);
  97.     HX_VECTOR_DELETE(m_bSubscribed);
  98.     HX_VECTOR_DELETE(m_bUnsubscribePending);
  99.     HX_VECTOR_DELETE(m_lastASMFlagsForThisRule);
  100.     HX_VECTOR_DELETE(m_bNeedSwitchOff);
  101.     for (UINT16 i = 0; i < m_nNumRules; i++)
  102.     {
  103. HX_VECTOR_DELETE(m_OffDepends[i]);
  104. HX_VECTOR_DELETE(m_OnDepends[i]);
  105.     }
  106.     HX_VECTOR_DELETE(m_OffDepends);
  107.     HX_VECTOR_DELETE(m_OnDepends);
  108.     m_nNumRules = 0;
  109. }
  110. /****************************************************************************
  111.  *  Method:
  112.  *    CASMRuleState::ParseRuleBookDirectives
  113.  *
  114.  */
  115. void 
  116. CASMRuleState::ParseRuleBookForDirectives(UINT16 num_rules,
  117.   char* pRuleBook,
  118.   UINT16 usBookSize,
  119.   BOOL* pNeedSwitchOff,
  120.   UINT16** pOffDepends, 
  121.   UINT16** pOnDepends)
  122. {
  123.     char* pOffset = pRuleBook;
  124.     UINT16 idxCurrentRule = 0;
  125.     while(*pOffset != '' && ((UINT16)(pOffset - pRuleBook) < usBookSize))
  126.     {
  127. while(*pOffset != ';')
  128. {
  129.     if (*pOffset == 'w' || *pOffset == 'W')
  130.     {
  131. // check to see if we have a wait directive
  132. if (strncasecmp(WAITFORSWITCHOFF, pOffset, 
  133. WAITFORSWITCHOFFLEN) == 0)
  134. {
  135.     pOffset += WAITFORSWITCHOFFLEN;
  136.     
  137.     SKIP_WHITE_SPACE(pOffset);
  138.     // should have an = sign
  139.     HX_ASSERT(*pOffset == '=');
  140.     pOffset ++;
  141.     SKIP_WHITE_SPACE(pOffset);
  142.     pNeedSwitchOff[idxCurrentRule] = 
  143. (*pOffset == 't' || *pOffset == 'T');
  144. }
  145.     }
  146.     if (*pOffset == 'o' || *pOffset == 'O')
  147.     {
  148. BOOL bDependsList = FALSE;
  149. UINT16* pDependsList = NULL;
  150. if (strncasecmp(ONDEPEND, pOffset, 
  151. ONDEPENDLEN) == 0)
  152. {
  153.     bDependsList = TRUE;
  154.     pDependsList = new UINT16[num_rules];
  155.     pOnDepends[idxCurrentRule] = pDependsList;
  156.     memset(pDependsList, 0xFF, sizeof(UINT16) * num_rules);
  157.     pOffset += ONDEPENDLEN;
  158. }
  159. else if (strncasecmp(OFFDEPEND, pOffset, 
  160. OFFDEPENDLEN) == 0)
  161. {
  162.     bDependsList = TRUE;
  163.     pDependsList = new UINT16[num_rules];
  164.     pOffDepends[idxCurrentRule] = pDependsList;
  165.     memset(pDependsList, 0xFF, sizeof(UINT16) * num_rules);
  166.     pOffset += OFFDEPENDLEN;
  167. }
  168. if (bDependsList)
  169. {
  170.     SKIP_WHITE_SPACE(pOffset);
  171.     HX_ASSERT(*pOffset == '=');
  172.     pOffset++;
  173.     SKIP_WHITE_SPACE(pOffset);
  174.     pOffset = ParseDependsList(pOffset, pDependsList);
  175. }
  176.     }
  177.     pOffset++;
  178. }
  179. idxCurrentRule++;
  180. pOffset++;
  181.     }
  182. }
  183. /****************************************************************************
  184.  *  Method:
  185.  *    CASMRuleState::ParseRuleBookDirectives
  186.  *
  187.  */
  188. char* 
  189. CASMRuleState::ParseDependsList(char* pDependsText, UINT16* pDependsList)
  190. {
  191.     char* pOffset = pDependsText;
  192.     UINT16 idxCurrentDepends = 0;
  193.     UINT16 nCurrentDepends = 0;
  194.     
  195.     SKIP_WHITE_SPACE(pOffset);
  196.     // depends directive list is in "'s
  197.     if (*pOffset != '"')
  198.     {
  199. HX_ASSERT(*pOffset == '"');
  200.     }
  201.     else
  202.     {
  203. // skip the first "
  204. pOffset++;
  205. // parse string till we find the last "
  206. while (*pOffset != '"')
  207. {
  208.             SKIP_WHITE_SPACE(pOffset);
  209.     // should be a list of numbers and we are at the beginning of one
  210.     while(*pOffset >= '0' && *pOffset <= '9')
  211.     {
  212. nCurrentDepends =  
  213.     (nCurrentDepends * 10) + *pOffset - '0';
  214. pOffset++;
  215.     }
  216.     pDependsList[idxCurrentDepends] = nCurrentDepends;
  217.     SKIP_WHITE_SPACE(pOffset);
  218.     // depend numbers are seperated by commas or this could be
  219.     // the last one
  220.     if (*pOffset == ',')
  221.     {
  222. pOffset++;
  223.     }
  224.     else
  225.     {
  226. // if it wasn't a comma, it better be the end of the depends
  227. // list
  228. HX_ASSERT(*pOffset == '"');
  229.     }
  230. }
  231.     }
  232.     return pOffset;
  233. }
  234. /****************************************************************************
  235.  *  Method:
  236.  *    CASMRuleState::StartSubscribePending
  237.  *
  238.  */
  239. void 
  240. CASMRuleState::StartSubscribePending(UINT16 usRuleNum)
  241. {
  242.     HX_ASSERT(usRuleNum < m_nNumRules);
  243. //printf("%luttSubscribe Pending:t%un", this, usRuleNum);
  244.     if (m_bUnsubscribePending[usRuleNum])
  245.     {
  246. //printf("%luttImediate Subscribe (was pending Unsubscribe):t%un", this, usRuleNum);
  247. m_bUnsubscribePending[usRuleNum] = FALSE;
  248. m_bSubscribed[usRuleNum] = TRUE;
  249.     }
  250.     else
  251.     {
  252.         m_bSubscribePending[usRuleNum] = TRUE;
  253.     }
  254. }
  255. /****************************************************************************
  256.  *  Method:
  257.  *    CASMRuleState::CanSubscribeNow
  258.  *
  259.  */
  260. BOOL
  261. CASMRuleState::CanSubscribeNow(UINT16 usRuleNum)
  262. {
  263.     // check for OnDepen dependent rules for this rule, if they are all
  264.     // subscribed then this rule can subscribe
  265.     UINT16 idxDepend;
  266.     BOOL bAllDependsSubscribed = TRUE;
  267.     if (m_OnDepends[usRuleNum] != NULL)
  268.     {
  269. // once we find one depend pending we can stop looking
  270. for (idxDepend = 0; idxDepend < m_nNumRules && 
  271. m_OnDepends[usRuleNum][idxDepend] != NO_DEPEND_SET && 
  272. bAllDependsSubscribed; idxDepend++)
  273. {
  274.     // if the dependent rule is not subscribed then we have a
  275.     // dependPending
  276.     bAllDependsSubscribed = 
  277. m_bSubscribed[m_OnDepends[usRuleNum][idxDepend]];
  278. }
  279.     }
  280.     // we can subscribe as long as all dependent rules are subscribed
  281.     return bAllDependsSubscribed;
  282. }
  283. /****************************************************************************
  284.  *  Method:
  285.  *    CASMRuleState::CompleteSubscribe
  286.  *
  287.  */
  288. void
  289. CASMRuleState::CompleteSubscribe(UINT16 usRuleNum)
  290. {
  291.     HX_ASSERT(usRuleNum < m_nNumRules);
  292. //printf("%luttSubscribe Complete:t%urn", this, usRuleNum);
  293.     m_bSubscribePending[usRuleNum] = FALSE;
  294.     m_bSubscribed[usRuleNum] = TRUE;
  295. }
  296. /****************************************************************************
  297.  *  Method:
  298.  *    CASMRuleState::StartUnsubscribePending
  299.  *
  300.  */
  301. void
  302. CASMRuleState::StartUnsubscribePending(UINT16 usRuleNum)
  303. {
  304.     HX_ASSERT(usRuleNum < m_nNumRules);
  305. //printf("%luttUnsubscribe Pending:t%urn", this, usRuleNum);
  306.     if (m_bSubscribed[usRuleNum])
  307.     {
  308. m_bUnsubscribePending[usRuleNum] = TRUE;
  309.     }
  310.     else
  311.     {
  312. /*
  313.  * when a client subscribes to a rule and then decides to subscribe to a
  314.  * mutually exclusive rule (e.g. 8 and then 6), the subscribe to the second
  315.  * rule calls ASMRuleState::CancelStreamSwitch which clears all pending
  316.  * subscribes (i.e. the one to 8) and then starts a subscribe pending to 6.
  317.  * Later the client comes along and decides to explicitly unsubscribe to 8
  318.  * which causes an assertion failure in the asm rule state.  
  319.  */
  320. // HX_ASSERT(m_bSubscribePending[usRuleNum]);
  321. /*
  322.  *  This should be fine since a new subscription state must have been established.
  323.  */
  324.  
  325. // we can cancel this pending subscribe if we are unsubscribing
  326. m_bSubscribePending[usRuleNum] = FALSE;
  327.     }
  328. }
  329. /****************************************************************************
  330.  *  Method:
  331.  *    CASMRuleState::CanUnsubscribeNow
  332.  *
  333.  */
  334. BOOL
  335. CASMRuleState::CanUnsubscribeNow(UINT16 usRuleNum)
  336. {
  337.     // check for OffDepen dependent rules for this rule, if any are 
  338.     // subscribed then this rule can't unsubscribe
  339.     UINT16 idxDepend;
  340.     BOOL bAllDependsUnsubscribed = TRUE;
  341.     if (m_OffDepends[usRuleNum] != NULL)
  342.     {
  343. // once we find one depend pending we can stop looking
  344. for (idxDepend = 0; idxDepend < m_nNumRules && 
  345.       m_OffDepends[usRuleNum][idxDepend] != NO_DEPEND_SET && 
  346.       bAllDependsUnsubscribed; idxDepend++)
  347. {
  348.     // if the dependent rule is still subscribed then we have a
  349.     // dependent rule that's not unsubscribed
  350.     bAllDependsUnsubscribed = 
  351. !m_bSubscribed[m_OffDepends[usRuleNum][idxDepend]];
  352. }
  353.     }
  354.     // we can unsubscribe if there aren't any dependent rules subscribed
  355.     return bAllDependsUnsubscribed;
  356. }
  357. /****************************************************************************
  358.  *  Method:
  359.  *    CASMRuleState::CompleteUnsubscribe
  360.  *
  361.  */
  362. void
  363. CASMRuleState::CompleteUnsubscribe(UINT16 usRuleNum)
  364. {
  365.     HX_ASSERT(usRuleNum < m_nNumRules);
  366. //printf("%luttUnsubscribe Complete:t%urn", this, usRuleNum);
  367.     m_bUnsubscribePending[usRuleNum] = FALSE;
  368.     m_bSubscribed[usRuleNum] = FALSE;
  369. }
  370. /****************************************************************************
  371.  *  Method:
  372.  *    CASMRuleState::CanSwitchStreamsNow
  373.  *
  374.  */
  375. BOOL
  376. CASMRuleState::CanSwitchStreamsNow()
  377. {
  378.     UINT16 i = 0;
  379.     // if there are no unsubscribes pending && there are no subscribed
  380.     // rules
  381.     while (i < m_nNumRules && !m_bUnsubscribePending[i] && 
  382. !m_bSubscribed[i])
  383.     {
  384. i++;
  385.     }
  386.     return (i == m_nNumRules);
  387. }
  388. /****************************************************************************
  389.  *  Method:
  390.  *    CASMRuleState::CompleteStreamSwitch
  391.  *
  392.  */
  393. void
  394. CASMRuleState::CompleteStreamSwitch()
  395. {
  396. //printf("%lutt--->Compete Stream Switchrn", this);
  397.     // mark all of the pending rules subscribed to
  398.     for (UINT16 usRuleNumber = 0; usRuleNumber < m_nNumRules;
  399. usRuleNumber++)
  400.     {
  401. if (IsSubscribePending(usRuleNumber))
  402. {
  403.     CompleteSubscribe(usRuleNumber);
  404. }
  405.     }
  406. //printf("%lutt<---Stream Switch Completedrn", this);
  407. }
  408. /****************************************************************************
  409.  *  Method:
  410.  *    CASMRuleState::CancelStreamSwitch
  411.  *
  412.  */
  413. void
  414. CASMRuleState::CancelStreamSwitch()
  415. {
  416. //printf("%luttCancel Stream Switchrn", this);
  417.     // mark all of the pending rules subscribed to
  418.     for (UINT16 usRuleNumber = 0; usRuleNumber < m_nNumRules;
  419. usRuleNumber++)
  420.     {
  421. m_bSubscribePending[usRuleNumber] = FALSE;
  422.     }
  423. }
  424. /****************************************************************************
  425.  *  Method:
  426.  *    CASMRuleState::CompleteAllUnsubscribes
  427.  *
  428.  */
  429. void
  430. CASMRuleState::CompleteAllUnsubscribes()
  431. {
  432. //printf("%lutt--->Compete Unsubscribe All Rulesrn", this);
  433.     for (UINT16 usRuleNumber = 0; usRuleNumber < m_nNumRules;
  434. usRuleNumber++)
  435.     {
  436. if (IsUnsubscribePending(usRuleNumber))
  437. {
  438.     CompleteUnsubscribe(usRuleNumber);
  439. }
  440.     }
  441. //printf("%lutt<---All Rules Unsubscribe Completern", this);
  442. }
  443. /****************************************************************************
  444.  *  Method:
  445.  *    CASMRuleState::AnyPendingUnsubscribes
  446.  *
  447.  */
  448. BOOL 
  449. CASMRuleState::AnyPendingUnsubscribes()
  450. {
  451.     UINT16 usRuleNumber;
  452.     for (usRuleNumber = 0; usRuleNumber < m_nNumRules;
  453. usRuleNumber++)
  454.     {
  455. if (IsUnsubscribePending(usRuleNumber))
  456. {
  457.     break;
  458. }
  459.     }
  460.     return usRuleNumber < m_nNumRules;
  461. }
  462. /****************************************************************************
  463.  *  Method:
  464.  *    CASMRuleState::GetNextPendingUnsubscribe
  465.  *
  466.  */
  467. UINT16 
  468. CASMRuleState::GetNextPendingUnsubscribe()
  469. {
  470.     UINT16 usRuleNumber;
  471.     for (usRuleNumber = 0; usRuleNumber < m_nNumRules;
  472. usRuleNumber++)
  473.     {
  474. if (IsUnsubscribePending(usRuleNumber))
  475. {
  476.     break;
  477. }
  478.     }
  479.     HX_ASSERT(usRuleNumber < m_nNumRules);
  480.     return usRuleNumber;
  481. }