reg_key.hpp

用STL的方式封装了WindowsAPI、COM调用、ACE、ATL、MFC、WTL等多种组件

     *  will be thrown if the value exists but cannot be deleted.
     */
    bool_type   delete_value(char_type const *valueName);
#ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
    /** \brief Deletes the named value.
     *
     * \param valueName The name of the value to be deleted.
     *
     * \return Indicates whether the value was deleted.
     * \retval true The value existed and was successfully deleted.
     * \retval false The value does not exist. (<b>Note</b>:
     *  if \ref page__exception_agnostic "exception handling is not enabled",
     *  then false will also be returned for any other reason, and the
     *  reason will be available via <code>::GetLastError()</code>.)
     *
     * \exception registry_exception If \ref page__exception_agnostic "exception handling is enabled",
     *  an instance of \link winstl::registry_exception registry_exception\endlink
     *  will be thrown if the value exists but cannot be deleted.
     */
    template <ss_typename_param_k S>
    bool_type   delete_value(S const &valueName)
    {
        return this->delete_value_(stlsoft_ns_qual(c_str_ptr)(valueName));
    }
#endif /* STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT */

#if 0
    ws_dword_t      get_value_type(char_type const *valueName) const;
    size_type       get_value_data_size(char_type const *valueName) const;
#endif /* 0 */

    /** \brief Returns the named value.
    ///
    /// \return An instance of basic_reg_value.
     */
    key_value_type              get_value(char_type const *valueName) const;
#ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
    /** \brief Returns the named value.
    ///
    /// \return An instance of basic_reg_value.
     */
    template <ss_typename_param_k S>
    key_value_type              get_value(S const &valueName) const
    {
        return this->get_value(stlsoft_ns_qual(c_str_ptr)(stlsoft_ns_qual(c_str_ptr)(valueName)));
    }
#endif /* STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT */
//  std::list<key_value_type>   get_values(char_type const *valueNames) const;
/// @}

/// \name Implementation
/// @{
private:
    static hkey_type    open_key_(  hkey_type       hkeyParent
                                ,   char_type const *keyName
                                ,   REGSAM          accessMask);
    class_type  open_sub_key_(      char_type const *subKeyName
                                ,   REGSAM          accessMask);
    class_type  create_sub_key_(    char_type const *subKeyName
                                ,   REGSAM          accessMask);
    bool_type   delete_sub_key_(    char_type const *subKeyName);
    static result_type  set_value_( hkey_type       hkey
                                ,   char_type const *valueName
                                ,   ws_uint_t       type
                                ,   void const      *value
                                ,   size_type       cbValue);

    bool_type   set_value_int_(char_type const *valueName, int value, stlsoft_ns_qual(yes_type));
    bool_type   set_value_int_(char_type const *valueName, int value, stlsoft_ns_qual(no_type));

    bool_type   set_value_(char_type const *valueName, DWORD value);
#  ifdef STLSOFT_CF_64BIT_INT_SUPPORT
    bool_type   set_value_(char_type const *valueName, ws_uint64_t value);
#  endif /* STLSOFT_CF_64BIT_INT_SUPPORT */
    bool_type   set_value_(char_type const *valueName, char_type const *value, ws_uint_t type);
    bool_type   set_value_(char_type const *valueName, char_type const **values, size_type numValues);
    bool_type   set_value_(char_type const *valueName, void const *value, size_type cbValue);
    bool_type   set_value_(char_type const *valueName, int value);

    bool_type   delete_value_(char_type const *valueName);

    static result_type  get_value_(hkey_type hkey, char_type const *valueName, ws_uint_t type, void *value, size_type *pcbValue);

    static hkey_type    dup_key_(   hkey_type       hkey
                                ,   REGSAM          accessMask  =   KEY_ALL_ACCESS);
/// @}

/// \name Operations
/// @{
public:
    /** \brief Efficiently swaps the contents between two instances
    ///
    /// \param rhs The parameter whose contents will be swapped.
     */
    void    swap(class_type &rhs) stlsoft_throw_0();
/// @}

/// \name Members
/// @{
private:
    hkey_type   m_hkey;         // The key handle
    string_type m_name;         // The key name
    REGSAM      m_accessMask;   // The security access mask
/// @}
};

/* Typedefs to commonly encountered types. */
/// Instantiation of the basic_reg_key template for the ANSI character type \c char
typedef basic_reg_key<ws_char_a_t, reg_traits<ws_char_a_t>, processheap_allocator<ws_char_a_t> >    reg_key_a;
/// Instantiation of the basic_reg_key template for the Unicode character type \c wchar_t
typedef basic_reg_key<ws_char_w_t, reg_traits<ws_char_w_t>, processheap_allocator<ws_char_w_t> >    reg_key_w;
/// Instantiation of the basic_reg_key template for the Win32 character type \c TCHAR
typedef basic_reg_key<TCHAR, reg_traits<TCHAR>, processheap_allocator<TCHAR> >                      reg_key;

