hxwinreg.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:10k
源码类别:

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. class CHXString;
  36. #include "hlxclib/windows.h"
  37. class _CListOfCHXString_Node
  38. {
  39. public:
  40.     _CListOfCHXString_Node();
  41.     ~_CListOfCHXString_Node();
  42.     CHXString& value();
  43.     const CHXString& value() const;
  44.     void value(const CHXString& rclsNewValue);
  45.     _CListOfCHXString_Node& operator=(const CHXString& rclsNewValue); 
  46.     _CListOfCHXString_Node* next() const;
  47.     void next(_CListOfCHXString_Node* plocnNew);
  48.     _CListOfCHXString_Node* prev() const;
  49.     void prev(_CListOfCHXString_Node* plocnNew);
  50.     void Remove();
  51.     void Insert(_CListOfCHXString_Node& rlocnNew);
  52. protected:
  53.     CHXString m_clsValue;
  54.     _CListOfCHXString_Node* m_plocPrev;
  55.     _CListOfCHXString_Node* m_plocNext;
  56.     _CListOfCHXString_Node(const _CListOfCHXString_Node& rlocnOther){}
  57. };
  58. class _CListIteratorCHXString_;
  59. class _CListReverseIteratorCHXString_;
  60. class _CListOfCHXString_
  61. {
  62. public:
  63.     typedef _CListIteratorCHXString_ iterator;
  64.     typedef _CListReverseIteratorCHXString_ reverse_iterator;
  65.     typedef const _CListReverseIteratorCHXString_ const_reverse_iterator;
  66.     _CListOfCHXString_();
  67.     _CListOfCHXString_(const _CListOfCHXString_& rlocOther);
  68.     ~_CListOfCHXString_();
  69.     _CListOfCHXString_& operator=(const _CListOfCHXString_& rlocOther); 
  70.     iterator begin();
  71.     const iterator begin() const;
  72.     iterator end();
  73.     const iterator end() const;
  74.     reverse_iterator rbegin();
  75.     const reverse_iterator rbegin() const;
  76.     reverse_iterator rend();
  77.     const reverse_iterator rend() const;
  78.     iterator insert(iterator itBefore, const CHXString&);
  79.     void insert
  80.     (
  81. iterator itBefore,
  82. const iterator itFirst,
  83. const iterator itLast
  84.     );
  85.     void remove(iterator itThis);
  86.     void remove(iterator itFirst, iterator itLast);
  87.     void empty();
  88. protected:
  89.     _CListOfCHXString_Node m_locnREnd;
  90.     _CListOfCHXString_Node m_locnEnd;
  91.     void _copy(const _CListOfCHXString_& rlocOther);
  92. };
  93. class _CListIteratorCHXString_
  94. {
  95. public:
  96.     _CListIteratorCHXString_();
  97.     _CListIteratorCHXString_
  98.     (
  99.         const _CListOfCHXString_Node& rlocnNewLocation
  100.     );
  101.     _CListIteratorCHXString_(const _CListIteratorCHXString_& rliocOther);
  102.     ~_CListIteratorCHXString_();
  103.     _CListIteratorCHXString_& operator=
  104.     (
  105. const _CListIteratorCHXString_& rliocOther
  106.     );
  107.     CHXString& operator*();
  108.     _CListIteratorCHXString_& operator=(const CHXString& rclsNewValue);
  109.     _CListIteratorCHXString_& operator++();
  110.     const _CListIteratorCHXString_ operator++(int);
  111.     _CListIteratorCHXString_& operator--();
  112.     const _CListIteratorCHXString_ operator--(int);
  113. private:
  114.     _CListOfCHXString_Node* m_plocCurrent;
  115.     friend class _CListOfCHXString_;
  116.     friend BOOL operator==
  117.     (
  118. const _CListIteratorCHXString_& rliocLeft,
  119. const _CListIteratorCHXString_& rliocRight
  120.     );
  121.     friend BOOL operator!=
  122.     (
  123. const _CListIteratorCHXString_& rliocLeft,
  124. const _CListIteratorCHXString_& rliocRight
  125.     );
  126. };
  127. BOOL operator==
  128. (
  129.     const _CListIteratorCHXString_& rliocLeft,
  130.     const _CListIteratorCHXString_& rliocRight
  131. );
  132. BOOL operator!=
  133. (
  134.     const _CListIteratorCHXString_& rliocLeft,
  135.     const _CListIteratorCHXString_& rliocRight
  136. );
  137. class _CListReverseIteratorCHXString_
  138. {
  139. public:
  140.     _CListReverseIteratorCHXString_();
  141.     _CListReverseIteratorCHXString_
  142.     (
  143.         const _CListOfCHXString_Node& rlocnNewLocation
  144.     );
  145.     _CListReverseIteratorCHXString_
  146.     (
  147. _CListReverseIteratorCHXString_& rlriocOther
  148.     );
  149.     ~_CListReverseIteratorCHXString_();
  150.     _CListReverseIteratorCHXString_& operator=
  151.     (
  152. const _CListReverseIteratorCHXString_& rlriocOther
  153.     );
  154.     CHXString& operator*();
  155.     _CListReverseIteratorCHXString_& operator=(const CHXString& rclsNewValue);
  156.     _CListReverseIteratorCHXString_& operator++();
  157.     const _CListReverseIteratorCHXString_ operator++(int);
  158.     _CListReverseIteratorCHXString_& operator--();
  159.     const _CListReverseIteratorCHXString_ operator--(int);
  160. private:
  161.     _CListOfCHXString_Node* m_plocCurrent;
  162.     friend class _CListOfCHXString_;
  163.     friend BOOL operator==
  164.     (
  165. const _CListReverseIteratorCHXString_& rlriocLeft,
  166. const _CListReverseIteratorCHXString_& rlriocRight
  167.     );
  168.     friend BOOL operator!=
  169.     (
  170. const _CListReverseIteratorCHXString_& rlriocLeft,
  171. const _CListReverseIteratorCHXString_& rlriocRight
  172.     );
  173. };
  174. BOOL operator==
  175. (
  176.     const _CListReverseIteratorCHXString_& rlriocLeft,
  177.     const _CListReverseIteratorCHXString_& rlriocRight
  178. );
  179. BOOL operator!=
  180. (
  181.     const _CListReverseIteratorCHXString_& rlriocLeft,
  182.     const _CListReverseIteratorCHXString_& rlriocRight
  183. );     
  184. class AWinRegValue
  185. {
  186. public:
  187.     AWinRegValue(const char* szName, HKEY hkParent)
  188. : m_hkParent(hkParent)
  189. , m_sName(szName)
  190.     {
  191.     }
  192.     virtual ~AWinRegValue(){}
  193.     HX_RESULT Delete()
  194.     {
  195. if
  196. (
  197.     RegDeleteValue
  198.     (
  199. m_hkParent,
  200. OS_STRING(m_sName)
  201.     ) == ERROR_SUCCESS
  202. )
  203. {
  204.     return HXR_OK;
  205. }
  206.         return HXR_FAIL;
  207.     }
  208.     void SetName(const char* szName){m_sName = szName;}
  209.     CHXString& GetName(){return m_sName;}
  210.     void SetParent(HKEY hkParent){m_hkParent = hkParent;}
  211.     
  212.     virtual BOOL DoesExist() =0;
  213.     virtual BOOL IsDWORD(){return FALSE;}
  214.     virtual BOOL AsDWORD(UINT32*){return FALSE;}
  215.     virtual BOOL FromDWORD(UINT32){return FALSE;}
  216.     virtual BOOL IsString(){return FALSE;}
  217.     virtual BOOL AsString(CHXString&){return FALSE;}
  218.     virtual BOOL FromString(const char*){return FALSE;}
  219.     virtual BOOL IsStringArray(){return FALSE;}
  220.     virtual BOOL AsStringArray(_CListOfCHXString_&){return FALSE;}
  221.     virtual BOOL AsStringArray(char**){return FALSE;}
  222.     virtual BOOL FromStringArray (const _CListOfCHXString_&){return FALSE;}
  223.     virtual BOOL FromStringArray(const char*, UINT32){return FALSE;}
  224.     void FreeStringArray
  225.     (
  226. char*& rszValue
  227.     ){delete [] rszValue;rszValue=NULL;}
  228. protected:
  229.     HKEY m_hkParent;
  230.     CHXString m_sName;
  231.     AWinRegValue(){}
  232. private:
  233. };
  234. class CWinRegStringValue : public AWinRegValue
  235. {
  236. public:
  237.     CWinRegStringValue(const char* szName, HKEY hkParent);
  238.     virtual ~CWinRegStringValue();
  239.     CWinRegStringValue& operator=(const char* szNewValue);
  240.     BOOL IsString();
  241.     BOOL AsString(CHXString&);
  242.     BOOL FromString(const char*);
  243.     HX_RESULT Delete();
  244.     
  245.     BOOL DoesExist();
  246. private:
  247.     CWinRegStringValue(){}
  248.     CWinRegStringValue(const CWinRegStringValue&){}
  249. };
  250. class CWinRegDWORDValue : public AWinRegValue
  251. {
  252. public:
  253.     CWinRegDWORDValue(const char* szName, HKEY hkParent);
  254.     virtual ~CWinRegDWORDValue();
  255.     CWinRegDWORDValue& operator=(UINT32 dwNewValue);
  256.     BOOL IsDWORD();
  257.     BOOL AsDWORD(UINT32*);
  258.     BOOL FromDWORD(UINT32);
  259.     HX_RESULT Delete();
  260.     
  261.     BOOL DoesExist();
  262. private:
  263.     CWinRegDWORDValue(){}
  264.     CWinRegDWORDValue(const CWinRegDWORDValue&){}
  265. };
  266. class CWinRegStringArrayValue : public AWinRegValue
  267. {
  268. public:
  269.     CWinRegStringArrayValue(const char* szName, HKEY hkParent);
  270.     virtual ~CWinRegStringArrayValue();
  271.     CWinRegStringArrayValue& operator=(const _CListOfCHXString_&);
  272.     BOOL IsStringArray();
  273.     BOOL AsStringArray(_CListOfCHXString_&);
  274.     BOOL AsStringArray(char**);
  275.     BOOL FromStringArray(const _CListOfCHXString_&);
  276.     BOOL FromStringArray(const char*, UINT32);
  277.     HX_RESULT Delete();
  278.     
  279.     BOOL DoesExist();
  280. private:
  281.     CWinRegStringArrayValue(){}
  282.     CWinRegStringArrayValue(const CWinRegStringArrayValue&){}
  283. };
  284. class CWinRegKey
  285. {
  286. public:
  287.     CWinRegKey();
  288.     virtual ~CWinRegKey();
  289.     HX_RESULT Open();
  290.     HX_RESULT Create
  291.     (
  292. const char* szClass=NULL, 
  293. DWORD dwOptions=REG_OPTION_NON_VOLATILE
  294.     );
  295.     HX_RESULT Close();
  296.     HX_RESULT Flush();
  297.     HX_RESULT DeleteSubKey(const char* szName);
  298.     
  299.     BOOL DoesExist();
  300.     BOOL SetDesiredAccess(REGSAM rsNew);
  301.     REGSAM GetDesiredAccess();
  302.     BOOL SetRootKey(HKEY hkRoot);
  303.     HKEY GetRootKey();
  304.     HKEY GetHandle();
  305.     BOOL SetRelativePath(const char* szPath);
  306.     CHXString& GetRelativePath();
  307.     BOOL GetValue(const char* szName, AWinRegValue** ppwrvOut, UINT32 ulType=0);
  308.     BOOL ResetKeyEnumerator();
  309.     BOOL GetNextKey(CWinRegKey&);
  310.     BOOL ResetValueEnumerator();
  311.     BOOL GetNextValue(AWinRegValue** ppwrvNext);
  312.     void FreeValue(AWinRegValue*&);
  313. protected:
  314. private:
  315.     HKEY m_hkRoot;
  316.     HKEY m_hkThis;
  317.     CHXString m_sPath;
  318.     DWORD m_dwKeyEnumPos;
  319.     DWORD m_dwValueEnumPos;
  320.     REGSAM m_rsAccess;
  321.     BOOL m_bOpen;
  322. };