#include <atlcom.h>

Inheritance diagram for ATL::CComEnumImpl< Base, piid, T, Copy >:

Collaboration diagram for ATL::CComEnumImpl< Base, piid, T, Copy >:

[legend]

Public Member Functions
	CComEnumImpl ()

virtual	~CComEnumImpl ()

HRESULT	Init (T begin, T end, IUnknown *pUnk, CComEnumFlags flags=AtlFlagNoCopy)

STDMETHOD()	Next (ULONG celt, T rgelt, ULONG pceltFetched)

STDMETHOD()	Skip (ULONG celt)

STDMETHOD()	Reset ()

STDMETHOD()	Clone (Base **ppEnum)

Public Attributes
CComPtr< IUnknown >	m_spUnk

DWORD	m_dwFlags

T *	m_begin

T *	m_end

T *	m_iter

Protected Types
enum	FlagBits { BitCopy = 1 , BitOwn = 2 }

Private Types
typedef CComObject< CComEnum< Base, piid, T, Copy > >	enumeratorClass

Detailed Description

template<class Base, const IID * piid, class T, class Copy>
class ATL::CComEnumImpl< Base, piid, T, Copy >

Definition at line 913 of file atlcom.h.

Member Typedef Documentation

◆ enumeratorClass

template<class Base , const IID * piid, class T , class Copy >

typedef CComObject<CComEnum<Base, piid, T, Copy> > ATL::CComEnumImpl< Base, piid, T, Copy >::enumeratorClass

private

Definition at line 916 of file atlcom.h.

Member Enumeration Documentation

◆ FlagBits

template<class Base , const IID * piid, class T , class Copy >

enum ATL::CComEnumImpl::FlagBits

protected

Enumerator
BitCopy
BitOwn

Definition at line 1081 of file atlcom.h.

    {
        BitCopy = 1,
        BitOwn = 2
    };

Constructor & Destructor Documentation

◆ CComEnumImpl()

template<class Base , const IID * piid, class T , class Copy >

ATL::CComEnumImpl< Base, piid, T, Copy >::CComEnumImpl ( )

inline

Definition at line 924 of file atlcom.h.

    {
        m_dwFlags = 0;
        m_begin = NULL;
        m_end = NULL;
        m_iter = NULL;
    }

◆ ~CComEnumImpl()

template<class Base , const IID * piid, class T , class Copy >

virtual ATL::CComEnumImpl< Base, piid, T, Copy >::~CComEnumImpl ( )

inlinevirtual

Definition at line 932 of file atlcom.h.

    {
        T *x;
 
        if ((m_dwFlags & BitOwn) != 0)
        {
            for (x = m_begin; x != m_end; x++)
                Copy::destroy(x);
            delete [] m_begin;
        }
    }

Member Function Documentation

◆ Clone()

template<class Base , const IID * piid, class T , class Copy >

STDMETHOD() ATL::CComEnumImpl< Base, piid, T, Copy >::Clone ( Base ** ppEnum )

inline

Definition at line 1055 of file atlcom.h.

    {
        enumeratorClass *newInstance;
        HRESULT hResult;
 
        hResult = E_POINTER;
        if (ppEnum != NULL)
        {
            *ppEnum = NULL;
            hResult = enumeratorClass::CreateInstance(&newInstance);
            if (SUCCEEDED(hResult))
            {
                hResult = newInstance->Init(m_begin, m_end, (m_dwFlags & BitOwn) ? this : m_spUnk);
                if (SUCCEEDED(hResult))
                {
                    newInstance->m_iter = m_iter;
                    hResult = newInstance->_InternalQueryInterface(*piid, (void **)ppEnum);
                }
                if (FAILED(hResult))
                    delete newInstance;
            }
        }
        return hResult;
    }

◆ Init()

template<class Base , const IID * piid, class T , class Copy >

