EnumVar.cpp

Go to the documentation of this file.

// EnumVar.cpp : implementation file
//

#include "stdafx.h"
#include "gme.h"
#include "EnumVar.h"

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

// CEnumVariant

IMPLEMENT_DYNCREATE(CEnumVariant, CCmdTarget)

CEnumVariant::CEnumVariant()
{
        m_nIndex = 0;
        m_nCount = 0;
        m_pContents = NULL;

        m_pClonedFrom = NULL;

        // To keep the application running as long as an OLE automation
        //  object is active, the constructor calls AfxOleLockApp.

        AfxOleLockApp();
}

CEnumVariant::~CEnumVariant()
{
        if (m_pClonedFrom != NULL)
        {
                m_pClonedFrom->ExternalRelease();
        }
        else
        {
                for (int i = 0; i < m_nCount; ++i)
                        VariantClear(&m_pContents[i]);
                delete[] m_pContents;
        }

        // To terminate the application when all objects created with
        //  with OLE automation, the destructor calls AfxOleUnlockApp.

        AfxOleUnlockApp();
}

void CEnumVariant::OnFinalRelease()
{
        // When the last reference for an automation object is released
        //  OnFinalRelease is called.  This implementation deletes the
        //  object.  Add additional cleanup required for your object before
        //  deleting it from memory.

        delete this;
}

void CEnumVariant::SetContents(VARIANT* pContents, int nCount, int nIndex)
{
        ASSERT(nIndex < nCount);
        ASSERT(nCount == 0 || pContents != NULL);
        ASSERT(pContents == NULL ||
                AfxIsValidAddress(pContents, sizeof(VARIANT)*nCount, FALSE));

        m_nCount = nCount;
        m_pContents = pContents;
        m_nIndex = nIndex;
}

BEGIN_MESSAGE_MAP(CEnumVariant, CCmdTarget)
        //{{AFX_MSG_MAP(CEnumVariant)
                // NOTE - the ClassWizard will add and remove mapping macros here.
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()

// CEnumVariant interfaces

static void CopyVariantArray(VARIANT* pDest, VARIANT* pSrc, int nCount)
{
        for (int i = 0; i < nCount; ++i)
                VariantInit(&pDest[i]);
        for (int i = 0; i < nCount; ++i)
        {
                SCODE sc = GetScode(VariantCopy(&pDest[i], &pSrc[i]));
                if (sc != NOERROR)
                {
                        while (--i >= 0)
                                VariantClear(&pDest[i]);
                        AfxThrowMemoryException();
                }
        }
}

BEGIN_INTERFACE_MAP(CEnumVariant, CCmdTarget)
        INTERFACE_PART(CEnumVariant, IID_IEnumVARIANT, EnumVARIANT)
END_INTERFACE_MAP()

STDMETHODIMP_(ULONG) CEnumVariant::XEnumVARIANT::AddRef()
{
        METHOD_PROLOGUE(CEnumVariant, EnumVARIANT)
        return pThis->ExternalAddRef();
}

STDMETHODIMP_(ULONG) CEnumVariant::XEnumVARIANT::Release()
{
        METHOD_PROLOGUE(CEnumVariant, EnumVARIANT)
        return pThis->ExternalRelease();
}

STDMETHODIMP CEnumVariant::XEnumVARIANT::QueryInterface(REFIID iid, void** ppvObj)
{
        METHOD_PROLOGUE(CEnumVariant, EnumVARIANT)
        return (HRESULT)pThis->ExternalQueryInterface(&iid, ppvObj) ;
}

STDMETHODIMP CEnumVariant::XEnumVARIANT::Next(ULONG celt, VARIANT* rgvar, ULONG* pceltFetched)
{
        METHOD_PROLOGUE(CEnumVariant, EnumVARIANT)

        ASSERT(celt > 0);
        ASSERT(celt == 1 || pceltFetched != NULL);

        if (pceltFetched != NULL)
                *pceltFetched = 0;

        int nFetched = min(pThis->m_nCount - pThis->m_nIndex, (int)celt);

        TRY
        {
                CopyVariantArray(rgvar, pThis->m_pContents + pThis->m_nIndex, nFetched);
        }
        CATCH_ALL(e)
        {
                return E_OUTOFMEMORY;
        }
        END_CATCH_ALL

        pThis->m_nIndex += nFetched;
        if (pceltFetched != NULL)
                *pceltFetched = nFetched;

        return nFetched == (int)celt ? NOERROR : S_FALSE;
}

STDMETHODIMP CEnumVariant::XEnumVARIANT::Skip(unsigned long celt)
{
        METHOD_PROLOGUE(CEnumVariant, EnumVARIANT)

        int nSkip = (int)celt;
        if (nSkip + pThis->m_nIndex > pThis->m_nCount)
                nSkip = pThis->m_nCount - pThis->m_nIndex;
        pThis->m_nIndex += nSkip;

        return nSkip == (int)celt ? NOERROR : S_FALSE;
}

STDMETHODIMP CEnumVariant::XEnumVARIANT::Reset()
{
        METHOD_PROLOGUE(CEnumVariant, EnumVARIANT)

        pThis->m_nIndex = 0;

        return NOERROR;
}

STDMETHODIMP CEnumVariant::XEnumVARIANT::Clone(IEnumVARIANT** ppenum)
{
        METHOD_PROLOGUE(CEnumVariant, EnumVARIANT)

        CEnumVariant* pClone;
        TRY
        {
                pClone = new CEnumVariant;
                pClone->SetContents(pThis->m_pContents, pThis->m_nCount, pThis->m_nIndex);

                pClone->m_pClonedFrom = pThis;
                pThis->ExternalAddRef();
        }
        CATCH_ALL(e)
        {
                return E_OUTOFMEMORY;
        }
        END_CATCH_ALL
        *ppenum = &pClone->m_xEnumVARIANT;

        return NOERROR;
}

// CEnumVariant message handlers