00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00051 #ifndef WINSTL_INCL_WINSTL_REGISTRY_HPP_REG_KEY
00052 #define WINSTL_INCL_WINSTL_REGISTRY_HPP_REG_KEY
00053
00054 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00055 # define WINSTL_VER_WINSTL_REGISTRY_HPP_REG_KEY_MAJOR 3
00056 # define WINSTL_VER_WINSTL_REGISTRY_HPP_REG_KEY_MINOR 9
00057 # define WINSTL_VER_WINSTL_REGISTRY_HPP_REG_KEY_REVISION 8
00058 # define WINSTL_VER_WINSTL_REGISTRY_HPP_REG_KEY_EDIT 135
00059 #endif
00060
00061
00062
00063
00064
00065 #ifndef WINSTL_INCL_WINSTL_H_WINSTL
00066 # include <winstl/winstl.h>
00067 #endif
00068 #ifndef WINSTL_INCL_WINSTL_REGISTRY_HPP_REGFWD
00069 # include <winstl/registry/regfwd.hpp>
00070 #endif
00071 #ifndef WINSTL_INCL_WINSTL_REGISTRY_UTIL_HPP_DEFS
00072 # include <winstl/registry/util/defs.hpp>
00073 #endif
00074 #ifndef WINSTL_INCL_WINSTL_REGISTRY_HPP_REG_TRAITS
00075 # include <winstl/registry/reg_traits.hpp>
00076 #endif
00077 #if defined(STLSOFT_COMPILER_IS_DMC)
00078 # ifndef WINSTL_INCL_WINSTL_REGISTRY_HPP_REG_VALUE
00079 # include <winstl/registry/reg_value.hpp>
00080 # endif
00081 #endif
00082 #ifndef WINSTL_INCL_WINSTL_REGISTRY_ERROR_HPP_EXCEPTIONS
00083 # include <winstl/registry/error/exceptions.hpp>
00084 #endif
00085 #ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_AUTO_BUFFER
00086 # include <stlsoft/memory/auto_buffer.hpp>
00087 #endif
00088 #ifndef WINSTL_INCL_WINSTL_MEMORY_HPP_PROCESSHEAP_ALLOCATOR
00089 # include <winstl/memory/processheap_allocator.hpp>
00090 #endif
00091 #ifndef WINSTL_INCL_SHIMS_ATTRIBUTE_HPP_GET_HKEY
00092 # include <winstl/shims/attribute/get_HKEY.hpp>
00093 #endif
00094 #ifndef STLSOFT_INCL_STLSOFT_SHIMS_ACCESS_HPP_STRING
00095 # include <stlsoft/shims/access/string.hpp>
00096 #endif
00097 #ifndef STLSOFT_INCL_STLSOFT_META_HPP_YESNO
00098 # include <stlsoft/meta/yesno.hpp>
00099 #endif
00100 #ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_STD_SWAP
00101 # include <stlsoft/util/std_swap.hpp>
00102 #endif
00103 #ifndef STLSOFT_INCL_STLSOFT_ITERATORS_HPP_TRANSFORM_ITERATOR
00104 # include <stlsoft/iterators/transform_iterator.hpp>
00105 #endif
00106
00107 #ifndef STLSOFT_INCL_NUMERIC
00108 # define STLSOFT_INCL_NUMERIC
00109 # include <numeric>
00110 #endif
00111 #ifndef STLSOFT_INCL_FUNCTIONAL
00112 # define STLSOFT_INCL_FUNCTIONAL
00113 # include <functional>
00114 #endif
00115
00116 #ifdef STLSOFT_UNITTEST
00117 # include <winstl/registry/reg_value.hpp>
00118 #endif
00119
00120
00121
00122
00123
00124 #ifndef _WINSTL_NO_NAMESPACE
00125 # if defined(_STLSOFT_NO_NAMESPACE) || \
00126 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
00127
00128 namespace winstl
00129 {
00130 # else
00131
00132
00133 namespace stlsoft
00134 {
00135
00136 namespace winstl_project
00137 {
00138
00139 # endif
00140 #endif
00141
00142
00143
00144
00145
00158 template< ss_typename_param_k C
00159 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00160 , ss_typename_param_k T = reg_traits<C>
00161 , ss_typename_param_k A = processheap_allocator<C>
00162 #else
00163 , ss_typename_param_k T
00164 , ss_typename_param_k A
00165 #endif
00166 >
00167 class basic_reg_key
00168 {
00171 public:
00173 typedef C char_type;
00175 typedef T traits_type;
00177 typedef A allocator_type;
00179 typedef basic_reg_key<C, T, A> class_type;
00181 typedef ss_typename_type_k traits_type::size_type size_type;
00183 typedef ss_typename_type_k traits_type::string_type string_type;
00185 #if defined(STLSOFT_COMPILER_IS_MSVC) && \
00186 _MSC_VER == 1100
00187
00188 typedef HKEY hkey_type;
00189 #else
00190 typedef ss_typename_type_k traits_type::hkey_type hkey_type;
00191 #endif
00193 typedef ws_bool_t bool_type;
00195 typedef basic_reg_value<C, T, A> key_value_type;
00196 #if 0
00198 typedef basic_reg_key_sequence<C, T, A> subkeys_collection_type;
00200 typedef basic_reg_value_sequence<C, T, A> value_collection_type;
00201 #endif
00202 private:
00204 typedef ss_typename_type_k traits_type::result_type result_type;
00205 public:
00206 typedef hkey_type resource_type;
00208
00211 private:
00212 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00213 friend class basic_reg_value_sequence<C, T, A>;
00214 friend class basic_reg_key_sequence<C, T, A>;
00215 #endif
00216
00217 #if defined(STLSOFT_COMPILER_IS_MSVC) && \
00218 ( _MSC_VER == 1200 || \
00219 _MSC_VER == 1300)
00220 public:
00221 #endif
00222 basic_reg_key(hkey_type* hkey, string_type const& keyName, REGSAM accessMask);
00223 public:
00225 basic_reg_key();
00242 basic_reg_key(hkey_type hkeyParent, char_type const* keyName, REGSAM accessMask = KEY_ALL_ACCESS)
00243 : m_name(keyName)
00244 , m_hkey(open_key_(hkeyParent, keyName, accessMask))
00245 , m_accessMask(accessMask)
00246 {}
00247 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00248
00264 template <ss_typename_param_k S>
00265 basic_reg_key(hkey_type hkeyParent, S const& keyName, REGSAM accessMask = KEY_ALL_ACCESS)
00266 : m_name(keyName)
00267 , m_hkey(open_key_(hkeyParent, stlsoft_ns_qual(c_str_ptr)(keyName), accessMask))
00268 , m_accessMask(accessMask)
00269 {}
00270 #endif
00271
00287 basic_reg_key(class_type const& keyParent, char_type const* keyName, REGSAM accessMask = KEY_ALL_ACCESS)
00288 : m_name(keyName)
00289 , m_hkey(open_key_(keyParent.get_key_handle(), keyName, accessMask))
00290 , m_accessMask(accessMask)
00291 {}
00292 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00293
00309 template <ss_typename_param_k S>
00310 basic_reg_key(class_type const& keyParent, S const& keyName, REGSAM accessMask = KEY_ALL_ACCESS)
00311 : m_name(keyName)
00312 , m_hkey(open_key_(keyParent.get_key_handle(), stlsoft_ns_qual(c_str_ptr)(keyName), accessMask))
00313 , m_accessMask(accessMask)
00314 {}
00315 #endif
00316
00329 basic_reg_key(class_type const& rhs);
00344 basic_reg_key(class_type const& rhs, REGSAM accessMask);
00345
00350 ~basic_reg_key() stlsoft_throw_0();
00351
00353 class_type& operator =(class_type const& rhs);
00355
00358 public:
00360 string_type const &name() const;
00362 string_type reg_class() const;
00366 size_type num_sub_keys() const;
00370 size_type num_values() const;
00374 template <ss_typename_param_k S>
00375 bool_type has_sub_key(S const& subKeyName)
00376 {
00377 return this->has_sub_key_(stlsoft_ns_qual(c_str_ptr)(subKeyName));
00378 }
00382 template <ss_typename_param_k S>
00383 bool_type has_value(S const& valueName)
00384 {
00385 return this->has_value_(stlsoft_ns_qual(c_str_ptr)(valueName));
00386 }
00387
00394 hkey_type get_key_handle() const;
00398 hkey_type get() const;
00399
00400 #if 0
00401 subkeys_collection_type subkeys() const;
00402 value_collection_type values() const;
00403 #endif
00404
00406 REGSAM get_access_mask() const;
00408
00411 public:
00413 class_type open_sub_key(char_type const* subKeyName, REGSAM accessMask = KEY_ALL_ACCESS);
00414 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00415 template <ss_typename_param_k S>
00416 class_type open_sub_key(S const& subKeyName, REGSAM accessMask = KEY_ALL_ACCESS)
00417 {
00418 return open_sub_key_(stlsoft_ns_qual(c_str_ptr)(subKeyName), accessMask);
00419 }
00420 #endif
00421
00435 class_type create_sub_key(char_type const* subKeyName, REGSAM accessMask = KEY_ALL_ACCESS);
00436 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00437
00450 template <ss_typename_param_k S>
00451 class_type create_sub_key(S const& subKeyName, REGSAM accessMask = KEY_ALL_ACCESS)
00452 {
00453 return create_sub_key_(stlsoft_ns_qual(c_str_ptr)(subKeyName), accessMask);
00454 }
00455 #endif
00456
00471 static class_type create_key(HKEY hkey, char_type const* subKeyName, REGSAM accessMask = KEY_ALL_ACCESS);
00472 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00473
00487 template <ss_typename_param_k H, ss_typename_param_k S>
00488 static class_type create_key(H const& key, S const& subKeyName, REGSAM accessMask = KEY_ALL_ACCESS)
00489 {
00490 return create_key_(get_HKEY(key), stlsoft_ns_qual(c_str_ptr)(subKeyName), accessMask);
00491 }
00492 #endif
00493
00494
00510 bool_type delete_sub_key(char_type const* subKeyName);
00511 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00512
00527 template <ss_typename_param_k S>
00528 class_type delete_sub_key(S const& subKeyName)
00529 {
00530 return delete_sub_key_(stlsoft_ns_qual(c_str_ptr)(subKeyName));
00531 }
00532 #endif
00534
00545 hkey_type dup_key_handle( REGSAM accessMask = KEY_ALL_ACCESS
00546 , result_type *res = NULL);
00547
00550 public:
00557 bool_type set_value(char_type const* valueName, DWORD value);
00558 #ifdef STLSOFT_CF_64BIT_INT_SUPPORT
00559
00565 bool_type set_value(char_type const* valueName, ws_uint64_t value);
00566 #endif
00567
00572
00577 bool_type set_value(char_type const* valueName, char_type const* value, ws_uint_t type = REG_SZ);
00583
00588 bool_type set_value(char_type const* valueName, char_type const** values, size_type numValues);
00595 bool_type set_value(char_type const* valueName, void const* value, size_type cbValue);
00596
00597 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00598
00604 template <ss_typename_param_k S>
00605 bool_type set_value(S const& valueName, DWORD value)
00606 {
00607 return set_value_(stlsoft_ns_qual(c_str_ptr)(valueName), value);
00608 }
00609 #endif
00610 #ifdef STLSOFT_CF_64BIT_INT_SUPPORT
00611 # ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00612
00618 template <ss_typename_param_k S>
00619 bool_type set_value(S const& valueName, ws_uint64_t value)
00620 {
00621 return set_value_(stlsoft_ns_qual(c_str_ptr)(valueName), value);
00622 }
00623 # endif
00624 #endif
00625 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00626
00631
00636 template <ss_typename_param_k S>
00637 bool_type set_value(S const& valueName, char_type const* value, ws_uint_t type = REG_SZ)
00638 {
00639 return set_value_(stlsoft_ns_qual(c_str_ptr)(valueName), value, type);
00640 }
00641 #endif
00642 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00643
00648
00653 template <ss_typename_param_k S>
00654 bool_type set_value(S const& valueName, char_type const** values, size_type numValues)
00655 {
00656 return set_value_(stlsoft_ns_qual(c_str_ptr)(valueName), values, numValues);
00657 }
00658 #endif
00659 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00660
00666 template <ss_typename_param_k S>
00667 bool_type set_value(S const& valueName, void const* value, size_type cbValue)
00668 {
00669 return set_value_(stlsoft_ns_qual(c_str_ptr)(valueName), value, cbValue);
00670 }
00671 #endif
00672
00676
00681 bool_type set_value(char_type const* valueName, int value);
00682 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00683
00687
00692 template <ss_typename_param_k S>
00693 bool_type set_value(S const& valueName, int value)
00694 {
00695 return set_value_(stlsoft_ns_qual(c_str_ptr)(valueName), value);
00696 }
00697 #endif
00698
00713 bool_type delete_value(char_type const* valueName);
00714 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00715
00730 template <ss_typename_param_k S>
00731 bool_type delete_value(S const& valueName)
00732 {
00733 return this->delete_value_(stlsoft_ns_qual(c_str_ptr)(valueName));
00734 }
00735 #endif
00736
00737 #if 0
00738 ws_dword_t get_value_type(char_type const* valueName) const;
00739 size_type get_value_data_size(char_type const* valueName) const;
00740 #endif
00741
00745
00746 key_value_type get_value(char_type const* valueName) const;
00747 #ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00748
00751
00752 template <ss_typename_param_k S>
00753 key_value_type get_value(S const& valueName) const
00754 {
00755 return this->get_value(stlsoft_ns_qual(c_str_ptr)(stlsoft_ns_qual(c_str_ptr)(valueName)));
00756 }
00757 #endif
00758
00760
00763 private:
00764 static hkey_type open_key_( hkey_type hkeyParent
00765 , char_type const* keyName
00766 , REGSAM accessMask);
00767 class_type open_sub_key_( char_type const* subKeyName
00768 , REGSAM accessMask);
00769 static class_type create_key_( HKEY hkey
00770 , char_type const* subKeyName
00771 , REGSAM accessMask);
00772 class_type create_sub_key_( char_type const* subKeyName
00773 , REGSAM accessMask);
00774 bool_type delete_sub_key_( char_type const* subKeyName);
00775 static result_type set_value_( hkey_type hkey
00776 , char_type const* valueName
00777 , ws_uint_t type
00778 , void const* value
00779 , size_type cbValue);
00780
00781 bool_type set_value_int_(char_type const* valueName, int value, stlsoft_ns_qual(yes_type));
00782 bool_type set_value_int_(char_type const* valueName, int value, stlsoft_ns_qual(no_type));
00783
00784 bool_type set_value_(char_type const* valueName, DWORD value);
00785 # ifdef STLSOFT_CF_64BIT_INT_SUPPORT
00786 bool_type set_value_(char_type const* valueName, ws_uint64_t value);
00787 # endif
00788 bool_type set_value_(char_type const* valueName, char_type const* value, ws_uint_t type);
00789 bool_type set_value_(char_type const* valueName, char_type const** values, size_type numValues);
00790 bool_type set_value_(char_type const* valueName, void const* value, size_type cbValue);
00791 bool_type set_value_(char_type const* valueName, int value);
00792
00793 bool_type delete_value_(char_type const* valueName);
00794
00795 bool_type has_sub_key_(char_type const* subKeyName);
00796 bool_type has_value_(char_type const* valueName);
00797
00798 static result_type get_value_(hkey_type hkey, char_type const* valueName, ws_uint_t type, void *value, size_type *pcbValue);
00799
00800 static hkey_type dup_key_( hkey_type hkey
00801 , REGSAM accessMask = KEY_ALL_ACCESS);
00803
00806 public:
00810
00811 void swap(class_type& rhs) stlsoft_throw_0();
00813
00816 private:
00817 string_type m_name;
00818 hkey_type m_hkey;
00819 REGSAM m_accessMask;
00821 };
00822
00823
00828 typedef basic_reg_key<ws_char_a_t, reg_traits<ws_char_a_t>, processheap_allocator<ws_char_a_t> > reg_key_a;
00833 typedef basic_reg_key<ws_char_w_t, reg_traits<ws_char_w_t>, processheap_allocator<ws_char_w_t> > reg_key_w;
00838 typedef basic_reg_key<TCHAR, reg_traits<TCHAR>, processheap_allocator<TCHAR> > reg_key;
00839
00840
00841
00842
00843
00844
00845
00854 template< ss_typename_param_k C
00855 , ss_typename_param_k T
00856 , ss_typename_param_k A
00857 >
00858 inline HKEY get_handle(basic_reg_key<C, T, A> const& key)
00859 {
00860 return key.get_key_handle();
00861 }
00862
00874 template< ss_typename_param_k C
00875 , ss_typename_param_k T
00876 , ss_typename_param_k A
00877 >
00878 inline HKEY get_HKEY(basic_reg_key<C, T, A> const& key)
00879 {
00880 return key.get_key_handle();
00881 }
00882
00884
00885
00886 #ifdef STLSOFT_UNITTEST
00887 # include "./unittest/reg_key_unittest_.h"
00888 #endif
00889
00890
00891
00892
00893
00894 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00895
00896 template< ss_typename_param_k C
00897 , ss_typename_param_k T
00898 , ss_typename_param_k A
00899 >
00900 #if ( defined(STLSOFT_COMPILER_IS_MSVC) && \
00901 _MSC_VER < 1100) || \
00902 defined(STLSOFT_COMPILER_IS_VECTORC)
00903 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::hkey_type basic_reg_key<C, T, A>::open_key_(hkey_type hkeyParent, char_type const* keyName, REGSAM accessMask)
00904 #else
00905 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::hkey_type basic_reg_key<C, T, A>::open_key_(ss_typename_param_k basic_reg_key<C, T, A>::hkey_type hkeyParent, ss_typename_param_k basic_reg_key<C, T, A>::char_type const* keyName, REGSAM accessMask)
00906 #endif
00907 {
00908 hkey_type hkey;
00909 result_type res = traits_type::reg_open_key(hkeyParent, keyName, &hkey, accessMask);
00910
00911 if(ERROR_SUCCESS != res)
00912 {
00913 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00914 static const char message[] = "could not open key";
00915
00916 if(ERROR_ACCESS_DENIED == res)
00917 {
00918 STLSOFT_THROW_X(access_denied_exception(message, res));
00919 }
00920 else
00921 {
00922 STLSOFT_THROW_X(registry_exception(message, res));
00923 }
00924 #else
00925 ::SetLastError(res);
00926 hkey = NULL;
00927 #endif
00928 }
00929
00930 return hkey;
00931 }
00932
00933 template< ss_typename_param_k C
00934 , ss_typename_param_k T
00935 , ss_typename_param_k A
00936 >
00937 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::hkey_type basic_reg_key<C, T, A>::dup_key_( ss_typename_type_k basic_reg_key<C, T, A>::hkey_type hkey
00938 , REGSAM accessMask )
00939 {
00940 if(NULL == hkey)
00941 {
00942 return NULL;
00943 }
00944 else
00945 {
00946 result_type res;
00947 HKEY hkeyDup = traits_type::key_dup(hkey, accessMask, &res);
00948
00949 if(ERROR_SUCCESS != res)
00950 {
00951 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00952 static const char message[] = "could not duplicate key";
00953
00954 if(ERROR_ACCESS_DENIED == res)
00955 {
00956 STLSOFT_THROW_X(access_denied_exception(message, res));
00957 }
00958 else
00959 {
00960 STLSOFT_THROW_X(key_not_duplicated_exception(message, res));
00961 }
00962 #else
00963 ::SetLastError(res);
00964 hkeyDup = NULL;
00965 #endif
00966 }
00967
00968 return hkeyDup;
00969 }
00970 }
00971
00972
00973 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
00974 inline basic_reg_key<C, T, A>::basic_reg_key()
00975 : m_name()
00976 , m_hkey(NULL)
00977 , m_accessMask(KEY_READ)
00978 {}
00979
00980 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
00981 inline basic_reg_key<C, T, A>::basic_reg_key(ss_typename_type_k basic_reg_key<C, T, A>::hkey_type* hkey, ss_typename_type_k basic_reg_key<C, T, A>::string_type const& keyName, REGSAM accessMask)
00982 : m_name(keyName)
00983 , m_hkey(*hkey)
00984 , m_accessMask(accessMask)
00985 {}
00986
00987 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
00988 inline basic_reg_key<C, T, A>::basic_reg_key(class_type const& rhs)
00989 : m_name(rhs.m_name)
00990 , m_hkey(dup_key_(rhs.m_hkey, rhs.get_access_mask()))
00991 , m_accessMask(rhs.m_accessMask)
00992 {}
00993
00994 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
00995 inline basic_reg_key<C, T, A>::basic_reg_key(class_type const& rhs, REGSAM accessMask)
00996 : m_name(rhs.m_name)
00997 , m_hkey(dup_key_(rhs.m_hkey, accessMask))
00998 , m_accessMask(accessMask)
00999 {}
01000
01001 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01002 inline basic_reg_key<C, T, A>::~basic_reg_key() stlsoft_throw_0()
01003 {
01004 if(m_hkey != NULL)
01005 {
01006 ::RegCloseKey(m_hkey);
01007 }
01008 }
01009
01010 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01011 inline void basic_reg_key<C, T, A>::swap(ss_typename_type_k basic_reg_key<C, T, A>::class_type& rhs) stlsoft_throw_0()
01012 {
01013 std_swap(m_name, rhs.m_name);
01014 std_swap(m_hkey, rhs.m_hkey);
01015 std_swap(m_accessMask, rhs.m_accessMask);
01016 }
01017
01018 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01019 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::class_type& basic_reg_key<C, T, A>::operator =(ss_typename_type_k basic_reg_key<C, T, A>::class_type const& rhs)
01020 {
01021 class_type _this(rhs);
01022
01023 swap(_this);
01024
01025 return *this;
01026 }
01027
01028
01029 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01030 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::string_type const& basic_reg_key<C, T, A>::name() const
01031 {
01032 return m_name;
01033 }
01034
01035 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01036 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::string_type basic_reg_key<C, T, A>::reg_class() const
01037 {
01038 size_type cch_key_class = 0;
01039 ws_long_t res = traits_type::reg_query_info(m_hkey, NULL, &cch_key_class, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
01040
01041 if(ERROR_SUCCESS != res)
01042 {
01043 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01044 query_fail:
01045
01046 static const char message[] = "could not determine the key registry class";
01047
01048 if(ERROR_ACCESS_DENIED == res)
01049 {
01050 STLSOFT_THROW_X(access_denied_exception(message, res));
01051 }
01052 else
01053 {
01054 STLSOFT_THROW_X(registry_exception(message, res));
01055 }
01056 #endif
01057 }
01058 else
01059 {
01060 stlsoft_ns_qual(auto_buffer_old)<char_type, allocator_type, CCH_REG_API_AUTO_BUFFER> p(++cch_key_class);
01061
01062 res = traits_type::reg_query_info(m_hkey, &p[0], &cch_key_class, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
01063
01064 if(ERROR_SUCCESS != res)
01065 {
01066 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01067 goto query_fail;
01068 #endif
01069 }
01070 else
01071 {
01072 return string_type(&p[0], cch_key_class);
01073 }
01074 }
01075
01076 return string_type();
01077 }
01078
01079 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01080 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::size_type basic_reg_key<C, T, A>::num_sub_keys() const
01081 {
01082 ws_uint32_t c_sub_keys;
01083 ws_long_t res = traits_type::reg_query_info(m_hkey, NULL, NULL, &c_sub_keys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
01084
01085 if(ERROR_SUCCESS != res)
01086 {
01087 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01088 static const char message[] = "could not determine the number of sub-keys";
01089
01090 if(ERROR_ACCESS_DENIED == res)
01091 {
01092 STLSOFT_THROW_X(access_denied_exception(message, res));
01093 }
01094 else
01095 {
01096 STLSOFT_THROW_X(registry_exception(message, res));
01097 }
01098 #else
01099 c_sub_keys = 0;
01100 #endif
01101 }
01102
01103 return c_sub_keys;
01104 }
01105
01106 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01107 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::size_type basic_reg_key<C, T, A>::num_values() const
01108 {
01109 ws_uint32_t c_values;
01110 ws_long_t res = traits_type::reg_query_info(m_hkey, NULL, NULL, NULL, NULL, NULL, &c_values, NULL, NULL, NULL, NULL);
01111
01112 if(ERROR_SUCCESS != res)
01113 {
01114 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01115 static const char message[] = "could not determine the number of values";
01116
01117 if(ERROR_ACCESS_DENIED == res)
01118 {
01119 STLSOFT_THROW_X(access_denied_exception(message, res));
01120 }
01121 else
01122 {
01123 STLSOFT_THROW_X(registry_exception(message, res));
01124 }
01125 #else
01126 c_values = 0;
01127 #endif
01128 }
01129
01130 return c_values;
01131 }
01132
01133 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01134 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::hkey_type basic_reg_key<C, T, A>::get_key_handle() const
01135 {
01136 return m_hkey;
01137 }
01138
01139 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01140 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::hkey_type basic_reg_key<C, T, A>::get() const
01141 {
01142 return get_key_handle();
01143 }
01144
01145 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01146 inline REGSAM basic_reg_key<C, T, A>::get_access_mask() const
01147 {
01148 return m_accessMask;
01149 }
01150
01151
01152 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01153 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::class_type basic_reg_key<C, T, A>::open_sub_key(char_type const* subKeyName, REGSAM accessMask )
01154 {
01155 return this->open_sub_key_(subKeyName, accessMask);
01156 }
01157
01158 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01159 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::class_type basic_reg_key<C, T, A>::create_sub_key(char_type const* subKeyName, REGSAM accessMask )
01160 {
01161 return this->create_sub_key_(subKeyName, accessMask);
01162 }
01163
01164 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01165 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::class_type basic_reg_key<C, T, A>::create_key(HKEY hkey, char_type const* subKeyName, REGSAM accessMask )
01166 {
01167 return create_key_(hkey, subKeyName, accessMask);
01168 }
01169
01170 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01171 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::class_type basic_reg_key<C, T, A>::open_sub_key_(char_type const* subKeyName, REGSAM accessMask )
01172 {
01173 return class_type(m_hkey, subKeyName, accessMask);
01174 }
01175
01176 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01177 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::class_type basic_reg_key<C, T, A>::create_key_(
01178 HKEY hkey
01179 , char_type const* subKeyName
01180 , REGSAM accessMask
01181 )
01182 {
01183 static const char_type s_emptyString[] = { '\0' };
01184
01185 return class_type(hkey, s_emptyString, KEY_CREATE_SUB_KEY).create_sub_key(subKeyName, accessMask);
01186 }
01187
01188 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01189 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::class_type basic_reg_key<C, T, A>::create_sub_key_(
01190 char_type const* subKeyName
01191 , REGSAM accessMask
01192 )
01193 {
01194 hkey_type hkey;
01195 result_type res = traits_type::reg_create_key(m_hkey, subKeyName, &hkey, accessMask);
01196
01197 if(ERROR_SUCCESS != res)
01198 {
01199 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01200 static const char message[] = "could not create sub-key";
01201
01202 if(ERROR_ACCESS_DENIED == res)
01203 {
01204 STLSOFT_THROW_X(access_denied_exception(message, res));
01205 }
01206 else
01207 {
01208 STLSOFT_THROW_X(registry_exception(message, res));
01209 }
01210 #else
01211 ::SetLastError(res);
01212 return class_type();
01213 #endif
01214 }
01215
01216 return class_type(&hkey, subKeyName, accessMask);
01217 }
01218
01219 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01220 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::delete_sub_key(char_type const* subKeyName)
01221 {
01222 return this->delete_sub_key_(subKeyName);
01223 }
01224
01225 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01226 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::delete_sub_key_(char_type const* subKeyName)
01227 {
01228 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01229 static const char message[] = "could not delete sub-key";
01230 #endif
01231
01232 result_type res = traits_type::reg_delete_key(m_hkey, subKeyName);
01233
01234 switch(res)
01235 {
01236 case ERROR_SUCCESS:
01237 return true;
01238 default:
01239 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01240 if(ERROR_ACCESS_DENIED == res)
01241 {
01242 STLSOFT_THROW_X(access_denied_exception(message, res));
01243 }
01244 else
01245 {
01246 STLSOFT_THROW_X(registry_exception(message, res));
01247 }
01248 #else
01249 ::SetLastError(res);
01250
01251 #endif
01252 case ERROR_FILE_NOT_FOUND:
01253 return false;
01254 }
01255 }
01256
01257
01258
01259 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01260 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::hkey_type basic_reg_key<C, T, A>::dup_key_handle(REGSAM accessMask , result_type *res )
01261 {
01262 return traits_type::key_dup(m_hkey, accessMask, res);
01263 }
01264
01265
01266
01267 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01268 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, DWORD value)
01269 {
01270 return set_value_(valueName, value);
01271 }
01272
01273 # ifdef STLSOFT_CF_64BIT_INT_SUPPORT
01274 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01275 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, ws_uint64_t value)
01276 {
01277 return set_value_(valueName, value);
01278 }
01279 # endif
01280
01281 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01282 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, int value)
01283 {
01284 return set_value_(valueName, value);
01285 }
01286
01287 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01288 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, char_type const* value, ws_uint_t type )
01289 {
01290 return set_value_(valueName, value, type);
01291 }
01292
01293 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01294 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, ss_typename_type_k basic_reg_key<C, T, A>::char_type const** values, ss_typename_type_k basic_reg_key<C, T, A>::size_type numValues)
01295 {
01296 return set_value_(valueName, values, numValues);
01297 }
01298
01299 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01300 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, void const* value, size_type cbValue)
01301 {
01302 return set_value_(valueName, value, cbValue);
01303 }
01304
01305
01306
01307 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01308 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::result_type basic_reg_key<C, T, A>::set_value_( ss_typename_type_k basic_reg_key<C, T, A>::hkey_type hkey
01309 , ss_typename_type_k basic_reg_key<C, T, A>::char_type const *valueName
01310 , ws_uint_t type
01311 , void const *value
01312 , ss_typename_type_k basic_reg_key<C, T, A>::size_type cbValue)
01313 {
01314 result_type res = traits_type::reg_set_value(hkey, valueName, type, value, cbValue);
01315
01316 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01317 if(ERROR_SUCCESS != res)
01318 {
01319 static const char message[] = "could not create value";
01320
01321 if(ERROR_ACCESS_DENIED == res)
01322 {
01323 STLSOFT_THROW_X(access_denied_exception(message, res));
01324 }
01325 else
01326 {
01327 STLSOFT_THROW_X(registry_exception(message, res));
01328 }
01329 }
01330 #endif
01331
01332 return res;
01333 }
01334
01335 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01336 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, DWORD value)
01337 {
01338 return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_DWORD, &value, sizeof(value));
01339 }
01340
01341 # ifdef STLSOFT_CF_64BIT_INT_SUPPORT
01342 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01343 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, ws_uint64_t value)
01344 {
01345 #ifndef REG_QWORD
01346 const DWORD REG_QWORD = 11;
01347 #endif
01348
01349 return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_QWORD, &value, sizeof(value));
01350 }
01351 # endif
01352
01353 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01354 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, char_type const* value, ws_uint_t type )
01355 {
01356 WINSTL_ASSERT(REG_SZ == type || REG_EXPAND_SZ == type || REG_MULTI_SZ == type);
01357
01358 return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, type, value, traits_type::str_len(value) * sizeof(char_type));
01359 }
01360
01361 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01362 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, ss_typename_type_k basic_reg_key<C, T, A>::char_type const** values, ss_typename_type_k basic_reg_key<C, T, A>::size_type numValues)
01363 {
01364
01365 const size_type totalLen = winstl_ns_qual_std(accumulate)( stlsoft_ns_qual(transformer)(values, std::ptr_fun(traits_type::str_len))
01366 , stlsoft_ns_qual(transformer)(values + numValues, std::ptr_fun(traits_type::str_len))
01367 , size_type(0));
01368
01369
01370 stlsoft_ns_qual(auto_buffer)<char_type> buff(totalLen + numValues * 1 + 2);
01371
01372 if(buff.empty())
01373 {
01374 ::SetLastError(ERROR_NOT_ENOUGH_MEMORY);
01375
01376 return false;
01377 }
01378
01379
01380 char_type *p = &buff[0];
01381
01382 { for(size_type i = 0; i != numValues; ++i)
01383 {
01384 char_type const* s = values[i];
01385 const size_type len = traits_type::str_len(s);
01386
01387 ::memcpy(p, s, sizeof(char_type) * len);
01388 p += len;
01389 *p++ = '\0';
01390 }}
01391 *p++ = '\0';
01392 *p++ = '\0';
01393
01394 return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_MULTI_SZ, buff.data(), static_cast<size_type>(p - &buff[0]) * sizeof(char_type));
01395 }
01396
01397 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01398 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, void const* value, size_type cbValue)
01399 {
01400 return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_BINARY, value, cbValue);
01401 }
01402
01403 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01404 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_int_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, int value, stlsoft_ns_qual(yes_type))
01405 {
01406 return this->set_value(valueName, static_cast<DWORD>(value));
01407 }
01408
01409 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01410 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_int_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, int value, stlsoft_ns_qual(no_type))
01411 {
01412 return this->set_value(valueName, static_cast<ws_uint64_t>(value));
01413 }
01414
01415 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01416 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::set_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName, int value)
01417 {
01418
01419
01420
01421 #if 0
01422 typedef ss_typename_type_k stlsoft_ns_qual(value_to_yesno_type)<sizeof(int) <= sizeof(DWORD)>::type yesno_t;
01423 #else
01424 typedef stlsoft_ns_qual(value_to_yesno_type)<sizeof(int) <= sizeof(DWORD)> value_to_yesno_t;
01425 typedef ss_typename_type_k value_to_yesno_t::type yesno_t;
01426 #endif
01427
01428 return ERROR_SUCCESS == set_value_int_(valueName, value, yesno_t());
01429 }
01430
01431 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01432 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::delete_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName)
01433 {
01434 return this->delete_value_(valueName);
01435 }
01436
01437 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01438 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::delete_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName)
01439 {
01440 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01441 static const char message[] = "could not delete value";
01442 #endif
01443
01444 result_type res = traits_type::reg_delete_value(m_hkey, valueName);
01445
01446 switch(res)
01447 {
01448 case ERROR_SUCCESS:
01449 return true;
01450 default:
01451 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01452 if(ERROR_ACCESS_DENIED == res)
01453 {
01454 STLSOFT_THROW_X(access_denied_exception(message, res));
01455 }
01456 else
01457 {
01458 STLSOFT_THROW_X(registry_exception(message, res));
01459 }
01460 #else
01461 ::SetLastError(res);
01462
01463 #endif
01464 case ERROR_FILE_NOT_FOUND:
01465 return false;
01466 }
01467 }
01468
01469
01470 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01471 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::has_sub_key_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* subKeyName)
01472 {
01473 hkey_type hkey;
01474 result_type res = traits_type::reg_open_key(m_hkey, subKeyName, &hkey, KEY_READ);
01475
01476 switch(res)
01477 {
01478 case ERROR_SUCCESS:
01479 ::RegCloseKey(hkey);
01480 case ERROR_ACCESS_DENIED:
01481 return true;
01482 default:
01483 return false;
01484 }
01485 }
01486
01487 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01488 inline ss_typename_type_ret_k basic_reg_key<C, T, A>::bool_type basic_reg_key<C, T, A>::has_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName)
01489 {
01490 ws_dword_t valueType;
01491 ss_byte_t data[1];
01492 size_type cbData = sizeof(data);
01493 result_type res = traits_type::reg_query_value(m_hkey, valueName, valueType, &data[0], cbData);
01494
01495 switch(res)
01496 {
01497 case ERROR_SUCCESS:
01498 case ERROR_MORE_DATA:
01499 return true;
01500 default:
01501 return false;
01502 }
01503 }
01504
01505 template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
01506 inline basic_reg_value<C, T, A> basic_reg_key<C, T, A>::get_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const* valueName) const
01507 {
01508 return basic_reg_value<C, T, A>(m_hkey, valueName);
01509 }
01510
01511 #endif
01512
01513
01514
01515 #ifndef _WINSTL_NO_NAMESPACE
01516 # if defined(_STLSOFT_NO_NAMESPACE) || \
01517 defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
01518 }
01519 # else
01520 }
01521 }
01522 # endif
01523 #endif
01524
01525 #if defined(STLSOFT_CF_std_NAMESPACE)
01526
01527 namespace std
01528 {
01529 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
01530 inline void swap(winstl_ns_qual(reg_key_a)& lhs, winstl_ns_qual(reg_key_a)& rhs)
01531 {
01532 lhs.swap(rhs);
01533 }
01534 inline void swap(winstl_ns_qual(reg_key_w)& lhs, winstl_ns_qual(reg_key_w)& rhs)
01535 {
01536 lhs.swap(rhs);
01537 }
01538 #endif
01539
01540 }
01541
01542 #endif
01543
01544
01545
01546 #endif
01547
01548