/*++

Copyright (c) 1997-1999  Microsoft Corporation

Module Name:

    enum.h

Abstract:

    Template classes for enumerations in TAPI3
    
Author:

    mquinton  06-12-97

Notes:

Revision History:

--*/

#ifndef __ENUM_H_
#define __ENUM_H_

#include "resource.h"       // main symbols

#include <mspenum.h>  // for CSafeComEnum

//////////////////////////////////////////////////////////////////////
// CTapiEnum
//          Template class for enumerations in TAPI3.
//////////////////////////////////////////////////////////////////////
template <class Base, class T, const IID* piid> class CTapiEnum :
    public Base,
    public CTAPIComObjectRoot<Base>
{
public:

    typedef CTapiEnum<Base, T, piid> _CTapiEnumBase;

    DECLARE_MARSHALQI(CTapiEnum)
	DECLARE_TRACELOG_CLASS(CTapiEnum)

    BEGIN_COM_MAP(_CTapiEnumBase)
            COM_INTERFACE_ENTRY_IID(*piid, _CTapiEnumBase)
            COM_INTERFACE_ENTRY_FUNC(IID_IMarshal, 0, IMarshalQI)
            COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
    END_COM_MAP()

protected:

    CTObjectArray<T*>    m_Array;
    int                  m_iCurrentLocation;
    
public:

    // initialize the enumerator with a list<T*>
    HRESULT Initialize(
                       CTObjectArray<T*> array
                      )
    {
        int         iSize, iCount;

        iSize = array.GetSize();

        for( iCount = 0; iCount < iSize; iCount++ )
        {
            m_Array.Add(array[iCount]);
        }

        m_iCurrentLocation = 0;
        
        this->AddRef();

        return S_OK;
    }

    // overloaded
    HRESULT Initialize(
                       CTArray<T*> array
                      )
    {
        int         iSize, iCount;

        iSize = array.GetSize();

        for( iCount = 0; iCount < iSize; iCount++ )
        {
            m_Array.Add(array[iCount]);
        }

        m_iCurrentLocation = 0;
        
        this->AddRef();

        return S_OK;
    }

    // Overloaded function, used with Add to build enum list manually
    HRESULT Initialize( )
    {
        m_iCurrentLocation = 0;
        
        this->AddRef();
        
        return S_OK;
    }    

    // Add - used with non-parameterized initialize() to build enum list manually
    HRESULT Add( T* t)
    {
        m_Array.Add( t );

        return S_OK;
    }
    
    
    // FinalRelease - release the objects that were addreffed in
    // initialize
    void FinalRelease()
    {
        m_Array.Shutdown();
    }


    // standard Next method
    HRESULT STDMETHODCALLTYPE Next( 
                                    ULONG celt,
                                    T ** ppElements,
                                    ULONG* pceltFetched
                                  )
    {
        DWORD       dwCount = 0;
        HRESULT     hr = S_OK;

        if ((NULL == ppElements) || (NULL == pceltFetched && celt > 1))
        {
            return E_POINTER;
        }

        // special case
        if (celt == 0)
        {
            return E_INVALIDARG;
        }

        if (TAPIIsBadWritePtr( ppElements, celt * sizeof(T*)) )
        {
            return E_POINTER;
        }

        if ( ( NULL != pceltFetched) &&
             TAPIIsBadWritePtr( pceltFetched, sizeof (ULONG) ) )
        {
            return E_POINTER;
        }
        
        // iterator over elements
        while ((m_iCurrentLocation != m_Array.GetSize()) && (dwCount < celt))
        {
            ppElements[dwCount] = m_Array[m_iCurrentLocation];
            
            ppElements[dwCount]->AddRef();
            
            m_iCurrentLocation++;
            
            dwCount++;
        }

        if (NULL != pceltFetched)
        {
            *pceltFetched = dwCount;
        }

        // indicate that we've reached the end
        // of the enumeration.
        if (dwCount < celt)
        {
            return S_FALSE;
        }

        return S_OK;
    }

    // standard Reset method
    HRESULT STDMETHODCALLTYPE Reset( void )
    {
        m_iCurrentLocation = 0;
        
        return S_OK;
    }


    // standard Skip method
    HRESULT STDMETHODCALLTYPE Skip( 
                                   ULONG celt
                                  )
    {
        long        lCount = 0;
        
        while ( (lCount < celt) && (m_iCurrentLocation < m_Array.GetSize() ) )
        {
            m_iCurrentLocation++;
            lCount++;
        }

        return S_OK;
    }

    // standard Clone method
    HRESULT STDMETHODCALLTYPE Clone( 
                                    Base  ** ppEnum
                                   )
    {
        HRESULT                        hr = S_OK;
        CComObject< _CTapiEnumBase > * pNewEnum;

        if (TAPIIsBadWritePtr( ppEnum, sizeof (Base *) ) )
        {
            return E_POINTER;
        }

        CComObject< _CTapiEnumBase >::CreateInstance(&pNewEnum);
        if (pNewEnum == NULL)
        {
            hr = E_OUTOFMEMORY;
        }
        else
        {
            pNewEnum->Initialize(m_Array);

            pNewEnum->m_iCurrentLocation = m_iCurrentLocation;

            *ppEnum = pNewEnum;
        }
        
        return hr;
    }

};

