reg_key_sequence.hpp

新版本TR1的stl

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline basic_reg_key_sequence_iterator<C, T, V, A>::basic_reg_key_sequence_iterator()
    : m_handle(NULL)
    , m_index(sentinel_())
    , m_name()
    , m_accessMask(KEY_READ)
{}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline basic_reg_key_sequence_iterator<C, T, V, A>::basic_reg_key_sequence_iterator(class_type const& rhs)
    : m_handle(rhs.m_handle)
    , m_index(rhs.m_index)
    , m_name(rhs.m_name)
    , m_accessMask(rhs.m_accessMask)
{
    if(NULL != m_handle)
    {
        m_handle->AddRef();
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::class_type &basic_reg_key_sequence_iterator<C, T, V, A>::operator =(ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::class_type const& rhs)
{
    registry_util::shared_handle   *this_handle;

    m_index         =   rhs.m_index;
    m_name          =   rhs.m_name;

    this_handle     =   m_handle;
    m_handle        =   rhs.m_handle;
    m_accessMask    =   rhs.m_accessMask;

    if(NULL != m_handle)
    {
        m_handle->AddRef();
    }

    if(NULL != this_handle)
    {
        this_handle->Release();
    }

    return *this;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline basic_reg_key_sequence_iterator<C, T, V, A>::~basic_reg_key_sequence_iterator() stlsoft_throw_0()
{
    if(NULL != m_handle)
    {
        m_handle->Release();
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline const ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::string_type &basic_reg_key_sequence_iterator<C, T, V, A>::get_key_name() const
{
    return m_name;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::class_type &basic_reg_key_sequence_iterator<C, T, V, A>::operator ++()
{
    WINSTL_MESSAGE_ASSERT("Attempting to increment an invalid iterator!", NULL != m_handle);
    WINSTL_MESSAGE_ASSERT("Attempting to increment an invalid iterator!", sentinel_() != m_index);

    // Grab enough for the first item
    size_type   cchName =   0;
    result_type res     =   traits_type::reg_query_info(m_handle->m_hkey, NULL, NULL, NULL, &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 */
        m_index = sentinel_();
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }
    else
    {
        buffer_type_    buffer(++cchName);   // This is increased so that the call to reg_enum_key is likely to succeed

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

            res = traits_type::reg_enum_key(m_handle->m_hkey, static_cast<ws_dword_t>(1 + m_index), &buffer[0], &cchName);

            if(ERROR_MORE_DATA == res)
            {
                continue; // "Let's go round again"
            }
            else if(ERROR_NO_MORE_ITEMS == res)
            {
                m_index = sentinel_();
                break;
            }
            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 */
                m_index = sentinel_();
                break;
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
            }
            else
            {
                m_name.assign(buffer.data(), cchName);

                ++m_index;

                break;
            }
        }
    }

    m_handle->test_reset_and_throw();

    return *this;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::class_type &basic_reg_key_sequence_iterator<C, T, V, A>::operator --()
{
    WINSTL_MESSAGE_ASSERT("Attempting to decrement an invalid iterator", NULL != m_handle);

    // Grab enough for the first item
    size_type   cchName     =   0;
    size_type   numEntries  =   0;
    result_type res         =   traits_type::reg_query_info(m_handle->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 */
        m_index = sentinel_();
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }
    else
    {
        buffer_type_    buffer(++cchName);   // This is increased so that the call to reg_enum_key is likely to succeed
        ws_dword_t      index;

        // If the iterator is currently at the "end()", ...
        if(m_index == sentinel_())
        {
            // ... then set the index to be one past the end
            index = numEntries - 1;
        }
        else
        {
            // ... otherwise just go back one from current
            index = m_index - 1;
        }

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

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

            if(ERROR_MORE_DATA == res)
            {
                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 elicit sub-key information", static_cast<DWORD>(res)));
                }
                else
                {
                    STLSOFT_THROW_X(registry_exception("Could not enumerate sub-keys", static_cast<DWORD>(res)));
                }
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
                m_index = sentinel_();
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
            }
            else
            {
                m_name.assign(buffer.data(), cchName);

                m_index = index;

                break;
            }
        }
    }

    m_handle->test_reset_and_throw();

    return *this;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline const ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::class_type basic_reg_key_sequence_iterator<C, T, V, A>::operator ++(int)
{
    class_type  ret(*this);

    operator ++();

    return ret;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline const ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::class_type basic_reg_key_sequence_iterator<C, T, V, A>::operator --(int)
{
    class_type  ret(*this);

    operator --();

    return ret;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline const ss_typename_type_k basic_reg_key_sequence_iterator<C, T, V, A>::value_type basic_reg_key_sequence_iterator<C, T, V, A>::operator *() const
{
    WINSTL_MESSAGE_ASSERT("Attempting to dereference an invalid iterator", NULL != m_handle);

    m_handle->test_reset_and_throw();

    return value_type(m_handle->m_hkey, m_name, m_accessMask);
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline ws_bool_t basic_reg_key_sequence_iterator<C, T, V, A>::equal(class_type const& rhs) const
{
    return m_index == rhs.m_index;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline ws_bool_t basic_reg_key_sequence_iterator<C, T, V, A>::operator ==(class_type const& rhs) const
{
    return equal(rhs);
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V, ss_typename_param_k A>
inline ws_bool_t basic_reg_key_sequence_iterator<C, T, V, A>::operator !=(class_type const& rhs) const
{
    return !equal(rhs);
}

#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 */

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

#endif /* WINSTL_INCL_WINSTL_REGISTRY_HPP_REG_KEY_SEQUENCE */

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