reg_key.hpp

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

}

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() const
{
    return get_key_handle();
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline REGSAM basic_reg_key<C, T, A>::get_access_mask() const
{
    return m_accessMask;
}

// Operations
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>::open_sub_key(char_type const *subKeyName, REGSAM accessMask /* = KEY_ALL_ACCESS */)
{
    return this->open_sub_key_(subKeyName, 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>::create_sub_key(char_type const *subKeyName, REGSAM accessMask /* = KEY_ALL_ACCESS */)
{
    return this->create_sub_key_(subKeyName, 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>::open_sub_key_(char_type const *subKeyName, REGSAM accessMask /* = KEY_ALL_ACCESS */)
{
    return class_type(m_hkey, subKeyName, 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>::create_sub_key_(char_type const *subKeyName, REGSAM accessMask)
{
    hkey_type   hkey;
    result_type res =   traits_type::reg_create_key(m_hkey, subKeyName, &hkey, accessMask);

    if(ERROR_SUCCESS != res)
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        throw registry_exception("Could not create sub-key", static_cast<DWORD>(res));
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        ::SetLastError(res);
        return class_type();
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }

    return class_type(&hkey, subKeyName, 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>::bool_type basic_reg_key<C, T, A>::delete_sub_key(char_type const *subKeyName)
{
    return this->delete_sub_key_(subKeyName);
}

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>::bool_type basic_reg_key<C, T, A>::delete_sub_key_(char_type const *subKeyName)
{
    result_type res = traits_type::reg_delete_key(m_hkey, subKeyName);

    switch(res)
    {
        case    ERROR_SUCCESS:
            return true;
        default:
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
            throw registry_exception("Could not delete sub-key", res);
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
            ::SetLastError(res);
            // Fall through
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
        case    ERROR_FILE_NOT_FOUND:
            return false;
    }
}


/* The handle returned from this method MUST be closed with RegCloseKey() */
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>::dup_key_handle(REGSAM accessMask /* = KEY_ALL_ACCESS */, result_type *result /* = NULL */)
{
    return traits_type::key_dup(m_hkey, accessMask, result);
}

// 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>::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)
{
    return set_value_(valueName, value);
}

#  ifdef STLSOFT_CF_64BIT_INT_SUPPORT
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>::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)
{
    return set_value_(valueName, value);
}
#  endif /* STLSOFT_CF_64BIT_INT_SUPPORT */

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>::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)
{
    return set_value_(valueName, value);
}

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>::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 /* = REG_SZ */)
{
    return set_value_(valueName, value, 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>::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)
{
    return set_value_(valueName, values, numValues);
}

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>::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)
{
    return set_value_(valueName, value, cbValue);
}



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>::result_type basic_reg_key<C, T, A>::set_value_(  ss_typename_type_k basic_reg_key<C, T, A>::hkey_type        hkey
                                                                                                            ,   ss_typename_type_k basic_reg_key<C, T, A>::char_type const  *valueName
                                                                                                            ,   ws_uint_t                                                   type
                                                                                                            ,   void const                                                  *value
                                                                                                            ,   ss_typename_type_k basic_reg_key<C, T, A>::size_type        cbValue)
{
    result_type res =   traits_type::reg_set_value(hkey, valueName, type, value, cbValue);

#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    if(ERROR_SUCCESS != res)
    {
        throw registry_exception("Could not create value", static_cast<DWORD>(res));
    }
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */

    return res;
}

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>::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)
{
    return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_DWORD, &value, sizeof(value));
}

#  ifdef STLSOFT_CF_64BIT_INT_SUPPORT
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>::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)
{
#ifndef REG_QWORD
    const DWORD REG_QWORD   =   11;
#endif /* !REG_QWORD */

    return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_QWORD, &value, sizeof(value));
}
#  endif /* STLSOFT_CF_64BIT_INT_SUPPORT */

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>::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 /* = REG_SZ */)
{
    WINSTL_ASSERT(REG_SZ == type || REG_EXPAND_SZ == type || REG_MULTI_SZ == type);

    return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, type, value, traits_type::str_len(value) * sizeof(char_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>::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)
{
    const size_type totalLen    =   winstl_ns_qual_std(accumulate)( stlsoft_ns_qual(transformer)(values, std::ptr_fun(traits_type::str_len))
                                                                ,   stlsoft_ns_qual(transformer)(values + numValues, std::ptr_fun(traits_type::str_len))
                                                                ,   size_type(0));

    stlsoft_ns_qual(auto_buffer)<char_type> buff(totalLen + numValues * 1 + 2);

    if(buff.empty())
    {
        ::SetLastError(ERROR_NOT_ENOUGH_MEMORY);

        return false;
    }

    char_type   *p  =   &buff[0];

    for(size_type i = 0; i < numValues; ++i)
    {
        char_type const *s  =   values[i];
        const size_type len =   traits_type::str_len(s);

        traits_type::str_n_copy(p, s, len + 1);
        p += len + 1;
    }
    *p++ = '\0';
    *p++ = '\0';

    return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_MULTI_SZ, buff.data(), static_cast<size_type>(p - &buff[0]));
}

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>::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)
{
    return ERROR_SUCCESS == class_type::set_value_(m_hkey, valueName, REG_BINARY, value, cbValue);
}

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>::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))
{
    return this->set_value(valueName, static_cast<DWORD>(value));
}

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>::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))
{
    return this->set_value(valueName, static_cast<ws_uint64_t>(value));
}

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>::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)
{
    // Because Borland is quite dense, we must use two typedefs here,
    // rather than just one

#if 0
    typedef ss_typename_type_k stlsoft_ns_qual(value_to_yesno_type)<sizeof(int) <= sizeof(DWORD)>::type yesno_t;
#else /* ? 0 */
    typedef stlsoft_ns_qual(value_to_yesno_type)<sizeof(int) <= sizeof(DWORD)>  value_to_yesno_t;
    typedef ss_typename_type_k value_to_yesno_t::type                           yesno_t;
#endif /* 0 */

    return ERROR_SUCCESS == set_value_int_(valueName, value, yesno_t());
}

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>::bool_type basic_reg_key<C, T, A>::delete_value(ss_typename_type_k basic_reg_key<C, T, A>::char_type const *valueName)
{
    return this->delete_value_(valueName);
}

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>::bool_type basic_reg_key<C, T, A>::delete_value_(ss_typename_type_k basic_reg_key<C, T, A>::char_type const *valueName)
{
    result_type res = traits_type::reg_delete_value(m_hkey, valueName);

    switch(res)
    {
        case    ERROR_SUCCESS:
            return true;
        default:
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
            throw registry_exception("Could not delete value", static_cast<DWORD>(res));
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
            ::SetLastError(res);
            // Fall through
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
        case    ERROR_FILE_NOT_FOUND:
            return false;
    }
}


template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
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
{
    return basic_reg_value<C, T, A>(m_hkey, valueName);
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* ////////////////////////////////////////////////////////////////////// */

#ifndef _WINSTL_NO_NAMESPACE
# if defined(_STLSOFT_NO_NAMESPACE) || \
     defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
} // namespace winstl
# else
} // namespace winstl_project
} // namespace stlsoft
# endif /* _STLSOFT_NO_NAMESPACE */
#endif /* !_WINSTL_NO_NAMESPACE */

#if defined(STLSOFT_CF_std_NAMESPACE)

namespace std
{
#if !defined(STLSOFT_COMPILER_IS_BORLAND)
    inline void swap(winstl_ns_qual(reg_key_a) &lhs, winstl_ns_qual(reg_key_a) &rhs)
    {
        lhs.swap(rhs);
    }
    inline void swap(winstl_ns_qual(reg_key_w) &lhs, winstl_ns_qual(reg_key_w) &rhs)
    {
        lhs.swap(rhs);
    }
#endif /* compiler */

} // anonymous namespace

#endif /* STLSOFT_CF_std_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* WINSTL_INCL_WINSTL_REGISTRY_HPP_REG_KEY */

/* ////////////////////////////////////////////////////////////////////// */