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

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

Symbian

开发平台：

Visual C++

commreg.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: commreg.cpp,v 1.10.32.3.2.1 2005/03/29 06:04:47 ehodge 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 "hxcom.h"
  51. // #include <stdio.h>
  52. #include "hlxclib/stdlib.h"
  53. #include "hlxclib/string.h"
  55. #include "hxtypes.h"
  56. #include "debug.h"
  57. #include "ihxpckts.h"
  58. #include "hxmon.h"
  59. #include "hxstrutl.h"
  60. #include "chxpckts.h"
  61. #include "db_misc.h"
  62. #include "key.h"
  64. #include "watchlst.h"
  65. #include "property.h"
  66. #include "db_dict_abs.h"
  67. #include "db_dict.h"
  68. #include "id.h"
  69. #include "commreg.h"
  71. #include "hxheap.h"
  72. #ifdef _DEBUG
  73. #undef HX_THIS_FILE
  74. static const char HX_THIS_FILE[] = __FILE__;
  75. #endif
  77. CommonRegistry::CommonRegistry()
  78.               : _count(0)
  79.       , m_pWatchList(NULL)
  80.       , m_lWatchCount(0)
  81.       , m_LastError(HXR_OK)
  82. {
  83.     _logdb_imp = new DB_dict;
  84.     if(!_logdb_imp)
  85.     {
  86.         m_LastError = HXR_OUTOFMEMORY;
  87.     }
  88.     _ids = new CHXID(1000);
  89.     if(!_ids)
  90.     {
  91.         m_LastError = HXR_OUTOFMEMORY;
  92.     }
  94.     DPRINTF(D_REGISTRY, ("CommonRegistry::CommonRegistry -- _logdb_imp(%p), "
  95.                          "_ids(%p)n", _logdb_imp, _ids));
  96. }
  98. CommonRegistry::~CommonRegistry()
  99. {
  100.     if (_logdb_imp)
  101. delete _logdb_imp;
  102.     if (_ids)
  103. delete _ids;
  104. }
  106. /*
  107.  *  Function Name:   AddComp
  108.  *  Input Params:    char * prop_name
  109.  *  Return Value:    UINT32
  110.  *  Description:
  111.  *   function for adding PT_COMPOSITE nodes in the log database.
  112.  *  PT_COMPOSITE nodes can contain other nodes, this is the structure
  113.  *  demanded by the hierarchical storage.
  114.  */
  115. UINT32
  116. CommonRegistry::AddComp(const char* prop_name)
  117. {
  118.     DPRINTF(D_REGISTRY, ("CommonRegistry::AddComp(%s)n", prop_name));
  120.     HX_RESULT theErr = HXR_OK;
  121.     DB_node* d = 0;
  122.     Property* p = 0;
  123.     Key* k = new Key(prop_name);
  124.     if(!k)
  125.     {
  126.         return 0;
  127.     }
  128.     int len = k->size();
  129.     char* curr_key_str = new char[len];
  130.     if(!curr_key_str)
  131.     {
  132.         HX_DELETE(k);
  133.         return 0;
  134.     }
  135.     DB_implem* ldb = _logdb_imp;
  136.     DB_node* new_d = NULL;
  137.     BOOL read_only = FALSE;
  139.     /*
  140.      * check if all but the last sub-strings are already present
  141.      * eg.
  142.      *     if foo.bar.moo is to be added then
  143.      *        the following loop checks is "foo" and "bar"
  144.      *        have already been created
  145.      *     after the while loop one final check is made to check
  146.      *     if "moo" NOT already present to avoid adding a DUPLICATE
  147.      */
  148.     *curr_key_str = '';
  149.     while(!k->last_sub_str())
  150.     {
  151.         k->append_sub_str(curr_key_str, len);
  152. if (p && p->get_type() == PT_COMPOSITE)
  153.     p->get_db_val(&ldb);
  154. if (!ldb)
  155. {
  156.     DPRINTF(D_INFO, ("%s -- %s has NO Properties under it!n",
  157.    prop_name, curr_key_str));
  158.     theErr = HXR_FAILED;
  159.     goto cleanup;
  160. }
  161. d = ldb->find(curr_key_str);
  162. if (!d)
  163. {
  164.     DPRINTF(D_REGISTRY, ("%s -- %s was NOT FOUNDn",
  165.                          prop_name, curr_key_str));
  166.     theErr = HXR_FAILED;
  167.     goto cleanup;
  168. }
  169. p = d->get_data();
  170.         if (!p)
  171. {
  172.     DPRINTF(D_REGISTRY, ("%s -- %s has NO DATAn",
  173.                          prop_name, curr_key_str));
  174.     theErr = HXR_FAILED;
  175.     goto cleanup;
  176. }
  177. read_only = p->is_read_only();
  178. if (read_only)
  179. {
  180.     DPRINTF(D_REGISTRY, ("%s -- %s is READ ONLYn",
  181.                          prop_name, curr_key_str));
  182.     theErr = HXR_FAILED;
  183.     goto cleanup;
  184. }
  185.     }
  186.     if (p && p->get_type() == PT_COMPOSITE)
  187. p->get_db_val(&ldb);
  188.     k->append_sub_str(curr_key_str, len);
  189.     if (ldb->find(curr_key_str))
  190.     {
  191. DPRINTF(D_REGISTRY, ("%s -- is ALREADY PRESENT!n", k->get_key_str()));
  192. theErr = HXR_FAILED;
  193. goto cleanup;
  194.     }
  196.     // everything is alright add the new property
  197.     new_d = _addComp(k, curr_key_str, ldb);
  199.     AddDone(ldb, new_d, d, p);
  201. cleanup:
  203.     HX_VECTOR_DELETE(curr_key_str);
  205.     if (HXR_OK != theErr)
  206.     {
  207. if (k)
  208. {
  209.     delete k;
  210.     k = NULL;
  211. }
  213. return 0;
  214.     }
  215.     else
  216.     {
  217. return new_d->get_id();
  218.     }
  219. }
  221. UINT32
  222. CommonRegistry::_buildSubstructure4Prop(const char* pFailurePoint,
  223. const char* pProp)
  224. {
  225.     /*
  226.      * A lower composite was not there.
  227.      * Add all of the composites up the to prop.
  228.      */
  229.     UINT32 len = strlen(pProp) + 1;
  230.     Key* lame = new Key(pProp);
  231.     char* temp_key_str = new char[len];
  232.     *temp_key_str = 0;
  233.     while (strlen(temp_key_str) < strlen(pFailurePoint))
  234.     {
  235. lame->append_sub_str(temp_key_str, len);
  236.     }
  237.     int ret;
  238.     while ((ret = AddComp(temp_key_str)) != 0)
  239.     {
  240. if (lame->last_sub_str())
  241. {
  242.     break;
  243. }
  244. lame->append_sub_str(temp_key_str, len);
  245.     }
  246.     delete[] temp_key_str;
  247.     delete lame;
  248.     lame = 0;
  249.     return ret;
  250. }
  252. /*
  253.  *  Function Name:   AddInt
  254.  *  Input Params:    const char* prop_name, const INT32 val
  255.  *  Return Value:    UINT32
  256.  *  Description:
  257.  *   function to add a property which has an integer value, to
  258.  *  the log database. this will add all the USER DEFINED properties.
  259.  */
  261. UINT32
  262. CommonRegistry::AddInt(const char* prop_name, const INT32 val)
  263. {
  264.     DPRINTF(D_REGISTRY, ("CommonRegistry::AddInt(%s, %ld)n", prop_name, val));
  265.     HX_RESULT theErr = HXR_OK;
  266.     DB_node* d = 0;
  267.     Property* p = 0;
  268.     Key* k = new Key(prop_name);
  269.     if(!k)
  270.     {
  271.         return 0;
  272.     }
  273.     int len = k->size();
  274.     char* curr_key_str = new char[len];
  275.     if(!curr_key_str)
  276.     {
  277.         HX_DELETE(k);
  278.         return 0;
  279.     }
  280.     DB_implem* ldb = _logdb_imp;
  281.     DB_node* new_d = NULL;
  282.     BOOL read_only = FALSE;
  284.     *curr_key_str = '';
  285.     while(!k->last_sub_str())
  286.     {
  287.         k->append_sub_str(curr_key_str, len);
  288. if (p && p->get_type() == PT_COMPOSITE)
  289.     p->get_db_val(&ldb);
  290. if (!ldb)
  291. {
  292.     DPRINTF(D_REGISTRY, ("%s -- %s has NO Properties under it!n",
  293.                          prop_name, curr_key_str));
  294.     theErr = HXR_FAILED;
  295.     goto cleanup;
  296. }
  297. d = ldb->find(curr_key_str);
  298. if (!d)
  299. {
  300.     int ret = _buildSubstructure4Prop(curr_key_str,
  301. prop_name);
  303.     if (ret)
  304.     {
  305. d = ldb->find(curr_key_str);
  306.     }
  307.     if (!ret || !d)
  308.     {
  309. theErr = HXR_FAILED;
  310. goto cleanup;
  311.     }
  312. }
  313. p = d->get_data();
  314.         if (!p)
  315. {
  316.     DPRINTF(D_REGISTRY, ("%s -- %s has NO DATAn",
  317.                          prop_name, curr_key_str));
  318.     theErr = HXR_FAILED;
  319.     goto cleanup;
  320. }
  321. read_only = p->is_read_only();
  322. if (read_only)
  323. {
  324.     DPRINTF(D_REGISTRY, ("%s -- %s is READ ONLYn",
  325.                          prop_name, curr_key_str));
  326.     theErr = HXR_FAILED;
  327.     goto cleanup;
  328. }
  329.     }
  330.     if (p && p->get_type() == PT_COMPOSITE)
  331. p->get_db_val(&ldb);
  332.     k->append_sub_str(curr_key_str, len);
  333.     if (ldb->find(curr_key_str))
  334.     {
  335. DPRINTF(D_REGISTRY, ("%s -- is ALREADY PRESENT!n", k->get_key_str()));
  336. theErr = HXR_FAILED;
  337. goto cleanup;
  338.     }
  340.     // everything is alright add the new property
  341.     new_d = _addInt(k, curr_key_str, val, ldb);
  343.     AddDone(ldb, new_d, d, p);
  345. cleanup:
  347.     HX_VECTOR_DELETE(curr_key_str);
  349.     if (HXR_OK != theErr)
  350.     {
  351. if (k)
  352. {
  353.     delete k;
  354.     k = NULL;
  355. }
  356. return 0;
  357.     }
  358.     else
  359.     {
  360. return new_d->get_id();
  361.     }
  362. }
  364. /*
  365.  *  Function Name:   GetInt
  366.  *  Input Params:    const char* prop_name, INT32* value
  367.  *  Return Value:    HX_RESULT
  368.  *  Description:
  369.  *   retrieve the INTEGER property if it exists.
  370.  */
  371. HX_RESULT
  372. CommonRegistry::GetInt(const char* prop_name, INT32* value) const
  373. {
  374.     DB_node*  d = 0;
  375.     Property* p = 0;
  377.     if (_find(&d, &p, prop_name) != HXR_OK)
  378. return HXR_FAIL;
  380.     if (p)
  381.     {
  382. switch(p->get_type())
  383. {
  384.     case PT_INTEGER:
  385. return p->get_int_val(value);
  386. break;
  388.     case PT_INTREF:
  389. return p->get_int_ref_val(value);
  390. break;
  392.     default:
  393. DPRINTF(D_REGISTRY, ("%s -- Property<-->Type MISMATCHn",
  394.                      prop_name));
  395. return HXR_PROP_TYPE_MISMATCH;
  396. }
  397.     }
  398.     return HXR_FAIL;
  399. }
  401. /*
  402.  *  Function Name:   GetInt
  403.  *  Input Params:    const UINT32 hash_key, INT32* value
  404.  *  Return Value:    HX_RESULT
  405.  *  Description:
  406.  *   retrieve the INTEGER property using the HashTree.
  407.  */
  408. HX_RESULT
  409. CommonRegistry::GetInt(const UINT32 hash_key, INT32* value) const
  410. {
  411.     DB_node*  d = 0;
  412.     Property* p = 0;
  414.     d = (DB_node *)_ids->get(hash_key);
  415.     if (!d)
  416.     {
  417. DPRINTF(D_REGISTRY, ("GetInt(%lu) failedn", hash_key));
  418. return HXR_FAIL;
  419.     }
  420.     p = d->get_data();
  421.     if (p)
  422.     {
  423. switch(p->get_type())
  424. {
  425.     case PT_INTEGER:
  426. return p->get_int_val(value);
  427. break;
  429.     case PT_INTREF:
  430. return p->get_int_ref_val(value);
  431. break;
  433.     default:
  434. DPRINTF(D_REGISTRY, ("%lu -- Property<-->Type MISMATCHn",
  435.                      hash_key));
  436. return HXR_PROP_TYPE_MISMATCH;
  437. }
  438.     }
  439.     return HXR_FAIL;
  440. }
  442. /*
  443.  *  Function Name:   SetInt
  444.  *  Input Params:    const char* prop_name, const INT32 value
  445.  *  Return Value:    HX_RESULT
  446.  *  Description:
  447.  *   sets the value of an integer property.
  448.  */
  449. HX_RESULT
  450. CommonRegistry::SetInt(const char* prop_name, const INT32 value)
  451. {
  452.     DB_node*  d = 0;
  453.     Property* p = 0;
  455.     if (_find(&d, &p, prop_name) != HXR_OK)
  456. return HXR_FAIL;
  458.     if (!p)
  459.         return HXR_FAIL;
  461.     if (p->is_read_only())
  462.     {
  463.         DPRINTF(D_REGISTRY, ("%s -- Property is READ ONLYn",
  464.                      prop_name));
  465. return HXR_FAIL;
  466.     }
  468.     switch(p->get_type())
  469.     {
  470.         case PT_INTEGER:
  471.             p->int_val(value);
  472.             break;
  474.         case PT_INTREF:
  475.             DPRINTF(D_REGISTRY, ("cannot set INTREF value using SetIntn"));
  476.             return HXR_FAIL;
  478.         default:
  479.             DPRINTF(D_REGISTRY, ("%s -- Property<-->Type MISMATCHn",
  480.                          prop_name));
  481.             return HXR_PROP_TYPE_MISMATCH;
  482.     }
  483.     // dispatch the callbacks and then return HXR_OK
  484.     return SetDone(d, p);
  485. }
  487. /*
  488.  *  Function Name:   SetInt
  489.  *  Input Params:    const UINT32 hash_key, const INT32 value
  490.  *  Return Value:    HX_RESULT
  491.  *  Description:
  492.  *   set a new value of the INTEGER property using the HashTree.
  493.  */
  494. HX_RESULT
  495. CommonRegistry::SetInt(const UINT32 hash_key, const INT32 value)
  496. {
  497.     DPRINTF(D_REGISTRY, ("CommonRegistry::SetInt(%lu, %ld)n", hash_key,
  498.                          value));
  499.     DB_node*  d = 0;
  500.     Property* p = 0;
  502.     d = (DB_node *)_ids->get(hash_key);
  503.     if (!d)
  504.     {
  505. DPRINTF(D_REGISTRY, ("SetInt(%lu) failedn", hash_key));
  506. return HXR_FAIL;
  507.     }
  508.     p = d->get_data();
  509.     if (!p)
  510.         return HXR_FAIL;
  512.     if (p->is_read_only())
  513.     {
  514.         DPRINTF(D_REGISTRY, ("%s(%lu) -- Property is READ ONLYn",
  515.                      p->get_key_str(), hash_key));
  516. return HXR_FAIL;
  517.     }
  519.     switch(p->get_type())
  520.     {
  521.         case PT_INTEGER:
  522.             p->int_val(value);
  523.             break;
  525.         case PT_INTREF:
  526.             DPRINTF(D_REGISTRY, ("cannot set INTREF value using SetIntn"));
  527.             return HXR_FAIL;
  529.         default:
  530.             DPRINTF(D_REGISTRY, ("%s(%lu) -- Property<-->Type MISMATCHn",
  531.                          p->get_key_str(), hash_key));
  532.             return HXR_PROP_TYPE_MISMATCH;
  533.     }
  534.     // dispatch the callbacks and then return HXR_OK
  535.     return SetDone(d, p);
  536. }
  538. /*
  539.  *  Function Name:   CommonRegistry::AddStr
  540.  *  Input Params:    const char* prop_name, const char* const value,
  541.  *  Return Value:    UINT32
  542.  *  Description:
  543.  *   adds a STRING Property ot the registry.
  544.  */
  545. UINT32
  546. CommonRegistry::AddStr(const char* prop_name, IHXBuffer* buf)
  547. {
  548.     DPRINTF(D_REGISTRY, ("CommonRegistry::AddStr(%s, buf(%p)n",
  549.                          prop_name, buf));
  550.     DB_node* d = 0;
  551.     Property* p = 0;
  552.     Key* k = new Key(prop_name);
  553.     if(!k)
  554.     {
  555.         return 0;
  556.     }
  557.     int len = k->size();
  558.     char* curr_key_str = new char[len];
  559.     if(!curr_key_str)
  560.     {
  561.         HX_DELETE(k);
  562.         return 0;
  563.     }
  564.     DB_implem* ldb = _logdb_imp;
  565.     BOOL read_only = FALSE;
  567.     *curr_key_str = '';
  568.     while(!k->last_sub_str())
  569.     {
  570.         k->append_sub_str(curr_key_str, len);
  571. if (p && p->get_type() == PT_COMPOSITE)
  572.     p->get_db_val(&ldb);
  573. if (!ldb)
  574. {
  575.     DPRINTF(D_REGISTRY, ("%s -- %s has NO Properties under it!n",
  576.             prop_name, curr_key_str));
  577.     delete k;
  578.     HX_VECTOR_DELETE(curr_key_str);
  579.     return 0;
  580. }
  581. d = ldb->find(curr_key_str);
  582. if (!d)
  583. {
  584.     int ret = _buildSubstructure4Prop(curr_key_str,
  585. prop_name);
  586.     if (!ret)
  587.     {
  588. delete k;
  589. delete[] curr_key_str;
  590. return 0;
  591.     }
  592.     d = ldb->find(curr_key_str);
  593.     if (!d)
  594.     {
  595. delete k;
  596. delete[] curr_key_str;
  597. return 0;
  598.     }
  599. }
  600. p = d->get_data();
  601.         if (!p)
  602. {
  603.     DPRINTF(D_REGISTRY, ("%s -- %s has NO DATAn",
  604.                          prop_name, curr_key_str));
  605.     delete k;
  606.     HX_VECTOR_DELETE(curr_key_str);
  607.     return 0;
  608. }
  609. read_only = p->is_read_only();
  610. if (read_only)
  611. {
  612.     DPRINTF(D_REGISTRY, ("%s -- %s is READ ONLYn",
  613.                          prop_name, curr_key_str));
  614.     delete k;
  615.     HX_VECTOR_DELETE(curr_key_str);
  616.     return 0;
  617. }
  618.     }
  619.     if (p && p->get_type() == PT_COMPOSITE)
  620. p->get_db_val(&ldb);
  621.     k->append_sub_str(curr_key_str, len);
  622.     if (ldb->find(curr_key_str))
  623.     {
  624. DPRINTF(D_REGISTRY, ("%s -- is ALREADY PRESENT!n", k->get_key_str()));
  625. delete k;
  626. HX_VECTOR_DELETE(curr_key_str);
  627. return 0;
  628.     }
  630.     // everything is alright add the new property
  631.     DB_node* new_d = _addBuf(k, curr_key_str, buf, ldb, PT_STRING);
  633.     HX_VECTOR_DELETE(curr_key_str);
  635.     AddDone(ldb, new_d, d, p);
  636.     return new_d->get_id();
  637. }
  639. /*
  640.  *  Function Name:   GetStr
  641.  *  Input Params:    const char* prop_name, char*& value
  642.  *  Return Value:    HX_RESULT
  643.  *  Description:
  644.  *   retrieves a STRING Property value from the registry given its
  645.  *  property name.
  646.  */
  647. HX_RESULT
  648. CommonRegistry::GetStr(const char* prop_name, REF(IHXBuffer*) p_buf) const
  649. {
  650.     DB_node*  d = 0;
  651.     Property* p = 0;
  653.     if (_find(&d, &p, prop_name) != HXR_OK)
  654. return HXR_FAIL;
  656.     if (p)
  657.     {
  658. switch(p->get_type())
  659. {
  660.     case PT_STRING:
  661. return p->get_buf_val(&p_buf, PT_STRING);
  662. break;
  664.     default:
  665. DPRINTF(D_REGISTRY, ("%s -- Property<-->Type MISMATCHn",
  666.                      prop_name));
  667. return HXR_PROP_TYPE_MISMATCH;
  668. }
  669.     }
  670.     return HXR_FAIL;
  671. }
  673. /*
  674.  *  Function Name:   GetStr
  675.  *  Input Params:    const UINT32 hash_key, char*& value
  676.  *  Return Value:    HX_RESULT
  677.  *  Description:
  678.  *   retrieves a STRING Property value from the registry given its
  679.  *  hash key.
  680.  */
  681. HX_RESULT
  682. CommonRegistry::GetStr(const UINT32 hash_key, REF(IHXBuffer*) p_buf) const
  683. {
  684.     DB_node*  d = 0;
  685.     Property* p = 0;
  687.     d = (DB_node *)_ids->get(hash_key);
  688.     if (!d)
  689.     {
  690. DPRINTF(D_REGISTRY, ("GetStr(%lu) failedn", hash_key));
  691. return HXR_FAIL;
  692.     }
  693.     p = d->get_data();
  695.     if (p)
  696.     {
  697. switch(p->get_type())
  698. {
  699.     case PT_STRING:
  700. return p->get_buf_val(&p_buf, PT_STRING);
  701. break;
  703.     default:
  704. DPRINTF(D_REGISTRY, ("%lu -- Property<-->Type MISMATCHn",
  705.                      hash_key));
  706. return HXR_PROP_TYPE_MISMATCH;
  707. }
  708.     }
  709.     return HXR_FAIL;
  710. }
  712. /*
  713.  *  Function Name:   SetStr
  714.  *  Input Params:    const char* prop_name, const IHXBuffer* value,
  715.  *                      size_t val_len
  716.  *  Return Value:    HX_RESULT
  717.  *  Description:
  718.  *   set the value of a STRING Property given a new value and its
  719.  *  CORRECT length.
  720.  */
  721. HX_RESULT
  722. CommonRegistry::SetStr(const char* prop_name, IHXBuffer* p_buf)
  723. {
  724.     DB_node*  d = 0;
  725.     Property* p = 0;
  727.     if (_find(&d, &p, prop_name) != HXR_OK)
  728. return HXR_FAIL;
  730.     if (!p)
  731.         return HXR_FAIL;
  733.     if (p->is_read_only())
  734.     {
  735.         DPRINTF(D_REGISTRY, ("%s -- Property is READ ONLYn",
  736.                      prop_name));
  737. return HXR_FAIL;
  738.     }
  740.     switch(p->get_type())
  741.     {
  742.         case PT_STRING:
  743.             p->buf_val(p_buf, PT_STRING);
  744.             break;
  746.         default:
  747.             DPRINTF(D_REGISTRY, ("%s -- Property<-->Type MISMATCHn",
  748.                          prop_name));
  749.             return HXR_PROP_TYPE_MISMATCH;
  750.     }
  751.     // dispatch the callbacks and then return HXR_OK
  752.     return SetDone(d, p);
  753. }
  755. /*
  756.  *  Function Name:   SetStr
  757.  *  Input Params:    const UINT32 hash_key, const IHXBuffer* value,
  758.  *                      size_t val_len
  759.  *  Return Value:    HX_RESULT
  760.  *  Description:
  761.  *   set the value of a STRING Property given a new value and its
  762.  *  CORRECT length.
  763.  */
  764. HX_RESULT
  765. CommonRegistry::SetStr(const UINT32 hash_key, IHXBuffer* p_buf)
  766. {
  767.     DB_node*  d = 0;
  768.     Property* p = 0;
  769.     UINT32    h = hash_key;
  771.     d = (DB_node *)_ids->get(hash_key);
  772.     if (!d)
  773.     {
  774. DPRINTF(D_REGISTRY, ("SetStr(%lu) failedn", hash_key));
  775. return HXR_FAIL;
  776.     }
  777.     p = d->get_data();
  779.     if (!p)
  780.         return HXR_FAIL;
  782.     if (p->is_read_only())
  783.     {
  784.         DPRINTF(D_REGISTRY, ("%lu -- Property is READ ONLYn",
  785.                      hash_key));
  786. return HXR_FAIL;
  787.     }
  789.     switch(p->get_type())
  790.     {
  791.         case PT_STRING:
  792.             p->buf_val(p_buf, PT_STRING);
  793.             break;
  795.         default:
  796.             DPRINTF(D_REGISTRY, ("%lu -- Property<-->Type MISMATCHn",
  797.                          hash_key));
  798.             return HXR_PROP_TYPE_MISMATCH;
  799.     }
  800.     // dispatch the callbacks and then return HXR_OK
  801.     return SetDone(d, p);
  802. }
  804. UINT32
  805. CommonRegistry::AddBuf(const char* prop_name, IHXBuffer* buf)
  806. {
  807.     DPRINTF(D_REGISTRY, ("CommonRegistry::AddBuf(%s, buf(%p)n",
  808.                          prop_name, buf));
  809.     DB_node* d = 0;
  810.     Property* p = 0;
  811.     Key* k = new Key(prop_name);
  812.     if(!k)
  813.     {
  814.         return 0;
  815.     }
  816.     int len = k->size();
  817.     char* curr_key_str = new char[len];
  818.     if(!curr_key_str)
  819.     {
  820.         HX_DELETE(k);
  821.         return 0;
  822.     }
  823.     DB_implem* ldb = _logdb_imp;
  824.     BOOL read_only = FALSE;
  826.     *curr_key_str = '';
  827.     while(!k->last_sub_str())
  828.     {
  829.         k->append_sub_str(curr_key_str, len);
  830. if (p && p->get_type() == PT_COMPOSITE)
  831.     p->get_db_val(&ldb);
  832. if (!ldb)
  833. {
  834.     DPRINTF(D_REGISTRY, ("%s -- %s has NO Properties under it!n",
  835.                          prop_name, curr_key_str));
  836.     HX_VECTOR_DELETE(curr_key_str);
  837.     delete k;
  838.     return 0;
  839. }
  840. d = ldb->find(curr_key_str);
  841. if (!d)
  842. {
  843.     int ret = _buildSubstructure4Prop(curr_key_str,
  844. prop_name);
  845.     if (!ret)
  846.     {
  847. delete k;
  848. delete[] curr_key_str;
  849. return 0;
  850.     }
  851.     d = ldb->find(curr_key_str);
  852.     if (!d)
  853.     {
  854. delete k;
  855. delete[] curr_key_str;
  856. return 0;
  857.     }
  858. }
  859. p = d->get_data();
  860.         if (!p)
  861. {
  862.     DPRINTF(D_REGISTRY, ("%s -- %s has NO DATAn",
  863.                          prop_name, curr_key_str));
  864.     HX_VECTOR_DELETE(curr_key_str);
  865.     delete k;
  866.     return 0;
  867. }
  868. read_only = p->is_read_only();
  869. if (read_only)
  870. {
  871.     DPRINTF(D_REGISTRY, ("%s -- %s is READ ONLYn",
  872.                          prop_name, curr_key_str));
  873.     HX_VECTOR_DELETE(curr_key_str);
  874.     delete k;
  875.     return 0;
  876. }
  877.     }
  878.     if (p && p->get_type() == PT_COMPOSITE)
  879. p->get_db_val(&ldb);
  880.     k->append_sub_str(curr_key_str, len);
  881.     if (ldb->find(curr_key_str))
  882.     {
  883. DPRINTF(D_REGISTRY, ("%s -- is ALREADY PRESENT!n", k->get_key_str()));
  884. HX_VECTOR_DELETE(curr_key_str);
  885. delete k;
  886. return 0;
  887.     }
  889.     // everything is alright add the new property
  890.     DB_node* new_d = _addBuf(k, curr_key_str, buf, ldb);
  892.     HX_VECTOR_DELETE(curr_key_str);
  894.     AddDone(ldb, new_d, d, p);
  895.     return new_d->get_id();
  896. }
  898. HX_RESULT
  899. CommonRegistry::GetBuf(const char* prop_name, IHXBuffer** pp_val) const
  900. {
  901.     DB_node*  d = 0;
  902.     Property* p = 0;
  904.     if (_find(&d, &p, prop_name) != HXR_OK)
  905. return HXR_FAIL;
  907.     if (p)
  908.     {
  909. if (p->get_type() == PT_BUFFER)
  910. {
  911.     return p->get_buf_val(pp_val);
  912. }
  913. else if (p->_alternate_string_access_ok)
  914. {
  915.     return p->get_buf_val(pp_val, PT_STRING);
  916. }
  917. else
  918. {
  919.     DPRINTF(D_REGISTRY, ("%s -- Property<-->Type MISMATCHn",
  920.  prop_name));
  921.     return HXR_PROP_TYPE_MISMATCH;
  922. }
  923.     }
  924.     return HXR_FAIL;
  925. }
  927. HX_RESULT
  928. CommonRegistry::GetBuf(const UINT32 hash_key, IHXBuffer** pp_buf) const
  929. {
  930.     DB_node*  d = 0;
  931.     Property* p = 0;
  933.     d = (DB_node *)_ids->get(hash_key);
  934.     if (!d)
  935.     {
  936. DPRINTF(D_REGISTRY, ("GetBuf(%lu) failedn", hash_key));
  937. return HXR_FAIL;
  938.     }
  939.     p = d->get_data();
  941.     if (p)
  942.     {
  943. if (p->get_type() == PT_BUFFER)
  944. {
  945.     return p->get_buf_val(pp_buf);
  946. }
  947. else if (p->_alternate_string_access_ok)
  948. {
  949.     return p->get_buf_val(pp_buf, PT_STRING);
  950. }
  951. else
  952. {
  953.     DPRINTF(D_REGISTRY, ("%lu -- Property<-->Type MISMATCHn",
  954.  hash_key));
  955.     return HXR_PROP_TYPE_MISMATCH;
  956. }
  957.     }
  958.     return HXR_FAIL;
  959. }
  961. HX_RESULT
  962. CommonRegistry::SetBuf(const char* prop_name, IHXBuffer* p_buf)
  963. {
  964.     DB_node*  d = 0;
  965.     Property* p = 0;
  967.     if (_find(&d, &p, prop_name) != HXR_OK)
  968. return HXR_FAIL;
  970.     if (!p)
  971.         return HXR_FAIL;
  973.     if (p->is_read_only())
  974.     {
  975.         DPRINTF(D_REGISTRY, ("%s -- Property is READ ONLYn",
  976.                      prop_name));
  977. return HXR_FAIL;
  978.     }
  980.     if (p->get_type() == PT_BUFFER)
  981.     {
  982. p->buf_val(p_buf);
  983.     }
  984.     else if (p->_alternate_string_access_ok)
  985.     {
  986. p->buf_val(p_buf, PT_STRING);
  987.     }
  988.     else
  989.     {
  990. DPRINTF(D_REGISTRY, ("%s -- Property<-->Type MISMATCHn",
  991.      prop_name));
  992. return HXR_PROP_TYPE_MISMATCH;
  993.     }
  994.     // dispatch the callbacks and then return HXR_OK
  995.     return SetDone(d, p);
  996. }
  998. HX_RESULT
  999. CommonRegistry::SetBuf(const UINT32 hash_key, IHXBuffer* p_buf)
  1000. {
  1001.     DB_node*  d = 0;
  1002.     Property* p = 0;
  1003.     UINT32    h = hash_key;
  1005.     d = (DB_node *)_ids->get(hash_key);
  1006.     if (!d)
  1007.     {
  1008. DPRINTF(D_REGISTRY, ("GetBuf(%lu) failedn", hash_key));
  1009. return HXR_FAIL;
  1010.     }
  1011.     p = d->get_data();
  1013.     if (!p)
  1014.         return HXR_FAIL;
  1016.     if (p->is_read_only())
  1017.     {
  1018.         DPRINTF(D_REGISTRY, ("%lu -- Property is READ ONLYn",
  1019.                      hash_key));
  1020. return HXR_FAIL;
  1021.     }
  1023.     switch(p->get_type())
  1024.     {
  1025.         case PT_BUFFER:
  1026.     p_buf->AddRef();
  1027.             p->buf_val(p_buf);
  1028.     p_buf->Release();
  1029.             break;
  1031.         default:
  1032.             DPRINTF(D_REGISTRY, ("%lu -- Property<-->Type MISMATCHn",
  1033.                          hash_key));
  1034.             return HXR_PROP_TYPE_MISMATCH;
  1035.     }
  1036.     // dispatch the callbacks and then return HXR_OK
  1037.     return SetDone(d, p);
  1038. }
  1040. HX_RESULT
  1041. CommonRegistry::SetReadOnly(const char* pName, BOOL bValue)
  1042. {
  1043.     DB_node*  d = 0;
  1044.     Property* p = 0;
  1046.     if (_find(&d, &p, pName) != HXR_OK)
  1047. return HXR_FAIL;
  1049.     if (!p)
  1050.         return HXR_FAIL;
  1052.     _setReadOnly(p, bValue);
  1054.     return HXR_OK;
  1055. }
  1057. HX_RESULT
  1058. CommonRegistry::SetReadOnly(UINT32 ulRegId, BOOL bValue)
  1059. {
  1060.     DB_node*  d = 0;
  1061.     Property* p = 0;
  1063.     d = (DB_node *)_ids->get(ulRegId);
  1064.     if (!d)
  1065.     {
  1066. DPRINTF(D_REGISTRY, ("SetReadOnly(%lu) failedn", ulRegId));
  1067. return HXR_FAIL;
  1068.     }
  1069.     p = d->get_data();
  1070.     if (!p)
  1071.         return HXR_FAIL;
  1073.     _setReadOnly(p, bValue);
  1075.     return HXR_OK;
  1076. }
  1078. UINT32
  1079. CommonRegistry::AddIntRef(const char* prop_name, INT32* val)
  1080. {
  1081.     DPRINTF(D_REGISTRY, ("CommonRegistry::AddIntRef(%s, %ld)n", prop_name,
  1082.                          *val));
  1083.     DB_node* d = 0;
  1084.     Property* p = 0;
  1085.     Key* k = new Key(prop_name);
  1086.     if(!k)
  1087.     {
  1088.         return 0;
  1089.     }
  1090.     int len = k->size();
  1091.     char* curr_key_str = new char[len];
  1092.     if(!curr_key_str)
  1093.     {
  1094.         HX_DELETE(k);
  1095.         return 0;
  1096.     }
  1097.     DB_implem* ldb = _logdb_imp;
  1098.     BOOL read_only = FALSE;
  1100.     *curr_key_str = '';
  1101.     while(!k->last_sub_str())
  1102.     {
  1103.         k->append_sub_str(curr_key_str, len);
  1104. if (p && p->get_type() == PT_COMPOSITE)
  1105.     p->get_db_val(&ldb);
  1106. if (!ldb)
  1107. {
  1108.     DPRINTF(D_REGISTRY, ("%s -- %s has NO Properties under it!n",
  1109.                          prop_name, curr_key_str));
  1110.     HX_VECTOR_DELETE(curr_key_str);
  1111.     return 0;
  1112. }
  1113. d = ldb->find(curr_key_str);
  1114. if (!d)
  1115. {
  1116.     DPRINTF(D_REGISTRY, ("%s -- %s was NOT FOUNDn",
  1117.                          prop_name, curr_key_str));
  1118.     HX_VECTOR_DELETE(curr_key_str);
  1119.     return 0;
  1120. }
  1121. p = d->get_data();
  1122.         if (!p)
  1123. {
  1124.     DPRINTF(D_REGISTRY, ("%s -- %s has NO DATAn",
  1125.                          prop_name, curr_key_str));
  1126.     HX_VECTOR_DELETE(curr_key_str);
  1127.     return 0;
  1128. }
  1129. read_only = p->is_read_only();
  1130. if (read_only)
  1131. {
  1132.     DPRINTF(D_REGISTRY, ("%s -- %s is READ ONLYn",
  1133.                          prop_name, curr_key_str));
  1134.     HX_VECTOR_DELETE(curr_key_str);
  1135.     return 0;
  1136. }
  1137.     }
  1138.     if (p && p->get_type() == PT_COMPOSITE)
  1139. p->get_db_val(&ldb);
  1140.     k->append_sub_str(curr_key_str, len);
  1141.     if (ldb->find(curr_key_str))
  1142.     {
  1143. DPRINTF(D_REGISTRY, ("%s -- is ALREADY PRESENT!n", k->get_key_str()));
  1144. HX_VECTOR_DELETE(curr_key_str);
  1145. return 0;
  1146.     }
  1148.     // everything is alright add the new property
  1149.     DB_node* new_d = _addIntRef(k, curr_key_str, val, ldb);
  1151.     HX_VECTOR_DELETE(curr_key_str);
  1153.     AddDone(ldb, new_d, d, p);
  1154.     return new_d->get_id();
  1155. }
  1157. /*
  1158.  *  Function Name:   Del
  1159.  *  Input Params:    const char* prop_name
  1160.  *  Return Value:    UINT32
  1161.  *  Description:
  1162.  *   delete a property (DB_node too) from the database given
  1163.  *  the key string.
  1164.  */
  1165. UINT32
  1166. CommonRegistry::Del(const char* prop_name)
  1167. {
  1168.     DB_node* d = 0;
  1169.     Property* p = 0;
  1170.     DB_implem* ldb = 0;
  1172.     if (_find(&d, &p, prop_name) != HXR_OK)
  1173. return 0;
  1175.     if (!p)
  1176.     {
  1177. DPRINTF(D_REGISTRY, ("%s -- has NO DATAn", prop_name));
  1178.         return 0;
  1179.     }
  1181.     // XXXDPS - Currently we do not check if any of the children are read-
  1182.     // only before deleting the key. Thus, a user could delete a read-only
  1183.     // node by deleting its parent, grandparent, etc. This would slow down
  1184.     // the Del() call significantly in the general case because we would
  1185.     // have to do a search first, and abort the entire operation if any child
  1186.     // is read-only. So it is currently safest to write-protect a key that
  1187.     // has no parents (a root key, like "license" or "config").
  1188.     if (p->is_read_only())
  1189.     {
  1190. DPRINTF(D_REGISTRY, ("%s -- is READ ONLYn", prop_name));
  1191.         return 0;
  1192.     }
  1194.     // find the DB that contains this node
  1195.     ldb = d->get_db();
  1197.     if (!ldb)
  1198.     {
  1199. DPRINTF(D_REGISTRY, ("%s -- has NO IMPLEMENTATIONn", prop_name));
  1200.         return 0;
  1201.     }
  1203.     // here the response method doesn't exactly end this method
  1204.     DeleteDone(ldb, d, p);
  1206.     UINT32 h = d->get_id();
  1208.     if (p->m_lWatchCount)
  1209.     {
  1210. /*
  1211.  * Wait for the clear watches to delete the node
  1212.  */
  1214. p->set_deleted(ldb, d, h);
  1216. return h;
  1217.     }
  1219.     return _Del(ldb, d, p, h);
  1220. }
  1222. /*
  1223.  *  Function Name:   Del
  1224.  *  Input Params:    const UINT32 hash_key
  1225.  *  Return Value:    UINT32
  1226.  *  Description:
  1227.  *   delete a property (DB_node too) from the database given
  1228.  *  the key string.
  1229.  */
  1230. UINT32
  1231. CommonRegistry::Del(const UINT32 hash_key)
  1232. {
  1233.     DB_node* d = 0;
  1234.     Property* p = 0;
  1235.     DB_implem* ldb = _logdb_imp;
  1237.     d = (DB_node *)_ids->get(hash_key);
  1239.     if (!d)
  1240.     {
  1241. DPRINTF(D_REGISTRY, ("%lu -- was NOT FOUNDn", hash_key));
  1242. return 0;
  1243.     }
  1245.     p = d->get_data();
  1247.     if (!p)
  1248.     {
  1249. DPRINTF(D_REGISTRY, ("%lu -- has NO DATAn", hash_key));
  1250. return 0;
  1251.     }
  1253.     if (p->is_read_only())
  1254.     {
  1255. DPRINTF(D_REGISTRY, ("%lu -- is READ ONLYn", hash_key));
  1256.         return 0;
  1257.     }
  1259.     // find the DB that contains this node
  1260.     ldb = d->get_db();
  1262.     if (!ldb)
  1263.     {
  1264. DPRINTF(D_REGISTRY, ("%lu -- has NO IMPLEMENTATIONn", hash_key));
  1265.         return 0;
  1266.     }
  1268.     // here the response method doesn't exactly end this method
  1269.     DeleteDone(ldb, d, p);
  1271.     if (p->m_lWatchCount)
  1272.     {
  1273. /*
  1274.  * Wait for the clear watches to delete the node
  1275.  */
  1277. p->set_deleted(ldb, d, hash_key);
  1279. return hash_key;
  1280.     }
  1282.     return _Del(ldb, d, p, hash_key);
  1283. }
  1285. UINT32
  1286. CommonRegistry::_Del(DB_implem* ldb, DB_node* d, Property* p, UINT32 h)
  1287. {
  1288.     if (p->get_type() == PT_COMPOSITE)
  1289.     {
  1290. DB_implem* temp_ldb;
  1291. p->get_db_val(&temp_ldb);
  1292. if (_del(temp_ldb) == HXR_FAIL)
  1293.     return 0;
  1294.     }
  1296.     _ids->destroy(h);
  1297.     ldb->del(d);
  1299.     _count--;
  1300.     return h;
  1301. }
  1303. UINT32
  1304. CommonRegistry::SetWatch(PropWatch* pPropWatch)
  1305. {
  1306.     /*
  1307.      * XXXAAK -- need to do some checking to disallow duplicate watchpoints
  1308.      * per process
  1309.      */
  1310.     WListElem* wle = new WListElem;
  1311.     wle->data = pPropWatch;
  1312.     m_pWatchList->insert(wle);
  1313.     m_lWatchCount++;
  1315.     return 1;
  1316. }
  1318. UINT32
  1319. CommonRegistry::SetWatch(const char* prop_name, PropWatch* pPropWatch)
  1320. {
  1321.     DB_node*  d = 0;
  1322.     Property* p = 0;
  1324.     if (_find(&d, &p, prop_name) == HXR_OK)
  1325.     {
  1326. WListElem* wle = new WListElem;
  1327. wle->data = pPropWatch;
  1328. p->m_pWatchList->insert(wle);
  1329. p->m_lWatchCount++;
  1330. return d->get_id();
  1331.     }
  1332.     return 0;
  1333. }
  1335. UINT32
  1336. CommonRegistry::SetWatch(const UINT32 hash_key, PropWatch* pPropWatch)
  1337. {
  1338.     DB_node*  d = 0;
  1339.     Property* p = 0;
  1341.     d = (DB_node *)_ids->get(hash_key);
  1342.     if (!d)
  1343. return 0;
  1344.     p = (Property *)d->get_data();
  1346.     if (p)
  1347.     {
  1348. WListElem* wle = new WListElem;
  1349. wle->data = pPropWatch;
  1350. p->m_pWatchList->insert(wle);
  1351. p->m_lWatchCount++;
  1352. return hash_key;
  1353.     }
  1354.     return 0;
  1355. }
  1357. /*
  1358.  *  Function Name:   SetTrickleWatch
  1359.  *  Input Params:    const char* par_prop_name, const char* target_name,
  1360.  *                      PropWatch* cb
  1361.  *  Return Value:    UINT32
  1362.  *  Description:
  1363.  *   this method does kinda a watch for a Property that will be added
  1364.  *  in the future. when the "target_name" Property gets added somewhere
  1365.  *  under the hierarchy of the parent Property "par_prop_name" the watch
  1366.  *  will be TRICKLED down the hierarchy until it reaches its target and
  1367.  *  set it for the target. if the target never gets added the callback
  1368.  *  will NOT be triggered.
  1369.  */
  1370. HX_RESULT
  1371. CommonRegistry::SetTrickleWatch(const char* par_prop_name, 
  1372.                                 const char* target_name,
  1373.         PropWatch* cb)
  1374. {
  1375.     // not supported!!!
  1376.     return HXR_NOTIMPL; 
  1377. }
  1379. /*
  1380.  *  Function Name:   CommonRegistry::ClearWatch
  1381.  *  Input Params:    int proc_num
  1382.  *  Return Value:    HX_RESULT
  1383.  *  Description:
  1384.  *   clear a watchpoint from the global watchlist at the highgest 
  1385.  *  level of the database hierarchy.
  1386.  */
  1387. HX_RESULT
  1388. CommonRegistry::ClearWatch(IHXPropWatchResponse* pResonse)
  1389. {
  1390.     return _clearWatch(pResonse);
  1391. }
  1393. HX_RESULT
  1394. CommonRegistry::ClearWatch(const char* prop_name, IHXPropWatchResponse* pResonse)
  1395. {
  1396.     DB_node*  d = 0;
  1397.     Property* p = 0;
  1399.     if (_find(&d, &p, prop_name) != HXR_OK)
  1400. return HXR_FAIL;
  1402.     return _clearWatch(p, pResonse);
  1403. }
  1405. HX_RESULT
  1406. CommonRegistry::ClearWatch(const UINT32 hash_key, IHXPropWatchResponse* pResonse)
  1407. {
  1408.     DB_node*  d = 0;
  1409.     Property* p = 0;
  1411.     d = (DB_node *)_ids->get(hash_key);
  1412.     if (!d)
  1413.     {
  1414. return HXR_FAIL;
  1415.     }
  1416.     p = d->get_data();
  1418.     return _clearWatch(p, pResonse);
  1419. }
  1421. HX_RESULT
  1422. CommonRegistry::AddDone(DB_implem* db_level, DB_node* new_node,
  1423.                 DB_node* parent_node, Property* parent_prop)
  1424. {
  1425.     _dispatchParentCallbacks(db_level, new_node, DBE_ADDED);
  1426.     
  1427.     return HXR_OK;
  1428. }
  1430. HX_RESULT
  1431. CommonRegistry::SetDone(DB_node* new_node, Property* new_prop)
  1432. {
  1433.     _dispatchCallbacks(new_node, new_prop, DBE_MODIFIED);
  1434.     return HXR_OK;
  1435. }
  1437. HX_RESULT
  1438. CommonRegistry::DeleteDone(DB_implem* db_level, DB_node* node,
  1439.    Property* prop)
  1440. {
  1441.     _dispatchCallbacks(node, prop, DBE_DELETED);
  1442.     _dispatchParentCallbacks(db_level, node, DBE_DELETED);
  1443.    
  1444.     return HXR_OK;
  1445. }
  1447. DB_node*
  1448. CommonRegistry::_addComp(Key* k, char* key_str, DB_implem* ldb)
  1449. {
  1450.     DPRINTF(D_REGISTRY, ("CommonRegistry::_addComp()n"));
  1451.     Property* new_p = new Property(k, PT_COMPOSITE);
  1452.     if( !new_p )
  1453.     {
  1454.         return NULL;
  1455.     }
  1457.     DB_node* new_d = ldb->add(key_str, new_p);
  1458.     if( !new_d )
  1459.     {
  1460. delete new_p;
  1461. return NULL;
  1462.     }
  1464.     DB_dict* pNewDb = new DB_dict(new_d);
  1465.     if( !pNewDb )
  1466.     {
  1467. delete new_p;
  1468. delete new_d;
  1469. return NULL;
  1470.     }
  1471.     new_p->db_val(pNewDb);
  1473.     UINT32 id = _ids->create((void *)new_d);
  1474.     new_d->id(id);
  1475.     _count++;
  1477.     return new_d;
  1478. }
  1480. DB_node*
  1481. CommonRegistry::_addInt(Key* k, char* key_str, INT32 val, DB_implem* ldb)
  1482. {
  1483.     DPRINTF(D_REGISTRY, ("CommonRegistry::_addInt()n"));
  1484.     Property* new_p = new Property(k, PT_INTEGER);
  1485.     if(!new_p)
  1486.     {
  1487.         return NULL;
  1488.     }
  1489.     new_p->int_val(val);
  1491.     DB_node* new_d = ldb->add(key_str, new_p);
  1492.     if (!new_d)
  1493.     {
  1494. delete new_p;
  1495. return 0;
  1496.     }
  1498.     UINT32 id = _ids->create((void *)new_d);
  1499.     new_d->id(id);
  1500.     _count++;
  1502.     return new_d;
  1503. }
  1505. DB_node*
  1506. CommonRegistry::_addBuf(Key* k, char* key_str, IHXBuffer* buf, DB_implem* ldb,
  1507.                         HXPropType val_type)
  1508. {
  1509.     DPRINTF(D_REGISTRY, ("CommonRegistry::_addBuf()n"));
  1510.     Property* new_p = new Property(k, val_type);
  1511.     if(!new_p)
  1512.     {
  1513.         return NULL;
  1514.     }
  1515.     // AddRef gets called within the buf_val() method
  1516.     new_p->buf_val(buf, val_type);
  1518.     DB_node* new_d = ldb->add(key_str, new_p);
  1519.     if (!new_d)
  1520.     {
  1521. delete new_p;
  1522. return 0;
  1523.     }
  1525.     UINT32 id = _ids->create((void *)new_d);
  1526.     new_d->id(id);
  1527.     _count++;
  1529.     return new_d;
  1530. }
  1532. DB_node*
  1533. CommonRegistry::_addIntRef(Key* k, char* key_str, INT32* val, DB_implem* ldb)
  1534. {
  1535.     DPRINTF(D_REGISTRY, ("CommonRegistry::_addIntRef()n"));
  1536.     Property* new_p = new Property(k, PT_INTREF);
  1537.     new_p->int_ref_val(val);
  1539.     DB_node* new_d = ldb->add(key_str, new_p);
  1540.     if (!new_d)
  1541.     {
  1542. delete new_p;
  1543. return 0;
  1544.     }
  1546.     UINT32 id = _ids->create((void *)new_d);
  1547.     new_d->id(id);
  1548.     _count++;
  1550.     return new_d;
  1551. }
  1553. /*
  1554.  *  Function Name:   _dispatchParentCallbacks
  1555.  *  Input Params:    DB_implem* db, DB_node* currNode, DB_Event e
  1556.  *  Return Value:    void
  1557.  *  Description:
  1558.  *      fires off the callbacks of the Parent of the
  1559.  *  Property in "currNode". it is used only when a Property gets
  1560.  *  added or deleted.
  1561.  */
  1562. void
  1563. CommonRegistry::_dispatchParentCallbacks(DB_implem* db, DB_node* currNode, 
  1564.                                          DB_Event e)
  1565. {
  1566.     DB_node*     parNode = 0; // parent's node
  1567.     Property*     parProp = 0; // parent's property
  1568.     UINT32      par_hash_key = 0;
  1570.     if (_logdb_imp == db)
  1571.     {
  1572. if (!m_pWatchList || m_pWatchList->empty())
  1573.     return;
  1575. PropWatch*  pPropWatch = NULL;
  1576. UINT32 hash_key = currNode->get_id();
  1578. DPRINTF(D_REGISTRY, ("_dPC -- before root loopn"));
  1579. for (WatchList_iterator wli(m_pWatchList); *wli != 0; ++wli)
  1580. {
  1581.     WListElem* wle = *wli;
  1582.     pPropWatch = (PropWatch *)wle->data;
  1584.     switch (e)
  1585.     {
  1586.     case DBE_ADDED:
  1587. pPropWatch->m_pResponse->AddedProp(hash_key, PT_UNKNOWN, 0);
  1588. break;
  1589.     case DBE_MODIFIED:
  1590. pPropWatch->m_pResponse->ModifiedProp(hash_key, PT_UNKNOWN, 0);
  1591. break;
  1592.     case DBE_DELETED:
  1593. pPropWatch->m_pResponse->DeletedProp(hash_key, 0);
  1594. break;
  1595.     default:
  1596. break;
  1597.     }
  1598. }
  1599.     }
  1600.     else
  1601.     {
  1602. // find the node that owns this DB
  1603. parNode = db->owner_node();
  1604. if (parNode)
  1605. {
  1606.     par_hash_key = parNode->get_id();
  1607.     // get the parent's Property
  1608.     parProp = parNode->get_data();
  1609.     if (!parProp)
  1610.     {
  1611. DPRINTF(D_REGISTRY, ("%s has an INVALID parent Propertyn",
  1612.                      currNode->get_data()->get_key_str()));
  1613. return;
  1614.     }
  1615. }
  1616. else
  1617. {
  1618.     DPRINTF(D_REGISTRY, ("%s has an INVALID parent DB_noden",
  1619.                          currNode->get_data()->get_key_str()));
  1620.     return;
  1621. }
  1623. if (!parProp->m_pWatchList || parProp->m_pWatchList->empty())
  1624.     return;
  1626. UINT32 hash_key = currNode->get_id();
  1627. for (WatchList_iterator wli(parProp->m_pWatchList); *wli != 0; ++wli)
  1628. {
  1629.     WListElem* wle = *wli;
  1630.     PropWatch* pPropWatch = (PropWatch *)wle->data;
  1632.     switch (e)
  1633.     {
  1634.     case DBE_ADDED:
  1635. pPropWatch->m_pResponse->AddedProp(hash_key, PT_UNKNOWN, 
  1636.    par_hash_key);
  1637. break;
  1638.     case DBE_MODIFIED:
  1639. pPropWatch->m_pResponse->ModifiedProp(hash_key, PT_UNKNOWN,
  1640.       par_hash_key);
  1641. break;
  1642.     case DBE_DELETED:
  1643. pPropWatch->m_pResponse->DeletedProp(hash_key, par_hash_key);
  1644. break;
  1645.     default:
  1646. break;
  1647.     }
  1648. }
  1649.     }
  1650. }
  1652. /*
  1653.  *  Function Name:   _dispatchCallbacks
  1654.  *  Input Params:    UINT32 hash_key, Property* p, DB_Event e
  1655.  *  Return Value:    void
  1656.  *  Description:
  1657.  *   it fires off the watch callbacks of the Property "p" whenever
  1658.  *  it gets modified or deleted.
  1659.  */
  1660. void
  1661. CommonRegistry::_dispatchCallbacks(DB_node* d, Property* p, DB_Event e)
  1662. {
  1663.     if (p->m_lWatchCount <= 0)
  1664. return;
  1666.     UINT32 hash_key = d->get_id();
  1667.     UINT32 par_id = 0;
  1669.     // find the DB that contains this node
  1670.     DB_implem* ldb = d->get_db();
  1671.     if (ldb)
  1672.     {
  1673. // find the node that owns the DB
  1674. DB_node* par_node = ldb->owner_node();
  1675. if (par_node)
  1676.     par_id = par_node->get_id();
  1677.     }
  1679.     for (WatchList_iterator wli(p->m_pWatchList); *wli != 0; ++wli)
  1680.     {
  1681. WListElem* wle = *wli;
  1682. PropWatch* pPropWatch = (PropWatch *)wle->data;
  1684. switch (e)
  1685. {
  1686. case DBE_ADDED:
  1687.     pPropWatch->m_pResponse->AddedProp(hash_key, PT_UNKNOWN, par_id);
  1688.     break;
  1689. case DBE_MODIFIED:
  1690.     pPropWatch->m_pResponse->ModifiedProp(hash_key, PT_UNKNOWN, par_id);
  1691.     break;
  1692. case DBE_DELETED:
  1693.     pPropWatch->m_pResponse->DeletedProp(hash_key, par_id);
  1694.     break;
  1695. default:
  1696.     break;
  1697. }
  1698.     }
  1699. }
  1701. /*
  1702.  *  Function Name:   CommonRegistry::_clearWatch
  1703.  *  Input Params:    int proc_num
  1704.  *  Return Value:    HX_RESULT
  1705.  *  Description:
  1706.  *   clear watch at the root level of the registry.
  1707.  */
  1708. HX_RESULT
  1709. CommonRegistry::_clearWatch(IHXPropWatchResponse* pResonse)
  1710. {
  1711.     for (WatchList_iterator wli(m_pWatchList); *wli != 0; ++wli)
  1712.     {
  1713. WListElem* wle = *wli;
  1714. PropWatch* pPropWatch = (PropWatch *)wle->data;
  1716.     // Delete the entry that contains pResonse if one was supplied.
  1717.     // If pResponse is NULL, blindly delete the first entry in the watch list.
  1718.     if ((pPropWatch && pResonse && pPropWatch->m_pResponse == pResonse) ||
  1719.         !pResonse)
  1720.     {
  1721.         m_pWatchList->removeElem(wle);
  1722.     delete wle;
  1723.     delete pPropWatch;
  1724.     m_lWatchCount--;
  1725.     }
  1726.     }
  1727.     
  1728.     return HXR_OK;
  1729. }
  1731. /*
  1732.  *  Function Name:   _clearWatch
  1733.  *  Input Params:    Property* p
  1734.  *  Return Value:    HX_RESULT
  1735.  *  Description:
  1736.  *   clears a watch callback (watchpoint) from a Property based on 
  1737.  *  the process number. if the Property is not specified, then the
  1738.  *  watchpoints at the highgest level are cleared.
  1739.  */
  1740. HX_RESULT
  1741. CommonRegistry::_clearWatch(Property* p, IHXPropWatchResponse* pResonse)
  1742. {
  1743.     if (p)
  1744.     {
  1745. for (WatchList_iterator wli(p->m_pWatchList); *wli != 0; ++wli)
  1746. {
  1747.     WListElem* wle = *wli;
  1748.     PropWatch* pPropWatch = (PropWatch *)wle->data;
  1749.     
  1750.         // Delete the entry that contains pResonse if one was supplied.
  1751.         // If pResponse is NULL, blindly delete the first entry in the watch list.
  1752.         if ((pPropWatch && pResonse && pPropWatch->m_pResponse == pResonse) ||
  1753.             !pResonse)
  1754.         {
  1755.             delete pPropWatch;
  1756.         return DeleteWatch(p, wle);
  1757.         }
  1758. }
  1759.     }
  1760.     return HXR_OK;
  1761. }
  1763. HX_RESULT
  1764. CommonRegistry::DeleteWatch(Property* p, WListElem* wle)
  1765. {
  1766.     p->m_pWatchList->removeElem(wle);
  1767.     delete wle;
  1768.     p->m_lWatchCount--;
  1770.     if (p->is_deleted() && !p->m_lWatchCount)
  1771.     {
  1772. _Del(p->_owner_db, p->_owner_node, p, p->_id);
  1773.     }
  1775.     return HXR_OK;
  1776. }
  1778. /*
  1779.  *  Function Name:   GetType
  1780.  *  Input Params:    const char* prop_name
  1781.  *  Return Value:    HXPropType
  1782.  *  Description:
  1783.  *      returns the Datatype of the Property.
  1784.  */
  1785. HXPropType
  1786. CommonRegistry::GetType(const char* prop_name) const
  1787. {
  1788.     DB_node*  d = 0;
  1789.     Property* p = 0;
  1791.     if (_find(&d, &p, prop_name) == HXR_OK)
  1792. if (p)
  1793.     return p->get_type();
  1795.     return PT_UNKNOWN;
  1796. }
  1798. /*
  1799.  *  Function Name:   GetType
  1800.  *  Input Params:    const UINT32 hash_key
  1801.  *  Return Value:    HXPropType
  1802.  *  Description:
  1803.  *      returns the Datatype of the Property.
  1804.  */
  1805. HXPropType
  1806. CommonRegistry::GetType(const UINT32 hash_key) const
  1807. {
  1808.     DB_node*  d = 0;
  1809.     Property* p = 0;
  1810.     UINT32    h = hash_key;
  1811.     d = (DB_node *)_ids->get(hash_key);
  1812.     if (!d)
  1813.     {
  1814. DPRINTF(D_REGISTRY, ("Get Type (%lu) failedn", hash_key));
  1815. return PT_UNKNOWN;
  1816.     }
  1817.     p = d->get_data();
  1819.     if (p)
  1820. return p->get_type();
  1822.     return PT_UNKNOWN;
  1823. }
  1825. /*
  1826.  *  Function Name:   CommonRegistry::GetPropList const
  1827.  *  Input Params: IHXValues*& pValues
  1828.  *  Return Value:    HX_RESULT
  1829.  *  Description:
  1830.  *   it returns back a list of triples one for each property under 
  1831.  *  highest level of the database. each of these properties consists of 
  1832.  *  name, type and the hash key
  1833.  *
  1834.  *  XXXAAK -- return a list of hash keys if the list element is PT_COMPOSITE.
  1835.  */
  1836. HX_RESULT
  1837. CommonRegistry::GetPropList(IHXValues*& pValues) const
  1838. {
  1839.     return _getPropList(_logdb_imp, pValues);
  1840. }
  1842. /*
  1843.  *  Function Name:   CommonRegistry::GetPropList const
  1844.  *  Input Params:    const char* prop_name, IHXValues*& pValues
  1845.  *  Return Value:    HX_RESULT
  1846.  *  Description:
  1847.  *   given a PT_COMPOSITE property, it returns back a list of triples
  1848.  *  one for each property under the PT_COMPOSITE. each of which consists 
  1849.  *  of property name, type and the hash key
  1850.  *
  1851.  *  XXXAAK -- return a list of hash keys if the list element is PT_COMPOSITE.
  1852.  */
  1853. HX_RESULT
  1854. CommonRegistry::GetPropList(const char* prop_name, IHXValues*& pValues) const
  1855. {
  1856.     DB_node*  d = 0;
  1857.     Property* p = 0;
  1859.     if (_find(&d, &p, prop_name) == HXR_OK)
  1860.     {
  1861. if (p)
  1862. {
  1863.     switch(p->get_type())
  1864.     {
  1865. case PT_COMPOSITE:
  1866. {
  1867.     DB_implem* ldb = 0;
  1869.     p->get_db_val(&ldb);
  1870.     return _getPropList(ldb, pValues);
  1871. }
  1872. default:
  1873.     DPRINTF(D_REGISTRY, ("%s -- is NOT a COMPOSITE propertyn", 
  1874.                          prop_name));
  1875.     break;
  1876.     }
  1877. }
  1878.     }
  1879.     return HXR_FAIL;
  1880. }
  1882. HX_RESULT
  1883. CommonRegistry::Copy(const char* pFrom, const char* pTo)
  1884. {
  1885.     HXPropType type;
  1886.     type = GetType(pFrom);
  1887.     char buf[256]; /* Flawfinder: ignore */
  1888.     INT32 Int;
  1889.     UINT32 ul;
  1890.     IHXBuffer* pBuffer = 0;
  1891.     HX_RESULT res;
  1892.     IHXValues* pValues = 0;
  1893.     const char* pName;
  1895.     switch (type)
  1896.     {
  1897.     case PT_COMPOSITE:
  1898. /*
  1899.  * Get all props and recurse copy all of them.
  1900.  */
  1901. if (HXR_OK != (res = GetPropList(pFrom, pValues)))
  1902. {
  1903.     break;
  1904. }
  1905. if (HXR_OK == pValues->GetFirstPropertyULONG32(pName, ul))
  1906. {
  1907.     SafeStrCpy(buf, pTo, 256);
  1908.     SafeStrCat(buf, pName + strlen(pFrom), 256);
  1909.     res = Copy(pName, buf);
  1910.     while (HXR_OK == pValues->GetNextPropertyULONG32(pName, ul))
  1911.     {
  1912. SafeStrCpy(buf, pTo, 256);
  1913. SafeStrCat(buf, pName + strlen(pFrom), 256);
  1914. res = Copy(pName, buf);
  1915.     }
  1916. }
  1917. HX_RELEASE(pValues);
  1918. break;
  1920.     case PT_INTEGER:
  1921. if (HXR_OK != (res = GetInt(pFrom, &Int)))
  1922. {
  1923.     break;
  1924. }
  1925. if (AddInt(pTo, Int))
  1926. {
  1927.     res = HXR_OK;
  1928. }
  1929. else
  1930. {
  1931.     res = HXR_FAIL;
  1932. }
  1933. break;
  1935.     case PT_STRING:
  1936. if (HXR_OK != (res = GetStr(pFrom, pBuffer)))
  1937. {
  1938.     break;
  1939. }
  1940. if (AddStr(pTo, pBuffer))
  1941. {
  1942.     res = HXR_OK;
  1943. }
  1944. else
  1945. {
  1946.     res = HXR_FAIL;
  1947. }
  1948. if (pBuffer)
  1949. {
  1950.     pBuffer->Release();
  1951. }
  1952. pBuffer = 0;
  1953. break;
  1955.     case PT_BUFFER:
  1956. if (HXR_OK != (res = GetBuf(pFrom, &pBuffer)))
  1957. {
  1958.     break;
  1959. }
  1960. if (AddBuf(pTo, pBuffer))
  1961. {
  1962.     res = HXR_OK;
  1963. }
  1964. else
  1965. {
  1966.     res = HXR_FAIL;
  1967. }
  1968. if (pBuffer)
  1969. {
  1970.     pBuffer->Release();
  1971. }
  1972. pBuffer = 0;
  1973. break;
  1974.     
  1975.     default:
  1976. res = HXR_FAIL;
  1977.     }
  1979.     return res;
  1980. }
  1982. HX_RESULT
  1983. CommonRegistry::SetStringAccessAsBufferById(UINT32 hash_key)
  1984. {
  1985.     DB_node*  d = 0;
  1986.     Property* p = 0;
  1988.     d = (DB_node *)_ids->get(hash_key);
  1989.     if (!d)
  1990.     {
  1991. DPRINTF(D_REGISTRY, ("SetStringAccessAsBufferById(%lu) failedn",
  1992.     hash_key));
  1993. return HXR_FAIL;
  1994.     }
  1995.     p = d->get_data();
  1997.     if (p)
  1998.     {
  1999. switch(p->get_type())
  2000. {
  2001.     case PT_STRING:
  2002. p->SetStringAccessAsBufferById();
  2003. return HXR_OK;
  2005.     default:
  2006. DPRINTF(D_REGISTRY, ("%lu -- Property<-->Type MISMATCHn",
  2007.                      hash_key));
  2008. return HXR_PROP_TYPE_MISMATCH;
  2009. }
  2010.     }
  2011.     return HXR_FAIL;
  2012. }
  2014. /*
  2015.  *  Function Name:   CommonRegistry::GetPropList const
  2016.  *  Input Params:    const UINT32 hash_key, IHXValues*& pValues
  2017.  *  Return Value:    HX_RESULT
  2018.  *  Description:
  2019.  *   given a PT_COMPOSITE property, it returns back a list of triples
  2020.  *  one for each property under the PT_COMPOSITE. each of which consists 
  2021.  *  of property name, type and the hash key
  2022.  *
  2023.  *  XXXAAK -- return a list of hash keys if the list element is PT_COMPOSITE.
  2024.  */
  2025. HX_RESULT
  2026. CommonRegistry::GetPropList(const UINT32 hash_key, IHXValues*& pValues) const
  2027. {
  2028.     if (!hash_key)
  2029. return _getPropList(_logdb_imp, pValues);
  2031.     DB_node*  d = 0;
  2032.     Property* p = 0;
  2034.     d = (DB_node *)_ids->get(hash_key);
  2035.     if (!d)
  2036.     {
  2037. DPRINTF(D_REGISTRY, ("could not get PropList for %lu -- no datan",
  2038.                      hash_key));
  2039. return HXR_FAIL;
  2040.     }
  2041.     p = d->get_data();
  2043.     if (p)
  2044.     {
  2045. switch(p->get_type())
  2046. {
  2047.     case PT_COMPOSITE:
  2048.     {
  2049. DB_implem* ldb = 0;
  2051. p->get_db_val(&ldb);
  2052. return _getPropList(ldb, pValues);
  2053.     }
  2054.     default:
  2055. DPRINTF(D_REGISTRY, ("%s(%lu) -- is NOT a COMPOSITE propertyn",
  2056.                      p->get_key_str(), hash_key));
  2057. break;
  2058. }
  2059.     }
  2060.     return HXR_FAIL;
  2061. }
  2063. /*
  2064.  *  Function Name:   CommonRegistry::GetPropName const
  2065.  *  Input Params:    const UINT32 id, IHXBuffer*& prop_name
  2066.  *  Return Value:    HX_RESULT
  2067.  *  Description:
  2068.  *   return a pointer to the key string of the Property whose
  2069.  *  id is given.
  2070.  */
  2071. HX_RESULT
  2072. CommonRegistry::GetPropName(const UINT32 id, IHXBuffer*& prop_name) const
  2073. {
  2074.     DB_node* d = (DB_node *)_ids->get(id);
  2075.     if (d)
  2076.     {
  2077. Property* p = d->get_data();
  2078. if (p)
  2079. {
  2080.     prop_name = new CHXBuffer;
  2081.     prop_name->Set((const unsigned char *)p->get_key_str(), 
  2082.    p->get_key_str_len());
  2083.     prop_name->AddRef();
  2084.     return HXR_OK;
  2085. }
  2086.     }
  2087.     return HXR_FAIL;
  2088. }
  2090. /*
  2091.  *  Function Name:   GetId
  2092.  *  Input Params:    const char* prop_name
  2093.  *  Return Value:    UINT32
  2094.  *  Description:
  2095.  *   returns the ID value for the Property name (prop_name) passed
  2096.  *  as a parameter. the main CONDITION is that the Property MUST EXIST,
  2097.  *  otherwise it returns a ZERO (0).
  2098.  */
  2099. UINT32
  2100. CommonRegistry::GetId(const char* prop_name) const
  2101. {
  2102.     DPRINTF(D_REGISTRY&D_ENTRY, ("CommonRegistry::GetId(%s)n", prop_name));
  2103.     DB_node* d = 0;
  2104.     Property* p = 0;
  2106.     if (_find(&d, &p, prop_name) == HXR_OK)
  2107. if (d)
  2108.         return d->get_id();
  2109.     return 0;
  2110. }
  2112. UINT32
  2113. CommonRegistry::FindParentKey(const char* prop_name)
  2114. {
  2115.     DB_node* d = 0;
  2116.     Property* p = 0;
  2118.     if (_find(&d, &p, prop_name) == HXR_OK)
  2119.     {
  2120. if (d)
  2121. {
  2122.     // find the DB that contains this node
  2123.     DB_implem* ldb = d->get_db();
  2124.     if (ldb)
  2125.     {
  2126. // find the node that owns this DB
  2127. d = ldb->owner_node();
  2128. if (d)
  2129.     return d->get_id();
  2130.     }
  2131. }
  2132.     }
  2133.     return 0;
  2134. }
  2136. UINT32
  2137. CommonRegistry::FindParentKey(const UINT32 hash_key)
  2138. {
  2139.     DB_node* d = (DB_node *)_ids->get(hash_key);
  2141.     // find the node with the hash key
  2142.     if (d)
  2143.     {
  2144. // find the DB that contains this node
  2145. DB_implem* ldb = d->get_db();
  2146. if (ldb)
  2147. {
  2148.     // find the node that owns this DB
  2149.     d = ldb->owner_node();
  2150.     if (d)
  2151. return d->get_id();
  2152. }
  2153.     }
  2154.     return 0;
  2155. }
  2157. /*
  2158.  *  Function Name:   CommonRegistry::Count const
  2159.  *  Input Params:   
  2160.  *  Return Value:    INT32
  2161.  *  Description:
  2162.  *   returns the total number of Properties (including COMPOSITE types)
  2163.  *  in the registry.
  2164.  */
  2165. INT32
  2166. CommonRegistry::Count() const
  2167. {
  2168.     return _count;
  2169. }
  2171. /*
  2172.  *  Function Name:   CommonRegistry::Count
  2173.  *  Input Params:    const char* prop_name
  2174.  *  Return Value:    UINT32
  2175.  *  Description:
  2176.  *   returns the number of Properties below the COMPOSITE whose
  2177.  *  name has been specified. if the Property is not a COMPOSITE then
  2178.  *  ZERO is returned.
  2179.  */
  2180. INT32
  2181. CommonRegistry::Count(const char* prop_name) const
  2182. {
  2183.     DB_node* d = 0;
  2184.     Property* p = 0;
  2185.     DB_implem* ldb = 0;
  2186.     UINT32 h = 0;
  2188.     if (_find(&d, &p, prop_name) != HXR_OK)
  2189. return 0;
  2191.     if (p)
  2192.     {
  2193. if (p->get_type() == PT_COMPOSITE)
  2194. {
  2195.     p->get_db_val(&ldb);
  2196.     if (ldb)
  2197. return ldb->count();
  2198. }
  2199.     }
  2200.     return 0;
  2201. }
  2203. /*
  2204.  *  Function Name:   CommonRegistry::Count
  2205.  *  Input Params:    const UINT32 hash_key
  2206.  *  Return Value:    UINT32
  2207.  *  Description:
  2208.  *   returns the number of Properties below the COMPOSITE whose
  2209.  *  hash key has been specified. if the Property is not a COMPOSITE
  2210.  *  then ZERO is returned.
  2211.  */
  2212. INT32
  2213. CommonRegistry::Count(const UINT32 hash_key) const
  2214. {
  2215.     DB_node* d = 0;
  2216.     Property* p = 0;
  2217.     DB_implem* ldb = 0;
  2219.     d = (DB_node *)_ids->get(hash_key);
  2220.     if (!d)
  2221.     {
  2222. DPRINTF(D_REGISTRY, ("%lu -- does not existn", hash_key));
  2223. return HXR_FAIL;
  2224.     }
  2226.     p = d->get_data();
  2227.     if (p)
  2228.     {
  2229. if (p->get_type() == PT_COMPOSITE)
  2230. {
  2231.     p->get_db_val(&ldb);
  2232.     if (ldb)
  2233. return ldb->count();
  2234. }
  2235.     }
  2236.     return 0;
  2237. }
  2239. /*
  2240.  *  Function Name:   CommonRegistry::_del
  2241.  *  Input Params:    DB_implem* db
  2242.  *  Return Value:    HX_RESULT
  2243.  *  Description:
  2244.  *   recursive delete down the database, which simultaneously
  2245.  *  deletes nodes from the hash tree. this method gets called from
  2246.  *  Del() when the user wants to delete a COMPOSITE Property. the
  2247.  *  default action is to delete all Properties under that COMPOSITE.
  2248.  */
  2249. HX_RESULT
  2250. CommonRegistry::_del(DB_implem* db)
  2251. {
  2252.     DPRINTF(D_REGISTRY, ("_del(db(%p)n", db));
  2253.     DB_node* d = db->first();
  2255.     while (d)
  2256.     {
  2257. Property* pnode = d->get_data();
  2258. DPRINTF(D_REGISTRY, ("_del(db(%p)) -- %s(%lu)n", db, 
  2259. pnode->get_key_str(), d->get_id()));
  2260. if (pnode)
  2261. {
  2262.     if (pnode->get_type() == PT_COMPOSITE)
  2263.     {
  2264. DB_implem* ldb;
  2265. pnode->get_db_val(&ldb);
  2266. if (!ldb)
  2267. {
  2268.     DPRINTF(D_REGISTRY, ("invalid Property(%lu) not deletedn",
  2269.                          d->get_id()));
  2270.     return HXR_FAIL;
  2271. }
  2272. _del(ldb);
  2273.     }
  2274.     // fire off the callbacks if someone is watching this prop
  2275.     DeleteDone(db, d, pnode);
  2277.     _ids->destroy(d->get_id());
  2278.     db->del(d);
  2279.     _count--;
  2280. }
  2281. else
  2282. {
  2283.     DPRINTF(D_REGISTRY, ("data corrputed for Property(%lu)n",
  2284.                          d->get_id()));
  2285.     return HXR_FAIL;
  2286. }
  2287. d = db->first();
  2288.     }
  2289.     return HXR_OK;
  2290. }
  2292. /*
  2293.  *  Function Name:   CommonRegistry::_getPropList const
  2294.  *  Input Params:    DB_implem* ldb, IHXValues*& pValues
  2295.  *  Return Value:    HX_RESULT
  2296.  *  Description:
  2297.  *   return back a list of triples (name, type, hash) consisting of
  2298.  *  all the properties in the database level specified by "ldb". this
  2299.  *  method is generally called from GetPropList() when a user requests 
  2300.  *  for a list of Properties under some COMPOSITE Property.
  2301.  */
  2302. HX_RESULT
  2303. CommonRegistry::_getPropList(DB_implem* ldb, IHXValues*& pValues) const
  2304. {
  2305.     DPRINTF(D_REGISTRY, ("_getPropList(ldb(%p))n", ldb));
  2306.     DB_node*  node = 0;
  2308.     pValues = new CHXHeader;
  2309.     pValues->AddRef();
  2311.     node = ldb->first();
  2312.     while (node)
  2313.     {
  2314. Property* p = node->get_data();
  2316. if (!p)
  2317. {
  2318.     DPRINTF(D_REGISTRY, ("%ld is an empty Registry node, skipping itn",
  2319.                          node->get_id()));
  2320. }
  2321. pValues->SetPropertyULONG32(p->get_key_str(), node->get_id());
  2323. DB_node* n = ldb->next(node);
  2324. node = n;
  2325.     }
  2326.     return HXR_OK;
  2327. }
  2329. /*
  2330.  *  Copyright (c) 1996, 1997, 1998 RealNetworks
  2331.  *
  2332.  *  Function Name:   CommonRegistry::_setReadOnly
  2333.  *  Input Params:    Property* pProp, BOOL bValue
  2334.  *  Return Value:    HX_RESULT
  2335.  *  Description:
  2336.  *   set the read_only flag of this node, and all nodes beneath
  2337.  * this node (if this node is a composite) to bValue.
  2338.  */
  2339. HX_RESULT
  2340. CommonRegistry::_setReadOnly(Property* pProp, BOOL bValue)
  2341. {
  2342.     DB_implem* ldb  = 0;
  2343.     DB_node*   node = 0;
  2345.     // Set read_only flag on pProp
  2346.     pProp->set_read_only(bValue);
  2348.     if (pProp->get_type() == PT_COMPOSITE)
  2349.     {
  2350. // Get ldb of pProp
  2351. pProp->get_db_val(&ldb);
  2352. if (ldb)
  2353. {
  2354.     // Set read_only flag on each child
  2355.     node = ldb->first();
  2356.     while (node)
  2357.     {
  2358. Property* p = node->get_data();
  2360. if (!p)
  2361. {
  2362.     DPRINTF(D_REGISTRY, ("%ld is an empty Registry node, "
  2363. "skipping itn", node->get_id()));
  2364. }
  2365. // Recurse...
  2366. _setReadOnly(p, bValue);
  2368. DB_node* n = ldb->next(node);
  2369. node = n;
  2370.     }
  2371. }
  2372.     }
  2374.     return HXR_OK;
  2375. }
  2377. /*
  2378.  *  Function Name:   _find
  2379.  *  Input Params:    DB_node** d, Property** p, 
  2380.  *                      UINT32& hash_key, const char* prop_name
  2381.  *  Return Value:    HX_RESULT
  2382.  *  Description:
  2383.  *   find a DB_node and its corresponding Property based on the name
  2384.  *  or the hash key, whichever is given.
  2385.  */
  2386. HX_RESULT
  2387. CommonRegistry::_find(DB_node** d, Property** p, const char* prop_name) const
  2388. {
  2389.     DPRINTF(D_REGISTRY, ("CommonRegistry::_find(prop_name(%s))n", prop_name));
  2391.     Key* k = new Key(prop_name);
  2392.     if(!k  ||  HXR_OK != k->m_LastError)
  2393.     {
  2394.         return 0;
  2395.     }
  2396.     int len = k->size();
  2397.     char* curr_key_str = new char[len];
  2398.     if(NULL==curr_key_str)
  2399.     {
  2400.         HX_DELETE(k);
  2401.         return 0;
  2402.     }
  2403.     DB_implem* ldb = _logdb_imp;
  2404.     HX_RESULT ret = HXR_OK;
  2406.     // find the node that contains the "prop_name"
  2407.     *curr_key_str = '';
  2408.     while(k->append_sub_str(curr_key_str, len))
  2409.     {
  2410. if (!ldb)
  2411. {
  2412.     DPRINTF(D_REGISTRY, ("%s -- %s has NO Properties under it!n",
  2413.                          prop_name, curr_key_str));
  2414.     ret = HXR_FAIL;
  2415.     goto cleanup;
  2416. }
  2417. *d = ldb->find(curr_key_str);
  2418. if (!(*d))
  2419. {
  2420.     DPRINTF(D_REGISTRY, ("%s -- %s was NOT FOUNDn",
  2421.                          prop_name, curr_key_str));
  2422.     ret = HXR_PROP_NOT_FOUND;
  2423.     goto cleanup;
  2424. }
  2426. *p = (*d)->get_data();
  2427.         if (!(*p))
  2428. {
  2429.     DPRINTF(D_REGISTRY, ("%s -- %s has NO DATAn",
  2430.                          prop_name, curr_key_str));
  2431.             ret = HXR_FAIL;
  2432.     goto cleanup;
  2433. }
  2434. if ((*p)->get_type() == PT_COMPOSITE)
  2435.     (*p)->get_db_val(&ldb);
  2436.     }
  2438.     if (*d && *p)
  2439. ret = HXR_OK;
  2440.     else
  2441. ret = HXR_FAIL;
  2443. cleanup:
  2444.     HX_VECTOR_DELETE(curr_key_str);
  2445.     delete k;
  2447.     return ret;
  2448. }