/*
 * EnumVariant.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


//2009/12/04

#pragma once

#include <sol/Object.h>
#include <objbase.h>
#include <sol/com/ComIUnknown.h>

#pragma comment(lib, "oleaut32.lib")


namespace SOL {

class EnumVariant :public ComIUnknown {


public:
    EnumVariant(IUnknown* pUnk=NULL)
    :ComIUnknown(pUnk)
    {

    }

public:
    ~EnumVariant() 
    {
    }

public:
    IEnumVARIANT* get()
    {
        return (IEnumVARIANT*)getIUnknown();
    }

public:
    EnumVariant& operator=(IEnumVARIANT* pEnum)
    { 
        set(pEnum);
        return *this;
    }

public:

    ULONG next( 
               __in  ULONG celt,
               __out VARIANT *rgVar)
    {
        HRESULT hr = E_FAIL;
        IEnumVARIANT* pEnum = get();
            
        ULONG celtFetched = 0;

        if (FAILED(hr = pEnum -> Next( 
                celt,
                rgVar,
                &celtFetched))) {
            throw hr;
        }
        return celtFetched;
    }

public:
    
    IDispatch* next() 
     {
        HRESULT hr = E_FAIL;

        IDispatch *pDisp = NULL;

        IEnumVARIANT* pEnum = get();
        VARIANT vVar;
        VariantInit(&vVar);
        ULONG celtFetched = 0;
        ULONG celt = 1;

        if (FAILED(hr = pEnum -> Next( 
                celt,
                &vVar,
                &celtFetched))) {
            throw hr;
        }
        //Check Variant type
        if (vVar.vt==VT_DISPATCH && celtFetched == 1) {
            //If vt were VT DISPATCH
            pDisp =V_DISPATCH(&vVar);
        } else {
            throw E_POINTER;
        }
        
        return pDisp;
    }

public:
    ULONG next(
               __in  ULONG celt,
               __out IDispatch **ppDisp)
    {
        HRESULT hr = E_FAIL;
        IEnumVARIANT* pEnum = get();
        VARIANT vVar;
        VariantInit(&vVar);
        ULONG celtFetched = 0;

        if (FAILED(hr = pEnum-> Next( 
                celt,
                &vVar,
                &celtFetched))) {
            throw hr;
        }
        //Check Variant type
        if (vVar.vt==VT_DISPATCH && celtFetched > 0) {
            //If vt were VT DISPATCH
            *ppDisp =V_DISPATCH(&vVar);
        } else {
            throw E_POINTER;
        }
        return celtFetched;
    }

public:
    HRESULT next( 
               __in  ULONG celt,
               __out VARIANT *rgVar,
            __out ULONG *pCeltFetched)
    {
        HRESULT hr = E_FAIL;
        IEnumVARIANT* pEnum = get();

        if (FAILED(hr = pEnum -> Next( 
                celt,
                rgVar,
                pCeltFetched))) {
            throw hr;
        }
        return hr;
    }

public:
    HRESULT skip( 
               __in ULONG celt)
    {
        HRESULT hr = E_FAIL;
        IEnumVARIANT* pEnum = get();

        if (FAILED(hr = pEnum-> Skip(celt))) {
            throw hr;
        }
        return hr;
    }
        

public:
    HRESULT reset()
    {
        HRESULT hr = E_FAIL;
        IEnumVARIANT* pEnum = get();
        
        if (FAILED(hr = pEnum->Reset())) {
            throw hr;
        }
        return hr;
    }
        

public:
    HRESULT clone( 
            __out IEnumVARIANT **ppEnum)        
    {
        HRESULT hr = E_FAIL;
        IEnumVARIANT* pEnum = get();

        if (FAILED(hr = pEnum -> Clone(ppEnum))) {
            throw hr;
        }
        return hr;
    }

};

}