HRESULT ATL::CComEnumImpl< Base, piid, T, Copy >::Init	(	T *	begin,
		T *	end,
		IUnknown *	pUnk,
		CComEnumFlags	flags = `AtlFlagNoCopy`
	)

inline

Definition at line 944 of file atlcom.h.

    {
        T *newBuffer;
        T *sourcePtr;
        T *destPtr;
        T *cleanupPtr;
        HRESULT hResult;
 
        if (flags == AtlFlagCopy)
        {
            ATLTRY(newBuffer = new T[end - begin])
            if (newBuffer == NULL)
                return E_OUTOFMEMORY;
            destPtr = newBuffer;
            for (sourcePtr = begin; sourcePtr != end; sourcePtr++)
            {
                Copy::init(destPtr);
                hResult = Copy::copy(destPtr, sourcePtr);
                if (FAILED(hResult))
                {
                    cleanupPtr = m_begin;
                    while (cleanupPtr < destPtr)
                        Copy::destroy(cleanupPtr++);
                    delete [] newBuffer;
                    return hResult;
                }
                destPtr++;
            }
            m_begin = newBuffer;
            m_end = m_begin + (end - begin);
        }
        else
        {
            m_begin = begin;
            m_end = end;
        }
        m_spUnk = pUnk;
        m_dwFlags = flags;
        m_iter = m_begin;
        return S_OK;
    }

Referenced by ATL::IConnectionPointContainerImpl< T >::EnumConnectionPoints().

◆ Next()

template<class Base , const IID * piid, class T , class Copy >

STDMETHOD() ATL::CComEnumImpl< Base, piid, T, Copy >::Next	(	ULONG	celt,
		T *	rgelt,
		ULONG *	pceltFetched
	)

inline

Definition at line 986 of file atlcom.h.

    {
        ULONG numAvailable;
        ULONG numToFetch;
        T *rgeltTemp;
        HRESULT hResult;
 
        if (pceltFetched != NULL)
            *pceltFetched = 0;
        if (celt == 0)
            return E_INVALIDARG;
        if (rgelt == NULL || (celt != 1 && pceltFetched == NULL))
            return E_POINTER;
        if (m_begin == NULL || m_end == NULL || m_iter == NULL)
            return E_FAIL;
 
        numAvailable = static_cast<ULONG>(m_end - m_iter);
        if (celt < numAvailable)
            numToFetch = celt;
        else
            numToFetch = numAvailable;
        if (pceltFetched != NULL)
            *pceltFetched = numToFetch;
        rgeltTemp = rgelt;
        while (numToFetch != 0)
        {
            hResult = Copy::copy(rgeltTemp, m_iter);
            if (FAILED(hResult))
            {
                while (rgelt < rgeltTemp)
                    Copy::destroy(rgelt++);
                if (pceltFetched != NULL)
                    *pceltFetched = 0;
                return hResult;
            }
            rgeltTemp++;
            m_iter++;
            numToFetch--;
        }
        if (numAvailable < celt)
            return S_FALSE;
        return S_OK;
    }

◆ Reset()

template<class Base , const IID * piid, class T , class Copy >

STDMETHOD() ATL::CComEnumImpl< Base, piid, T, Copy >::Reset ( )

inline

Definition at line 1049 of file atlcom.h.

    {
        m_iter = m_begin;
        return S_OK;
    }

◆ Skip()

template<class Base , const IID * piid, class T , class Copy >

STDMETHOD() ATL::CComEnumImpl< Base, piid, T, Copy >::Skip ( ULONG celt )

inline

Definition at line 1030 of file atlcom.h.

    {
        ULONG numAvailable;
        ULONG numToSkip;
 
        if (celt == 0)
            return E_INVALIDARG;
 
        numAvailable = static_cast<ULONG>(m_end - m_iter);
        if (celt < numAvailable)
            numToSkip = celt;
        else
            numToSkip = numAvailable;
        m_iter += numToSkip;
        if (numAvailable < celt)
            return S_FALSE;
        return S_OK;
    }