////////////////////////////////////////////////////////////////////////
// CTapiCollection
//      Collection template for TAPI3.0 collections
////////////////////////////////////////////////////////////////////////
template <class T> class CTapiCollection :
    public CComDualImpl<ITCollection2, &IID_ITCollection2, &LIBID_TAPI3Lib>,
    public CTAPIComObjectRoot<T>,
    public CObjectSafeImpl
{
public:
    typedef CTapiCollection<T> _CTapiCollectionBase;

DECLARE_MARSHALQI(CTapiCollection)
DECLARE_TRACELOG_CLASS(CTapiCollection)

BEGIN_COM_MAP(_CTapiCollectionBase)
    COM_INTERFACE_ENTRY(IDispatch)
    COM_INTERFACE_ENTRY(ITCollection)
    COM_INTERFACE_ENTRY(ITCollection2)
    COM_INTERFACE_ENTRY(IObjectSafety)
    COM_INTERFACE_ENTRY_FUNC(IID_IMarshal, 0, IMarshalQI)
    COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
END_COM_MAP()

private:

    int                 m_nSize;
    CComVariant *       m_Var;
    
public:

    CTapiCollection() : m_nSize(0),
                        m_Var(NULL)
                        {}


    // initialize
    HRESULT STDMETHODCALLTYPE Initialize(
                                         CTObjectArray<T *> array
                                        )
    {
        int                     i;
        HRESULT                 hr;

        LOG((TL_TRACE, "Initialize - enter"));

        // create variant array
        m_nSize = array.GetSize();

        m_Var = new CComVariant[m_nSize];

        if (m_Var == NULL)
        {
            LOG((TL_ERROR, "Initialize - out of memory"));
            return E_OUTOFMEMORY;
        }

        for (i = 0; i < array.GetSize(); i++)
        {
            // get IDispatch pointer
            IDispatch * pDisp = NULL;

            hr = array[i]->QueryInterface(IID_IDispatch, (void**)&pDisp);

            if (S_OK != hr)
            {
                return hr;
            }

            // create a variant and add it to the collection
            CComVariant& var = m_Var[i];

            VariantInit(&var);
            
            var.vt = VT_DISPATCH;
            var.pdispVal = pDisp;
        }

        LOG((TL_TRACE, "Initialize - exit"));
        
        return S_OK;
    }

    // initialize
    HRESULT STDMETHODCALLTYPE Initialize(
                                         CTArray<T *> array
                                        )
    {
        int                     i;
        HRESULT                 hr;

        LOG((TL_TRACE, "Initialize - enter"));

        // create variant array
        m_nSize = array.GetSize();

        m_Var = new CComVariant[m_nSize];

        if (m_Var == NULL)
        {
            LOG((TL_ERROR, "Initialize - out of memory"));
            return E_OUTOFMEMORY;
        }

        for (i = 0; i < array.GetSize(); i++)
        {
            // get IDispatch pointer
            IDispatch * pDisp = NULL;

            hr = array[i]->QueryInterface(IID_IDispatch, (void**)&pDisp);

            if (S_OK != hr)
            {
                return hr;
            }

            // create a variant and add it to the collection
            CComVariant& var = m_Var[i];

            VariantInit(&var);
            
            var.vt = VT_DISPATCH;
            var.pdispVal = pDisp;
        }

        LOG((TL_TRACE, "Initialize - exit"));
        
        return S_OK;
    }

    void FinalRelease()
    {
        //
        // We "new"ed an array of objects -- delete the array and call
        // each object's destructor. Each destructor calls VariantClear,
        // which calls Release on each pointer.
        //

        if(m_Var != NULL)
        {
            delete [] m_Var;
        }
    }
    
    STDMETHOD(get_Count)(
                         long* retval
                        )
    {
        LOG((TL_TRACE, "get_Count - enter"));

        if ( TAPIIsBadWritePtr( retval, sizeof(long) ) )
        {
            return E_POINTER;
        }
        
        *retval = m_nSize;

        LOG((TL_TRACE, "get_Count - exit"));

        return S_OK;
    }

    STDMETHOD(get_Item)(
                        long Index, 
                        VARIANT* retval
                       )
    {
        LOG((TL_TRACE, "get_Item - enter"));

        if ( TAPIIsBadWritePtr (retval, sizeof(VARIANT) ) )
        {
            return E_POINTER;
        }
        
        VariantInit(retval);

        retval->vt = VT_UNKNOWN;
        retval->punkVal = NULL;

        // use 1-based index, VB like
        if ((Index < 1) || (Index > m_nSize))
        {
            return E_INVALIDARG;
        }

        VariantCopy(retval, &m_Var[Index-1]);

        LOG((TL_TRACE, "get_Item - exit"));
        
        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE get__NewEnum(
                                           IUnknown** retval
                                          )
    
    {
        HRESULT         hr;

        LOG((TL_TRACE, "new__Enum - enter"));
        
        if ( TAPIIsBadWritePtr( retval, sizeof( IUnknown * ) ) )
        {
            return E_POINTER;
        }

        *retval = NULL;

        typedef CComObject<CSafeComEnum<IEnumVARIANT, &IID_IEnumVARIANT, VARIANT, _Copy<VARIANT> > > enumvar;

        enumvar* p; // = new enumvar;
        enumvar::CreateInstance( &p );

        _ASSERTE(p);
        
        if (p == NULL)
        {
            hr = E_OUTOFMEMORY;
        }
        else
        {

            hr = p->Init(&m_Var[0], &m_Var[m_nSize], NULL, AtlFlagCopy);

            if (SUCCEEDED(hr))
            {
                hr = p->QueryInterface(IID_IEnumVARIANT, (void**)retval);
            }

            if (FAILED(hr))
            {
                delete p;
            }
        }

        LOG((TL_TRACE, "new__Enum - exit"));
        
        return hr;

    }

    STDMETHOD(Add)(
                   long Index, 
                   VARIANT* pVariant
                  )
    {
        LOG((TL_TRACE, "Add - enter"));

        if ( IsBadReadPtr (pVariant, sizeof(VARIANT) ) )
        {
            return E_POINTER;
        }

         // use 1-based index, VB like
        if ( (Index < 1) || (Index > (m_nSize + 1)) )
        {
            return E_INVALIDARG;
        }

        CComVariant *       newVar = NULL;

        newVar = new CComVariant[m_nSize + 1];

        if ( NULL == newVar )
        {
            LOG((TL_ERROR, "Add - out of memory"));
            return E_OUTOFMEMORY;
        }

        HRESULT hr;
        int i;

        // fill in the new array
        for ( i = 0; i < (m_nSize + 1); i++ )
        {
            VariantInit(&newVar[i]);

            if ( i < (Index - 1) )
            {
                // shouldn't reach this case unless there was an old array
                _ASSERTE(m_Var != NULL);

                hr = VariantCopy(&newVar[i], &m_Var[i]);
            }
            else if ( i == (Index - 1) )
            {
                // copy the new element
                hr = VariantCopy(&newVar[i], pVariant);
            }
            else
            {
                // shouldn't reach this case unless there was an old array
                _ASSERTE(m_Var != NULL);

                hr = VariantCopy(&newVar[i], &m_Var[i-1]);
            }

            if ( FAILED(hr) ) 
            {
                LOG((TL_ERROR, "Add - VariantCopy failed - %lx", hr));

                delete [] newVar;

                return hr;
            }
        }

        if ( m_Var != NULL)
        {
            // Delete the old array
            delete [] m_Var;            
        }

        m_Var = newVar;
        m_nSize++;

        LOG((TL_TRACE, "Add - exit"));
        
        return S_OK;
    }

    STDMETHOD(Remove)(
                      long Index
                     )
    {
        LOG((TL_TRACE, "Remove - enter"));

         // use 1-based index, VB like
        if ( (Index < 1) || (Index > m_nSize) )
        {
            return E_INVALIDARG;
        }

        CComVariant *       newVar = NULL;

        // if there is only one element in the array we don't need to do
        // any copying
        if (m_nSize > 1)
        {
            newVar = new CComVariant[m_nSize - 1];

            if ( NULL == newVar )
            {
                LOG((TL_ERROR, "Remove - out of memory"));
                return E_OUTOFMEMORY;
            }

            HRESULT hr;
            int i;
       
            // fill in the new array
            for ( i = 0; i < (m_nSize - 1); i++ )
            {
                VariantInit(&newVar[i]);

                if ( i < (Index - 1) )
                {
                    // shouldn't reach this case unless there was an old array
                    _ASSERTE(m_Var != NULL);

                    hr = VariantCopy(&newVar[i], &m_Var[i]);
                }
                else
                {
                    // shouldn't reach this case unless there was an old array
                    _ASSERTE(m_Var != NULL);

                    hr = VariantCopy(&newVar[i], &m_Var[i+1]);
                }

                if ( FAILED(hr) ) 
                {
                    LOG((TL_ERROR, "Remove - VariantCopy failed - %lx", hr));

                    delete [] newVar;

                    return hr;
                }
            }
        }

        if ( m_Var != NULL)
        {
            // Delete the old array
            delete [] m_Var;            
        }

        m_Var = newVar;
        m_nSize--;

        LOG((TL_TRACE, "Remove - exit"));
        
        return S_OK;
    }

};

////////////////////////////////////////////////////////////////////////
// CTapiBstrCollection
//    Collection of BSTRs.
////////////////////////////////////////////////////////////////////////
class CTapiBstrCollection :
    public CComObjectRootEx<CComMultiThreadModelNoCS>,
    public IDispatchImpl<ITCollection, &IID_ITCollection, &LIBID_TAPI3Lib>,
    public CObjectSafeImpl
{
public:
DECLARE_TRACELOG_CLASS(CTapiBstrCollection)
BEGIN_COM_MAP(CTapiBstrCollection)
    COM_INTERFACE_ENTRY(IDispatch)
    COM_INTERFACE_ENTRY(ITCollection)
    COM_INTERFACE_ENTRY(IObjectSafety)
END_COM_MAP()

private:

    DWORD               m_dwSize;
    CComVariant *       m_Var;
    
public:

    CTapiBstrCollection(void) : m_dwSize(0), m_Var(NULL) { }

    // initialize
    HRESULT STDMETHODCALLTYPE Initialize(
                                         DWORD dwSize,
                                         BSTR * pBegin,
                                         BSTR * pEnd                                         
                                        )
    {
        BSTR *  i;
        DWORD   dw = 0;

        LOG((TL_TRACE, "Initialize - enter"));

        // create variant array
        m_dwSize = dwSize;

        m_Var = new CComVariant[m_dwSize];

        if (m_Var == NULL)
        {
            // debug output
            return E_OUTOFMEMORY;
        }

        for (i = pBegin; i != pEnd; i++)
        {
            // create a variant and add it to the collection
            CComVariant& var = m_Var[dw];

            var.vt = VT_BSTR;
            var.bstrVal = *i;

            dw++;
        }

        LOG((TL_TRACE, "Initialize - exit"));
        
        return S_OK;
    }
    
    STDMETHOD(get_Count)(
                         long* retval
                        )
    {
        HRESULT         hr = S_OK;

        LOG((TL_TRACE, "get_Count - enter"));        

        try
        {
            *retval = m_dwSize;
        }
        catch(...)
        {
            hr = E_INVALIDARG;
        }

        LOG((TL_TRACE, "get_Count - exit"));
        
        return hr;
    }

    STDMETHOD(get_Item)(
                        long Index, 
                        VARIANT* retval
                       )
    {
        HRESULT         hr = S_OK;

        LOG((TL_TRACE, "get_Item - enter"));
        
        if (retval == NULL)
        {
            return E_POINTER;
        }

        try
        {
            VariantInit(retval);
        }
        catch(...)
        {
            hr = E_INVALIDARG;
        }

        if (hr != S_OK)
        {
            return hr;
        }

        retval->vt = VT_BSTR;
        retval->bstrVal = NULL;

        // use 1-based index, VB like
        // no problem with signed/unsigned, since
        // if Index < 0 then first clause is true, making it
        // irrelevant if the second clause is correct or not.

        if ((Index < 1) || ( (DWORD) Index > m_dwSize))
        {
            return E_INVALIDARG;
        }

        //
        // This copies the string, not just the pointer.
        //

        VariantCopy(retval, &m_Var[Index-1]);

        LOG((TL_TRACE, "get_Item - exit"));

        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE get__NewEnum(
                                           IUnknown** retval
                                          )
    
    {
        HRESULT         hr;

        LOG((TL_TRACE, "get__NumEnum - enter"));
        
        if (retval == NULL)
        {
            return E_POINTER;
        }

        *retval = NULL;

        typedef CComObject<CSafeComEnum<IEnumVARIANT, &IID_IEnumVARIANT, VARIANT, _Copy<VARIANT> > > enumvar;

        enumvar* p = new enumvar;

        if ( p == NULL)
        {
            // debug output
            return E_OUTOFMEMORY;
        }

        hr = p->Init(&m_Var[0], &m_Var[m_dwSize], NULL, AtlFlagCopy);

        if (SUCCEEDED(hr))
        {
            hr = p->QueryInterface(IID_IEnumVARIANT, (void**)retval);
        }

        if (FAILED(hr))
        {
            delete p;
        }

        LOG((TL_TRACE, "get__NewEnum - exit"));
        
        return hr;

    }

    void FinalRelease()
    {
        LOG((TL_TRACE, "FinalRelease() - enter"));

        //
        // We "new"ed an array of objects. Delete each object in the array. The
        // destructor for each object calls VariantClear to release the pointer
        // in that object, based on the variant's tag.
        //

        delete [] m_Var;

        LOG((TL_TRACE, "FinalRelease() - exit"));
    }

};

////////////////////////////////////////////////////////////////////////
// CTapiTypeEnum template - enumerate types & structures
////////////////////////////////////////////////////////////////////////
template <class Base, class T, class Copy, const IID* piid> class CTapiTypeEnum :
    public Base,
    public CTAPIComObjectRoot<Base>
{
public:

    // *piid is the IID of the enumerator class being
    // created (like IID_IEnumAddressType)
    typedef CTapiTypeEnum<Base, T, Copy, piid> _CTapiTypeEnumBase;
    
    BEGIN_COM_MAP(_CTapiTypeEnumBase)
            COM_INTERFACE_ENTRY_IID(*piid, _CTapiTypeEnumBase)
            COM_INTERFACE_ENTRY_FUNC(IID_IMarshal, 0, IMarshalQI)
            COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
    END_COM_MAP()
    DECLARE_QI()
    DECLARE_MARSHALQI(CTapiTypeEnum)
	DECLARE_TRACELOG_CLASS(CTapiTypeEnum)
	
protected:

        CTArray<T>              m_Array;
        int                     m_iCurrentLocation;
    
public:

    //
    // initialize the enumerator
    //
    HRESULT Initialize(CTArray<T> array)
    {
        int         iSize, iCount;

        iSize = array.GetSize();

        for (iCount = 0; iCount < iSize; iCount++ )
        {
            m_Array.Add(array[iCount]);
        }

        m_iCurrentLocation = 0;
        
        //
        // addref ourself
        //
        this->AddRef();

        
        return S_OK;
    }

    //
    // FinalRelease
    //
    void FinalRelease()
    {
        m_Array.Shutdown();
    }

    HRESULT STDMETHODCALLTYPE Next(
                                    ULONG celt,
                                    T * pElements,
                                    ULONG* pceltFetched
                                  )
    {
        DWORD       dwCount = 0;

        if ((NULL == pElements) || (NULL == pceltFetched && celt > 1))
        {
            return E_POINTER;
        }

        //
        // special case
        //
        if (celt == 0)
        {
            return E_INVALIDARG;
        }

        if (TAPIIsBadWritePtr( pElements, celt * sizeof(T) ) )
        {
            return E_POINTER;
        }
        
        if ( (NULL != pceltFetched) &&
             TAPIIsBadWritePtr( pceltFetched, sizeof(ULONG) ) )
        {
            return E_POINTER;
        }
        
        //
        // iterator over elements and copy
        //
        while ((m_iCurrentLocation != m_Array.GetSize()) && (dwCount < celt))
        {   
            Copy::copy(
                       &(pElements[dwCount]),
                       &(m_Array[m_iCurrentLocation])
                      );

            m_iCurrentLocation++;
            dwCount++;
        }

        //
        // return number copied
        //
        if (NULL != pceltFetched)
        {
            *pceltFetched = dwCount;
        }

        //
        // indicate if we've reached the end
        // of the enumeration.
        //
        if (dwCount < celt)
        {
            return S_FALSE;
        }

        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE Skip(
                                   ULONG celt
                                  )
    {
        long        lCount = 0;
        
        while ( (lCount < celt) && (m_iCurrentLocation < m_Array.GetSize()) )
        {
            m_iCurrentLocation++;
            lCount++;
        }

        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE Reset(void)
    {
        m_iCurrentLocation = 0;
        
        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE Clone(
                                    Base ** ppEnum
                                   )
    {
        HRESULT                        hr = S_OK;
        CComObject< _CTapiTypeEnumBase > * pNewEnum;

        if (TAPIIsBadWritePtr( ppEnum, sizeof (Base *) ) )
        {
            return E_POINTER;
        }

        CComObject< _CTapiTypeEnumBase >::CreateInstance(&pNewEnum);

        if (pNewEnum == NULL)
        {
            hr = E_OUTOFMEMORY;
        }
        else
        {
            pNewEnum->Initialize(m_Array);

            pNewEnum->m_iCurrentLocation = m_iCurrentLocation;

            *ppEnum = pNewEnum;
        }
        
        return hr;
    }
};

////////////////////////////////////////////////////////////////////////
// CTerminalClassEnum
////////////////////////////////////////////////////////////////////////
class CTerminalClassEnum :
    public IEnumTerminalClass,
    public CTAPIComObjectRoot<CTerminalClassEnum>
{
public:

    DECLARE_MARSHALQI(CTerminalClassEnum)
	DECLARE_TRACELOG_CLASS(CTerminalClassEnum)
		
    BEGIN_COM_MAP(CTerminalClassEnum)
            COM_INTERFACE_ENTRY(IEnumTerminalClass)
            COM_INTERFACE_ENTRY_FUNC(IID_IMarshal, 0, IMarshalQI)
            COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
    END_COM_MAP()

protected:

    TerminalClassPtrList            m_list;
    TerminalClassPtrList::iterator  m_iter;
    
public:

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void **ppvObject) = 0;
	virtual ULONG STDMETHODCALLTYPE AddRef() = 0;
	virtual ULONG STDMETHODCALLTYPE Release() = 0;


    // initialize the enumerator
    HRESULT Initialize(
                       TerminalClassPtrList List
                      )
    {
        // copy the array
        m_list.clear();
        m_list.insert(m_list.begin(), List.begin(), List.end());

        m_iter = m_list.begin();

        this->AddRef();
        
        return S_OK;
    }

    // FinalRelease -- added by ZoltanS
    void FinalRelease(void)
    {
        // go through the list
        for ( m_iter = m_list.begin(); m_iter != m_list.end(); m_iter++ )
        {
            SysFreeString(*m_iter); // this is the real way to free a BSTR

            *m_iter = NULL; // destructor for list will delete(NULL)
        }
    }
    
    
    HRESULT STDMETHODCALLTYPE Next(
                                   ULONG celt,
                                   GUID * pElements,
                                   ULONG* pceltFetched
                                  )
    {
        DWORD       dwCount = 0;
        HRESULT     hr = S_OK;

        if ((NULL == pElements) || (NULL == pceltFetched && celt > 1))
        {
            return E_POINTER;
        }

        // special case
        if (celt == 0)
        {
            return E_INVALIDARG;
        }

        // iterator over elements
        try
        {
            while ( (m_iter != m_list.end()) &&
                    (dwCount < celt) )
            {
                hr = IIDFromString( *m_iter, &(pElements[dwCount]) );

                if (!SUCCEEDED(hr))
                {
                    break;
                }
                
                m_iter++;
                dwCount++;
            }
        }
        catch(...)
        {
            hr = E_INVALIDARG;
        }

        if (S_OK != hr)
        {
            return hr;
        }
            

        if (NULL != pceltFetched)
        {
            try
            {
                *pceltFetched = dwCount;
            }
            catch(...)
            {
                hr = E_INVALIDARG;
            }
        }

        if (S_OK != hr)
        {
            return hr;
        }

        // indicate that we've reached the end
        // of the enumeration.
        if (dwCount < celt)
        {
            return S_FALSE;
        }

        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE Skip(
                                   ULONG celt
                                  )
    {
        long        lCount = 0;
        
        while ( (lCount < celt) && (m_iter != m_list.end()) )
        {
            m_iter++;
            lCount++;
        }

        // check to see if we reached the end
        if (lCount != celt)
        {
            return S_OK;
        }
        
        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE Reset(void)
    {
        m_iter = m_list.begin();
        
        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE Clone(
                                    IEnumTerminalClass ** ppEnum
                                   )
    {
        HRESULT         hr = S_OK;
        
        CComObject< CTerminalClassEnum > * pNewEnum;

        CComObject< CTerminalClassEnum >::CreateInstance(&pNewEnum);

        if (pNewEnum == NULL)
        {
            hr = E_OUTOFMEMORY;
        }
        else
        {
            pNewEnum->Initialize( m_list );

            try
            {
                *ppEnum = pNewEnum;
            }
            catch(...)
            {
                hr = E_INVALIDARG;
            }
        }
        
        return hr;
    }
};



#endif // __ENUM_H__