enumerators.hpp

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

    }
/// @}

/// \name Members
/// @{
private:
    values_type     m_values;
    const_iterator  m_current;
/// @}

/// \name Not to be implemented
/// @{
private:
    copy_enumerator_impl(class_type const &);
    class_type &operator =(class_type const &);
/// @}
};

#if defined(STLSOFT_COMPILER_IS_INTEL) || \
    defined(STLSOFT_COMPILER_IS_MSVC)
# if _MSC_VER >= 1200
#  pragma warning(push)
# endif /* compiler */
# pragma warning(disable : 4348)
#endif /* compiler */

// class copy_enumerator
template<   ss_typename_param_k I                                   // Enumerator interface
        ,   IID const           *piid                               // Enumerator interface Id
        ,   ss_typename_param_k V                                   // Enumerator interface value type
        ,   ss_typename_param_k IV      =   V                       // Internal type
        ,   ss_typename_param_k I2ETx   =   copy_policy<IV, V>      // Internal to external transformation policy
        ,   ss_typename_param_k TM      =   CComObjectThreadModel   // Thread model
        >
class ATL_NO_VTABLE copy_enumerator
    : public copy_enumerator_impl<I, piid, V, IV, I2ETx>
    , public CComObjectRootEx<TM>
{
public:
    typedef copy_enumerator<I, piid, V, IV, I2ETx, TM>      class_type;
private:
    typedef copy_enumerator_impl<I, piid, V, IV, I2ETx>     impl_type_;

public:
    BEGIN_COM_MAP(class_type)
        COM_INTERFACE_ENTRY_IID(*piid, impl_type_)
    END_COM_MAP()

protected:
    virtual impl_type_ *CreateEmptyClone() const
    {
        return new CComObject<class_type>;
    }
};

#if defined(STLSOFT_COMPILER_IS_INTEL) || \
    defined(STLSOFT_COMPILER_IS_MSVC)
# if _MSC_VER >= 1200
#  pragma warning(pop)
# else /* ? compiler */
#  pragma warning(default: 4348)
# endif /* _MSC_VER */
#endif /* compiler */

////////////////////////////////////////////////////////////////////////////
// Implementation

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline copy_enumerator_impl<I, piid, V, IV, I2ETx>::copy_enumerator_impl()
    : m_values()
    , m_current(m_values.begin())
{}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline copy_enumerator_impl<I, piid, V, IV, I2ETx>::~copy_enumerator_impl() stlsoft_throw_0()
{}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Next(ULONG celt, V *rgelt, ULONG *pceltFetched)
{
    HRESULT hr;

    if( rgelt == NULL ||
        (   celt != 1 &&
            pceltFetched == NULL))
    {
        hr = E_POINTER;
    }
    else
    {
        ULONG   celtFetched_;

        if(NULL == pceltFetched)
        {
            pceltFetched = &celtFetched_;
        }

        { for(*pceltFetched = 0, hr = S_OK; /* SUCCEEDED(hr) && */ celt > 0 && m_current != m_values.end(); --celt, ++m_current, ++rgelt, ++*pceltFetched)
        {
            internal_to_external_transformer_type::init(rgelt);
            hr = internal_to_external_transformer_type::copy(rgelt, *m_current);

            if(FAILED(hr))
            {
                break;
            }
        }}

        if(FAILED(hr))
        {
            for(; 0 != *pceltFetched; --*pceltFetched)
            {
                internal_to_external_transformer_type::clear(--rgelt);
            }
        }

        if(SUCCEEDED(hr))
        {
            hr = (0 == celt) ? S_OK : S_FALSE;
        }
    }

    return hr;
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Skip(ULONG celt)
{
    { for(; celt > 0 && m_current == m_values.end(); --celt, ++m_current)
    {
    }}

    return (0 == celt) ? S_OK : S_FALSE;
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Reset(void)
{
    m_current == m_values.begin();

    return S_OK;
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline STDMETHODIMP copy_enumerator_impl<I, piid, V, IV, I2ETx>::Clone(I** ppEnum)
{
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    try
    {
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
        if(NULL == ppEnum)
        {
            return E_POINTER;
        }
        else
        {
            *ppEnum = NULL;

            HRESULT     hr;
            class_type  *pThis  =   this;
            class_type  *p      =   pThis->CreateEmptyClone();

            if(p == NULL)
            {
                hr = E_OUTOFMEMORY;
            }
            else
            {
                stlsoft::ref_ptr<class_type, I>     en(p, true);    // Sink the instance, with a bumped (to 1) ref-count

                hr = p->Init(this->begin(), this->end());

                if(SUCCEEDED(hr))
                {
                    const_iterator  begin   =   this->m_values.begin();
                    const_iterator  current =   this->m_current;

                    std::advance(p->m_current, std::distance(begin, current));

                    hr = en->QueryInterface(*piid, reinterpret_cast<void**>(ppEnum));
                }
            }

            return hr;
        }
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    }
    catch(std::bad_alloc &)
    {
        return E_OUTOFMEMORY;
    }
    catch(std::exception &)
    {
        return E_UNEXPECTED;
    }
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline ss_size_t copy_enumerator_impl<I, piid, V, IV, I2ETx>::size() const
{
    return m_values.size();
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline ss_typename_type_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::const_iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::begin() const
{
    return m_values.begin();
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline ss_typename_type_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::begin()
{
    return m_values.begin();
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline ss_typename_type_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::const_iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::end() const
{
    return m_values.end();
}

template<   ss_typename_param_k I
        ,   IID const           *piid
        ,   ss_typename_param_k V
        ,   ss_typename_param_k IV
        ,   ss_typename_param_k I2ETx
        >
inline ss_typename_type_k copy_enumerator_impl<I, piid, V, IV, I2ETx>::iterator copy_enumerator_impl<I, piid, V, IV, I2ETx>::end()
{
    return m_values.end();
}

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

#ifndef _ATLSTL_NO_NAMESPACE
# if defined(_STLSOFT_NO_NAMESPACE) || \
     defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
} // namespace atlstl
# else
} // namespace atlstl_project
} // namespace stlsoft
# endif /* _STLSOFT_NO_NAMESPACE */
#endif /* !_ATLSTL_NO_NAMESPACE */

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

#endif /* ATLSTL_INCL_ATLSTL_HPP_ENUMERATORS */

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