/* /////////////////////////////////////////////////////////////////////////
 * Handle access shims
 */

/* get_handle */

/** \brief [\ref group__concept__shims "Shim" function] Returns the corresponding registry handle of an instance of \link winstl::basic_reg_key basic_reg_key\endlink.
 *
 * \ingroup group__library__windows_registry
 *
 * \param key The \link winstl::basic_reg_key basic_reg_key\endlink instance.
 *
 * \return The HKEY handle of the given \link winstl::basic_reg_key basic_reg_key\endlink instance.
 */
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline HKEY get_handle(basic_reg_key<C, T, A> const &key)
{
    return key.get_key_handle();
}

////////////////////////////////////////////////////////////////////////////
// Unit-testing

#ifdef STLSOFT_UNITTEST
# include "./unittest/reg_key_unittest_.h"
#endif /* STLSOFT_UNITTEST */

/* /////////////////////////////////////////////////////////////////////////
 * Implementation
 */

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
#if (   defined(STLSOFT_COMPILER_IS_MSVC) && \
        _MSC_VER < 1100) || \
    defined(STLSOFT_COMPILER_IS_VECTORC)
inline /* static */ ss_typename_type_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)
#else /* ? compiler */
inline /* static */ ss_typename_type_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)
#endif /* compiler */
{
    hkey_type   hkey;
    result_type res = traits_type::reg_open_key(hkeyParent, keyName, &hkey, accessMask);

    if(ERROR_SUCCESS != res)
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        throw registry_exception("Could not open key", static_cast<DWORD>(res));
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        ::SetLastError(res);
        hkey = NULL;
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }

    return hkey;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline /* static */ ss_typename_type_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
                                                                                                        ,   REGSAM                                                  accessMask /* = KEY_ALL_ACCESS */)
{
    result_type res;
    HKEY        hkeyDup =   traits_type::key_dup(hkey, accessMask, &res);

    if(ERROR_SUCCESS != res)
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        throw registry_exception("Could not duplicate key", res);
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        ::SetLastError(res);
        hkeyDup = NULL;
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }

    return hkeyDup;
}

// Construction
template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key<C, T, A>::basic_reg_key()
    : m_hkey(NULL)
    , m_accessMask(KEY_READ)
{}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
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)
    : m_hkey(*hkey)
    , m_name(keyName)
    , m_accessMask(accessMask)
{}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key<C, T, A>::basic_reg_key(class_type const &rhs)
    : m_hkey(dup_key_(rhs.m_hkey, rhs.get_access_mask()))
    , m_name(rhs.m_name)
    , m_accessMask(rhs.m_accessMask)
{}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key<C, T, A>::basic_reg_key(class_type const &rhs, REGSAM accessMask)
    : m_hkey(dup_key_(rhs.m_hkey, accessMask))
    , m_name(rhs.m_name)
    , m_accessMask(accessMask)
{}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key<C, T, A>::~basic_reg_key() stlsoft_throw_0()
{
    if(m_hkey != NULL)
    {
        ::RegCloseKey(m_hkey);
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
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()
{
    std_swap(m_name,        rhs.m_name);
    std_swap(m_hkey,        rhs.m_hkey);
    std_swap(m_accessMask,  rhs.m_accessMask);
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_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)
{
    class_type  _this(rhs);

    swap(_this);

    return *this;
}

// Attributes
template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key<C, T, A>::string_type const &basic_reg_key<C, T, A>::name() const
{
    return m_name;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key<C, T, A>::string_type basic_reg_key<C, T, A>::reg_class() const
{
    size_type   cch_key_class   =   0;
    ws_long_t   res             =   traits_type::reg_query_info(m_hkey, NULL, &cch_key_class, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);

    if(ERROR_SUCCESS == res)
    {
        stlsoft_ns_qual(auto_buffer_old)<char_type, allocator_type, CCH_REG_API_AUTO_BUFFER>  p(++cch_key_class);

        res = traits_type::reg_query_info(m_hkey, &p[0], &cch_key_class, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);

        if(ERROR_SUCCESS == res)
        {
            return string_type(&p[0], cch_key_class);
        }
    }

    return string_type();
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key<C, T, A>::size_type basic_reg_key<C, T, A>::num_sub_keys() const
{
    size_type   c_sub_keys;
    ws_long_t   res         =   traits_type::reg_query_info(m_hkey, NULL, NULL, &c_sub_keys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);

    if(ERROR_SUCCESS != res)
    {
        c_sub_keys = 0;
    }

    return c_sub_keys;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key<C, T, A>::size_type basic_reg_key<C, T, A>::num_values() const
{
    size_type   c_values;
    ws_long_t   res         =   traits_type::reg_query_info(m_hkey, NULL, NULL, NULL, NULL, NULL, &c_values, NULL, NULL, NULL, NULL);

    if(ERROR_SUCCESS != res)
    {
        c_values = 0;
    }

    return c_values;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key<C, T, A>::hkey_type basic_reg_key<C, T, A>::get_key_handle() const
{
    return m_hkey;