property.h
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:11k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: property.h,v 1.4.32.3 2004/07/09 01:48:00 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 ***** */
  49. #ifndef _PROPERTY_H
  50. #define _PROPERTY_H
  51. #include <string.h>
  52. #include "hxtypes.h"
  53. #include "hxcom.h"
  54. #include "ihxpckts.h"
  55. #include "hxbuffer.h"
  56. #include "hxmon.h"
  57. #include "key.h"
  58. #include "db_misc.h"
  59. #include "db_dict_abs.h"
  60. #include "watchlst.h"
  61. struct IHXPropWatchResponse;
  62. class PropWatch
  63. {
  64. public:
  65.     PropWatch() : m_pResponse(0){}
  66.     ~PropWatch() {}
  67.     IHXPropWatchResponse* m_pResponse;
  68. };
  69. class Property
  70. {
  71. private: 
  72.     Key*   _prop_name;
  73.     HXPropType  _prop_type;
  74.     // (in bytes) mainly for strings/binary blobs
  75.     INT32 _prop_size;
  76.     BOOL     _deleted;
  77.     BOOL _read_only;
  78.     union VALUE
  79.     {
  80. IHXBuffer* t_buf;
  81. INT32 t_int;
  82. INT32* t_iref;
  83. DB_implem* t_imp;
  84.     } _prop_val;
  85. public:
  86.     WatchList* m_pWatchList;
  87.     LONG32 m_lWatchCount;
  88.     Property();
  89.     Property(Key* n, HXPropType t);
  90.     Property(char* n, HXPropType t);
  91.     virtual ~Property();
  92.     // mutator methods
  93.     virtual HX_RESULT key_str(char* s);
  94.     virtual HX_RESULT type(const HXPropType t);
  95.     virtual HX_RESULT buf_val(IHXBuffer* v, HXPropType t = PT_BUFFER);
  96.     virtual HX_RESULT int_val(const INT32 v);
  97.     virtual HX_RESULT int_ref_val(INT32* v);
  98.     virtual HX_RESULT db_val(DB_implem* v);
  99.     // accessor methods
  100.     virtual const Key* get_key_obj() const;
  101.     virtual const char* get_key_str() const;
  102.     virtual int         get_key_str_len() const;
  103.     virtual void        get_type(HXPropType* t) const;
  104.     virtual HXPropType get_type() const;
  105.     virtual HX_RESULT        get_buf_val(IHXBuffer** v, 
  106.     HXPropType t = PT_BUFFER) const;
  107.     virtual const IHXBuffer* get_buf_val(HXPropType t = PT_BUFFER) const;
  108.     virtual HX_RESULT        get_int_val(INT32* v) const;
  109.     virtual INT32       get_int_val() const;
  110.     virtual HX_RESULT        get_int_ref_val(INT32* v) const;
  111.     virtual INT32     get_int_ref_val() const;
  112.     virtual HX_RESULT     get_db_val(DB_implem** v) const;
  113.     virtual const DB_implem*  get_db_val() const;
  114.     virtual void set_deleted(DB_implem* ldb, DB_node* d,
  115.             UINT32 h);
  116.     virtual BOOL is_deleted();
  117.     virtual void set_read_only(BOOL read_only);
  118.     virtual BOOL is_read_only();
  119.     virtual void SetStringAccessAsBufferById();
  120.     /*
  121.      * Make these public so that CommonRegistry can use them
  122.      */
  123.     DB_implem* _owner_db;
  124.     DB_node* _owner_node;
  125.     UINT32 _id;
  126.     BOOL     _alternate_string_access_ok;
  127.     HX_RESULT m_LastError;
  128. };
  129. inline
  130. Property::Property()
  131.          : _prop_name(0), _prop_type(PT_UNKNOWN), _prop_size(0),
  132.    _deleted(FALSE), _read_only(FALSE), _owner_db(0), 
  133.    _owner_node(0), _id(0), _alternate_string_access_ok(0), m_LastError(HXR_OK)
  134. {
  135.     _prop_val.t_int = 0x0000;
  136.     _prop_val.t_buf = 0;
  137.     m_pWatchList = new WatchList;
  138.     if(!m_pWatchList)
  139.     {
  140.         m_LastError = HXR_OUTOFMEMORY;
  141.     }
  142.     m_lWatchCount = 0;
  143. }
  144. inline
  145. Property::Property(Key* k, HXPropType t) 
  146.          : _prop_name(k), _prop_type(t), _prop_size(0), 
  147.    _deleted(FALSE), _read_only(FALSE), _owner_db(0), 
  148.    _owner_node(0), _id(0), m_LastError(HXR_OK)
  149. {
  150.     // XXX by default set the integer value to ZERO.
  151.     _prop_val.t_int = 0x0000;
  152.     _prop_val.t_buf = 0;
  153.     m_pWatchList = new WatchList;
  154.     if(!m_pWatchList)
  155.     {
  156.         m_LastError = HXR_OUTOFMEMORY;
  157.     }
  158.     m_lWatchCount = 0;
  159. }
  160. inline
  161. Property::Property(char* n, HXPropType t)
  162.          : _prop_name(new Key(n)), _prop_type(t), _prop_size(0),
  163.    _deleted(FALSE), _read_only(FALSE), _owner_db(0), 
  164.    _owner_node(0), _id(0), m_LastError(HXR_OK)
  165. {
  166.     // XXX by default set the integer value to ZERO.
  167.     _prop_val.t_int = 0x0000;
  168.     _prop_val.t_buf = 0;
  169.     m_pWatchList = new WatchList;
  170.     if(!m_pWatchList)
  171.     {
  172.         m_LastError = HXR_OUTOFMEMORY;
  173.     }
  174.     m_lWatchCount = 0;
  175. }
  176. inline
  177. Property::~Property()
  178. {
  179.     for (WatchList_iterator wli(m_pWatchList); *wli != 0; ++wli)
  180.     {
  181. WListElem* wle = *wli;
  182. PropWatch* pw = (PropWatch *)wle->data;
  183. delete pw;
  184. m_pWatchList->removeElem(wle);
  185. delete wle;
  186. m_lWatchCount--;
  187.     }
  188.     delete m_pWatchList;
  189.     delete _prop_name;
  190.     switch (_prop_type)
  191.     {
  192. case PT_COMPOSITE:
  193.     delete _prop_val.t_imp;
  194.     break;
  195. case PT_STRING:
  196.     if (_prop_val.t_buf)
  197. _prop_val.t_buf->Release();
  198.     break;
  199. case PT_BUFFER:
  200.     if (_prop_val.t_buf)
  201. _prop_val.t_buf->Release();
  202.     break;
  203. default:
  204.     break;
  205.     }
  206. }
  207. inline HX_RESULT
  208. Property::type(const HXPropType t)
  209. {
  210.     _prop_type = t;
  211.     return HXR_OK;
  212. }
  213. inline HX_RESULT
  214. Property::int_val(const INT32 v)
  215. {
  216.     if (_read_only)
  217.     {
  218. return HXR_FAIL;
  219.     }
  220.     else if (_prop_type != PT_INTEGER)
  221.     {
  222. _prop_val.t_int = 0;
  223. return HXR_FAIL;
  224.     }
  225.     else
  226.     {
  227. _prop_val.t_int = v;
  228. return HXR_OK;
  229.     }
  230. }
  231. inline HX_RESULT
  232. Property::int_ref_val(INT32* v)
  233. {
  234.     if (_read_only)
  235.     {
  236. return HXR_FAIL;
  237.     }
  238.     else if (_prop_type != PT_INTREF)
  239.     {
  240. _prop_val.t_iref = 0;
  241. return HXR_FAIL;
  242.     }
  243.     else
  244.     {
  245. _prop_val.t_iref = v;
  246. return HXR_OK;
  247.     }
  248. }
  249. inline HX_RESULT
  250. Property::buf_val(IHXBuffer* v, HXPropType t)
  251. {
  252.     HX_RESULT theErr = HXR_OK;
  253.     if (_read_only)
  254.     {
  255. return HXR_FAIL;
  256.     }
  257.     else if (_prop_type != t)
  258.     {
  259. theErr = HXR_FAIL;
  260. goto cleanup;
  261.     }
  262.   
  263.     if (_prop_val.t_buf)
  264.     {
  265. _prop_val.t_buf->Release();
  266. _prop_val.t_buf = 0;
  267.     }
  268.     if (!v)
  269.     {
  270. theErr = HXR_OK;
  271. goto cleanup;
  272.     }
  273.     _prop_val.t_buf = v;
  274.     v->AddRef();
  275. cleanup:
  276.     return theErr;
  277. }
  278. inline const Key*
  279. Property::get_key_obj() const
  280. {
  281.     return _prop_name;
  282. }
  283. inline const char*
  284. Property::get_key_str() const
  285. {
  286.     return _prop_name->get_key_str();
  287. }
  288. inline int
  289. Property::get_key_str_len() const
  290. {
  291.     return _prop_name->size();
  292. }
  293. inline void
  294. Property::get_type(HXPropType* t) const
  295. {
  296.     *t = _prop_type;
  297. }
  298. inline HXPropType
  299. Property::get_type() const
  300. {
  301.     return _prop_type;
  302. }
  303. inline HX_RESULT
  304. Property::get_buf_val(IHXBuffer** v, HXPropType t) const
  305. {
  306.     HX_RESULT theErr = HXR_OK;
  307.     *v = 0;
  308.     if (_prop_type != t)
  309.     {
  310. theErr = HXR_FAIL;
  311. goto cleanup;
  312.     }
  313.    
  314.     if (!_prop_val.t_buf)
  315.     {
  316. theErr = HXR_FAIL;
  317. goto cleanup;
  318.     }
  319.     _prop_val.t_buf->AddRef();
  320.     *v = _prop_val.t_buf;
  321. cleanup:
  322.     return theErr;
  323. }
  324. inline HX_RESULT
  325. Property::get_int_val(INT32* v) const
  326. {
  327.     if (_prop_type != PT_INTEGER)
  328.     {
  329. *v = 0;
  330. return HXR_FAIL;
  331.     }
  332.     else
  333.     {
  334. *v = _prop_val.t_int;
  335. return HXR_OK;
  336.     }
  337. }
  338. inline HX_RESULT
  339. Property::get_int_ref_val(INT32* v) const
  340. {
  341.     if (_prop_type != PT_INTREF)
  342.     {
  343. *v = 0;
  344. return HXR_FAIL;
  345.     }
  346.     else
  347.     {
  348. *v = *_prop_val.t_iref;
  349. return HXR_OK;
  350.     }
  351. }
  352. inline HX_RESULT
  353. Property::get_db_val(DB_implem** v) const
  354. {
  355.     if (_prop_type != PT_COMPOSITE)
  356.     {
  357. *v = 0;
  358. return HXR_FAIL;
  359.     }
  360.     else
  361.     {
  362. *v = _prop_val.t_imp;
  363. return HXR_OK;
  364.     }
  365. }
  366. inline INT32
  367. Property::get_int_val() const
  368. {
  369.     if (_prop_type != PT_INTEGER)
  370. return 0;
  371.     else
  372. return _prop_val.t_int;
  373. }
  374. inline const IHXBuffer*
  375. Property::get_buf_val(HXPropType t) const
  376. {
  377.     if (_prop_type != t)
  378. return 0;
  379.     
  380.     if (!_prop_val.t_buf)
  381. return 0;
  382.     _prop_val.t_buf->AddRef();
  383.     return _prop_val.t_buf;
  384. }
  385. inline INT32
  386. Property::get_int_ref_val() const
  387. {
  388.     if (_prop_type != PT_INTREF)
  389. return 0;
  390.     else
  391.     {
  392. return *_prop_val.t_iref;
  393.     }
  394. }
  395. inline const DB_implem*
  396. Property::get_db_val() const
  397. {
  398.     if (_prop_type != PT_COMPOSITE)
  399. return 0;
  400.     else
  401. return _prop_val.t_imp;
  402. }
  403. inline void
  404. Property::set_deleted(DB_implem* ldb, DB_node* d, UINT32 h)
  405. {
  406.     _owner_db = ldb;
  407.     _owner_node = d;
  408.     _id = h;
  409.     _deleted = TRUE;
  410. }
  411. inline BOOL
  412. Property::is_deleted()
  413. {
  414.     return _deleted;
  415. }
  416. inline void
  417. Property::set_read_only(BOOL read_only)
  418. {
  419.     _read_only = read_only;
  420. }
  421. inline BOOL
  422. Property::is_read_only()
  423. {
  424.     return _read_only;
  425. }
  426. inline void
  427. Property::SetStringAccessAsBufferById()
  428. {
  429.     _alternate_string_access_ok = TRUE;
  430. }
  431. #endif // _PROPERTY_H