// enumvar.cpp : implementation file
//
// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1993 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and Microsoft
// QuickHelp and/or WinHelp documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.

#include "stdafx.h"
#include "inproc.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 (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 ResultFromScode(E_OUTOFMEMORY);
	}
	END_CATCH_ALL

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

	return nFetched == (int)celt ? NOERROR : ResultFromScode(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 : ResultFromScode(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 ResultFromScode(E_OUTOFMEMORY);
	}
	END_CATCH_ALL
	*ppenum = &pClone->m_xEnumVARIANT;

	return NOERROR;
}

/////////////////////////////////////////////////////////////////////////////
// CEnumVariant message handlers
