reg_key_sequence.hpp

新版本TR1的stl

                                                            ,   ss_typename_type_k basic_reg_key_sequence<C, T, A>::char_type const*    sub_key_name
                                                            ,   REGSAM                                                                  accessMask /* = KEY_READ */)
    : m_hkey(NULL)
    , m_accessMask(accessMask)
    , m_bMonitorExternalInvalidation(0 != (KEY_NOTIFY & accessMask))
{
    result_type result;

    if(ERROR_SUCCESS != (result = traits_type::reg_open_key(hkey, sub_key_name, &m_hkey, accessMask)))
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        STLSOFT_THROW_X(registry_exception("Could not open key", result));
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        m_hkey = NULL;
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key_sequence<C, T, A>::basic_reg_key_sequence( ss_typename_type_k basic_reg_key_sequence<C, T, A>::hkey_type       hkey
                                                            ,   ss_typename_type_k basic_reg_key_sequence<C, T, A>::char_type const* sub_key_name
                                                            ,   REGSAM                                                              accessMask
                                                            ,   ss_typename_type_k basic_reg_key_sequence<C, T, A>::bool_type       bMonitorExternalInvalidation)
    : m_hkey(NULL)
    , m_accessMask(validate_access_mask_(accessMask, bMonitorExternalInvalidation))
    , m_bMonitorExternalInvalidation(bMonitorExternalInvalidation)
{
    result_type result;

    if(ERROR_SUCCESS != (result = traits_type::reg_open_key(hkey, sub_key_name, &m_hkey, accessMask)))
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        STLSOFT_THROW_X(registry_exception("Could not open key", result));
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        m_hkey = NULL;
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key_sequence<C, T, A>::basic_reg_key_sequence(ss_typename_type_k basic_reg_key_sequence<C, T, A>::reg_key_type const& key)
    : m_hkey(dup_key_(key.m_hkey, key.get_access_mask()))
    , m_accessMask(key.get_access_mask())
    , m_bMonitorExternalInvalidation(0 != (KEY_NOTIFY & key.get_access_mask()))
{
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    if(NULL == m_hkey)
    {
        STLSOFT_THROW_X(registry_exception("Failed to take duplicate of key", ::GetLastError()));
    }
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key_sequence<C, T, A>::basic_reg_key_sequence( ss_typename_type_k basic_reg_key_sequence<C, T, A>::reg_key_type const  &key
                                                            ,   REGSAM                                                                  accessMask)
    : m_hkey(dup_key_(key.m_hkey, accessMask))
    , m_accessMask(accessMask)
    , m_bMonitorExternalInvalidation(0 != (KEY_NOTIFY & accessMask))
{
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    if(NULL == m_hkey)
    {
        STLSOFT_THROW_X(registry_exception("Failed to take duplicate of key", ::GetLastError()));
    }
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key_sequence<C, T, A>::basic_reg_key_sequence( ss_typename_type_k basic_reg_key_sequence<C, T, A>::reg_key_type const  &key
                                                            ,   REGSAM                                                                  accessMask
                                                            ,   bool_type                                                               bMonitorExternalInvalidation)
    : m_hkey(dup_key_(key.m_hkey, validate_access_mask_(accessMask, bMonitorExternalInvalidation)))
    , m_accessMask(validate_access_mask_(accessMask, bMonitorExternalInvalidation))
    , m_bMonitorExternalInvalidation(bMonitorExternalInvalidation)
{
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    if(NULL == m_hkey)
    {
        STLSOFT_THROW_X(registry_exception("Failed to take duplicate of key", ::GetLastError()));
    }
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline basic_reg_key_sequence<C, T, A>::~basic_reg_key_sequence() 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 ss_typename_type_k basic_reg_key_sequence<C, T, A>::iterator basic_reg_key_sequence<C, T, A>::begin()
{
    // 1. Check that there are some items
    //
    // 2. Duplicate the registry key handle & Create the shared handle
    //
    // 4. Loop to get the full name
    //
    // 5. Create the iterator and return


    // 1. Check that there are some items

    // Grab enough for the first item
    size_type   cchName     =   0;
    size_type   numEntries  =   0;
    result_type res         =   traits_type::reg_query_info(m_hkey, NULL, NULL, &numEntries, &cchName, NULL, NULL, NULL, NULL, NULL, NULL);

    if(ERROR_SUCCESS != res)
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        if(ERROR_ACCESS_DENIED == res)
        {
            STLSOFT_THROW_X(access_denied_exception("Could not elicit sub-key information", static_cast<DWORD>(res)));
        }
        else
        {
            STLSOFT_THROW_X(registry_exception("Could not elicit sub-key information", static_cast<DWORD>(res)));
        }
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        ; // This will fall through to the end() call at the end of the function
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }
    else
    {
        if(0 != numEntries)
        {
            // 2. Duplicate the registry key handle & create the shared handle
            registry_util::shared_handle    *handle =   create_shared_handle_(res);
            ws_sint32_t                     index   =   0;

            if(NULL == handle)
            {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
                STLSOFT_THROW_X(registry_exception("Failed to create shared enumeration context", static_cast<DWORD>(res)));
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
                ; // This will fall through to the end() call at the end of the function
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
            }
            else
            {
                ref_ptr<registry_util::shared_handle>   ref(handle, false); // Eat the reference here. The iterator will take another

                // 4. Loop to get the full name
                buffer_type_    buffer(++cchName);   // This is increased so that the call to reg_enum_key is likely to succeed

                for(; !buffer.empty(); )    // Need to loop because sub-keys can change, when we're not monitoring
                {
                    cchName  =   buffer.size();

                    res = traits_type::reg_enum_key(m_hkey, 0, &buffer[0], &cchName);

                    if(ERROR_MORE_DATA == res)
                    {
                        if(!buffer.resize(2 * buffer.size())) // Throws, or returns false
                        {
                            cchName =   0;
                            index   =   const_iterator::sentinel_();
                            break;
                        }

                        continue; // "Let's go round again"
                    }
                    else if(ERROR_SUCCESS != res)
                    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
                        if(ERROR_ACCESS_DENIED == res)
                        {
                            STLSOFT_THROW_X(access_denied_exception("Could not enumerate sub-keys", static_cast<DWORD>(res)));
                        }
                        else
                        {
                            STLSOFT_THROW_X(registry_exception("Could not enumerate sub-keys", static_cast<DWORD>(res)));
                        }
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
                        cchName = 0;
                        index   =   const_iterator::sentinel_();
                        break; // This will fall through to the end() call at the end of the function
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
                    }
                    else
                    {
                        break;
                    }
                }

                // 5. Create the iterator and return
                return iterator(handle, buffer.data(), cchName, index, m_accessMask);
            }
        }
    }

    return end();
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key_sequence<C, T, A>::iterator basic_reg_key_sequence<C, T, A>::end()
{
    result_type                             res;
    registry_util::shared_handle            *handle =   create_shared_handle_(res);
    ref_ptr<registry_util::shared_handle>   ref(handle, false); // Eat the reference here. The iterator will take another
    ws_sint32_t                             index   =   const_iterator::sentinel_();

    if(NULL == handle)
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        STLSOFT_THROW_X(registry_exception("Failed to take duplicate of key", static_cast<DWORD>(res)));
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        index = 0; // This will fall through to the constructor at the end of the function
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }

    return iterator(handle, NULL, 0, index, m_accessMask);
}

#if defined(STLSOFT_CF_BIDIRECTIONAL_ITERATOR_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_sequence<C, T, A>::reverse_iterator basic_reg_key_sequence<C, T, A>::rbegin()
{
    return reverse_iterator(end());
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key_sequence<C, T, A>::reverse_iterator basic_reg_key_sequence<C, T, A>::rend()
{
    return reverse_iterator(begin());
}
#endif /* STLSOFT_CF_BIDIRECTIONAL_ITERATOR_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_sequence<C, T, A>::size_type basic_reg_key_sequence<C, T, A>::size() const
{
    return current_size();
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key_sequence<C, T, A>::size_type basic_reg_key_sequence<C, T, A>::current_size() const
{
    ws_uint_t   numEntries;
    result_type res = traits_type::reg_query_info(m_hkey, NULL, NULL, &numEntries, NULL, NULL, NULL, NULL, NULL, NULL, NULL);

    if(ERROR_SUCCESS != res)
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        if(ERROR_ACCESS_DENIED == res)
        {
            STLSOFT_THROW_X(access_denied_exception("Could not elicit sub-key information", static_cast<DWORD>(res)));
        }
        else
        {
            STLSOFT_THROW_X(registry_exception("Could not elicit number of sub-keys", static_cast<DWORD>(res)));
        }
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        numEntries = 0;
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }

    return static_cast<size_type>(numEntries);
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ws_bool_t basic_reg_key_sequence<C, T, A>::empty() const
{
    return 0 == size();
}

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

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key_sequence<C, T, A>::hkey_type basic_reg_key_sequence<C, T, A>::get() const
{
    return get_key_handle();
}


// basic_reg_key_sequence_iterator

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline /* static */ ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::index_type basic_reg_key_sequence_iterator<C, T, V, A>::sentinel_() stlsoft_throw_0()
{
    return 0x7fffffff;
}