//***************************************************************************

//

// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//
//  Instance.CPP
//
//  Purpose: Implementation of CInstance class
//
//***************************************************************************

#include "precomp.h"

#include <BrodCast.h>
#include <assertbreak.h>
#include <stopwatch.h>
#include "FWStrings.h"

#define DEPRECATED 1

////////////////////////////////////////////////////////////////////////
//
//  Function:   CInstance ctor
//
//
//
//  Inputs:     IWbemClassObject* - the class we want to wrap
//              MethodContext*    - since the context is shared, this will be addreffed
//  Outputs:
//
//  Return:
//
//  Comments:   pointers should not be NULL
//
////////////////////////////////////////////////////////////////////////
CInstance::CInstance(IWbemClassObject* piClassObject, MethodContext* pMethodContext)
:   m_nRefCount( 1 )
{
    ASSERT_BREAK(piClassObject  != NULL);
    ASSERT_BREAK(pMethodContext != NULL);

    // Both these values will be released in the destructor, so they both oughta
    // be AddRefed.  Note that they are

    m_piClassObject  = piClassObject;
    if ( NULL != piClassObject )
    {   // this, however, is a copy
        m_piClassObject->AddRef();
    }

    m_pMethodContext = pMethodContext;
    if (pMethodContext)
    {   // this, however, is a copy
        m_pMethodContext->AddRef();
    }
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   CInstance Dtor
//
//
//
//  Inputs:
//
//  Outputs:
//
//  Return:
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
CInstance::~CInstance()
{

    if ( NULL != m_piClassObject )
    {
        m_piClassObject->Release();
    }

    if ( NULL != m_pMethodContext )
    {
        m_pMethodContext->Release();
    }
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   CInstance::AddRef
//
//  Increments our reference count.
//
//  Inputs:     None.
//
//  Outputs:    None.
//
//  Return:     New Reference Count.
//
//  Comments:   We may want to go to an Interlocked Inc/Dec model at
//              some point if Thread Safety on these objects becomes
//              an issue.
//
////////////////////////////////////////////////////////////////////////

LONG CInstance::AddRef( void )
{
    return InterlockedIncrement(&m_nRefCount);
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   CInstance::Release
//
//  Decrements our reference count.
//
//  Inputs:     None.
//
//  Outputs:    None.
//
//  Return:     New Reference Count.
//
//  Comments:   Deletes the object when the ref count hits 0.  We may
//              want to go to an Interlocked Inc/Dec model at some
//              point if Thread Safety on these objects becomes an issue.
//
////////////////////////////////////////////////////////////////////////

LONG CInstance::Release( void )
{
    LONG   nRet = InterlockedDecrement(&m_nRefCount);

    ASSERT_BREAK(nRet >= 0);

    if ( 0 == nRet )
    {
        delete this;
    }
    else if (nRet < 0)
    {
        // Duplicate release.  Let's try to dump the stack
        DWORD t_stack[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
#ifdef _X86_
        DWORD *dwEBP;

        _asm {
            mov dwEBP, ebp
        }

        dwEBP += 1;
        memcpy(&t_stack, dwEBP, sizeof(t_stack));
#endif

        CHString sMsg;
        sMsg.Format(L"Duplicate release: %08x %08x %08x %08x %08x %08x %08x %08x "
                                       L"%08x %08x %08x %08x %08x %08x %08x %08x "
                                       L"%08x %08x %08x %08x %08x %08x %08x %08x "
                                       L"%08x %08x %08x %08x %08x %08x %08x %08x ",
                    t_stack[0], t_stack[1], t_stack[2], t_stack[3], 
                    t_stack[4], t_stack[5], t_stack[6], t_stack[7],
                    t_stack[8], t_stack[9], t_stack[10], t_stack[11], 
                    t_stack[12], t_stack[13], t_stack[14], t_stack[15], 
                    t_stack[16], t_stack[17], t_stack[18], t_stack[19], 
                    t_stack[20], t_stack[21], t_stack[22], t_stack[23], 
                    t_stack[24], t_stack[25], t_stack[26], t_stack[27], 
                    t_stack[28], t_stack[29], t_stack[30], t_stack[31]
        );

        LogErrorMessage(sMsg);
    }

    return nRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Commit
//
//              returns this CInstance to CIMOM
//              will stuff it into the cache someday
//  Inputs:
//
//  Outputs:
//
//  Return:
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
HRESULT CInstance::Commit(void)
{
    return m_pMethodContext->Commit( this );
}

IWbemClassObject*   CInstance::GetClassObjectInterface()
{
    m_piClassObject->AddRef();

    return m_piClassObject;
}


// reference counting //

// string support //

////////////////////////////////////////////////////////////////////////
//
//  Function:   Set
//
//
//
//  Inputs:     Name of property to set
//              string to be set
//
//  Outputs:
//
//  Return:     false if you try to set a property that is not a string type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetWCHARSplat( LPCWSTR name, LPCWSTR pStr)
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(name != NULL);
    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v(pStr);

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);

        if (!bRet)
        {
			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETCHSTRING, name, hr);
        }
    }
    else
    {
		if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETCHSTRING);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
	        LogError(IDS_NOCLASS, IDS_SETCHSTRING);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);

	SetLastError(dwLastErr);
    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Set
//
//
//
//  Inputs:     Name of property to set to VT_NULL
//
//  Outputs:
//
//  Return:     false if you try to set a property that is not a string type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetNull(LPCWSTR name)
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(name != NULL);
    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;
        v.vt = VT_NULL ;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);

        if (!bRet)
        {
			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETCHSTRING, name, hr);
        }
    }
    else
    {
		if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETCHSTRING);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETCHSTRING);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);

	SetLastError(dwLastErr);
    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   SetStringArray
//
//
//
//  Inputs:     Name of property to set
//              string to be set
//
//  Outputs:
//
//  Return:     false if you try to set a property that is not a string array type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetStringArray(LPCWSTR name, const SAFEARRAY &strArray)
{

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(name != NULL);
    if (m_piClassObject && name)
    {
        SAFEARRAY *t_SafeArray = NULL;
        HRESULT hr = SafeArrayCopy ( ( SAFEARRAY * ) & strArray , &t_SafeArray );

        if ( SUCCEEDED ( hr ) )
        {
            // Variant_t handles the VariantInit/VariantClear
            variant_t v;

            v.vt = VT_BSTR | VT_ARRAY ;
            v.parray = t_SafeArray ;

            PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
            HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
            PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

            ASSERT_BREAK(SUCCEEDED(hr));

            bRet = (bool)SUCCEEDED(hr);

            if (!bRet)
            {
				dwLastErr = (hr);
                LogError(IDS_FAILED, IDS_SetStringArray, name, hr);
            }
        }
        else
        {
            throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
        }

    }
    else
    {
		if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SetStringArray);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SetStringArray);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);

	SetLastError(dwLastErr);
    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Get (CHString)
//
//
//
//  Inputs:     Name of property to retrieve
//              CHString buffer to receive value
//  Outputs:
//
//  Return:     false if you try to get a property that is not a string compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetCHString(LPCWSTR name, CHString& str) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(name != NULL);
    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = SUCCEEDED(hr) && (v.vt == VT_BSTR || v.vt == VT_NULL);
        
        ASSERT_BREAK(bSuccess);
        
        if (SUCCEEDED(hr))
        {
            if ((v.vt == VT_BSTR) && (v.bstrVal != NULL))
            {
                str = v.bstrVal;
                bRet = true;
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETCHSTRING, name, hr);
        }
    }
    else
    {
		if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETCHSTRING);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETCHSTRING);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);

	SetLastError(dwLastErr);
    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetStringArray
//
//
//
//  Inputs:     Name of property to retrieve
//              SAFEARRAY *& strArray
//  Outputs:
//
//  Return:     false if you try to get a property that is not a string array compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetStringArray(LPCWSTR name,  SAFEARRAY *& strArray) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(name != NULL);
    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = SUCCEEDED(hr) && (v.vt == (VT_BSTR|VT_ARRAY) || 
                            v.vt == VT_NULL);
        
        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if ((v.vt == (VT_BSTR|VT_ARRAY)) && (v.parray != NULL ))
            {
                if ( SUCCEEDED ( SafeArrayCopy ( v.parray , ( SAFEARRAY ** ) &strArray ) ) )
                {
                    bRet = true ;
                }
                else
                {
                    throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
                }
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GetStringArray, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GetStringArray);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GetStringArray);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);

	SetLastError(dwLastErr);
    return bRet;
}

bool CInstance::GetWCHAR(LPCWSTR name,  WCHAR **pW) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = SUCCEEDED(hr) && (v.vt == VT_BSTR || v.vt == VT_NULL);
        
        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if ((v.vt == VT_BSTR) && (v.bstrVal != NULL))
            {
                *pW = (WCHAR *)malloc((wcslen(v.bstrVal) + 1)*sizeof(WCHAR));
                if (*pW == NULL)
                {
                    VariantClear(&v);
                    throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
                }

                wcscpy(*pW, v.bstrVal);
                bRet = true;
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETCHSTRING, name, hr);
        }

    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETCHSTRING);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETCHSTRING);
		}

    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);

	SetLastError(dwLastErr);
    return bRet;
}

// WORD support //

////////////////////////////////////////////////////////////////////////
//
//  Function:   Set (WORD)
//
//
//
//  Inputs:     Name of property to set
//              WORD to be set
//  Outputs:
//
//  Return:     false if you try to set a property that is not a WORD compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetWORD(LPCWSTR name,  WORD w)
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(name);
    if (m_piClassObject && name)
    {
        VARIANT v;
        VariantInit(&v);

        v.vt   = VT_I4;
        v.lVal = (long)w;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);

        VariantClear(&v);
        if (!bRet)
        {
			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETWORD, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETWORD);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETWORD);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);
    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Get (WORD)
//
//
//
//  Inputs:     Name of property to retrieve
//              WORD buffer to receive value
//  Outputs:
//
//  Return:     false if you try to get a property that is not a WORD compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetWORD(LPCWSTR name,  WORD& w) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(name != NULL);
    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;
        CIMTYPE  vtType;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, &vtType, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = SUCCEEDED(hr) && CIM_UINT16 == vtType;

        ASSERT_BREAK(bSuccess);
        
        if (SUCCEEDED(hr))
        {
            // the CIM type is important here
            if( (v.vt == VT_I4) && (CIM_UINT16 == vtType) )
            {
                w = (WORD)v.lVal;
                bRet = true;
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETWORD, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETWORD);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETWORD);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);
    return bRet;
}

// DWORD support //

////////////////////////////////////////////////////////////////////////
//
//  Function:   Set (DWORD)
//
//
//
//  Inputs:     Name of property to set
//              DWORD to be set
//  Outputs:
//
//  Return:     false if you try to set a property that is not a DWORD compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetDWORD(LPCWSTR name, DWORD d)
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        VARIANT v;
        VariantInit(&v);

        v.vt   = VT_I4;
        v.lVal = (long)d;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);
		
		if (!bRet)
		{
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETDWORD, name, hr);
		}

        VariantClear(&v);
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETDWORD);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETDWORD);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);
    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Get (DWORD)
//
//
//
//  Inputs:     Name of property to retrieve
//              DWORD buffer to receive value
//  Outputs:
//
//  Return:     false if you try to get a property that is not a DWORD compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetDWORD(LPCWSTR name,  DWORD& d) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = SUCCEEDED(hr) && (v.vt == VT_I4 || v.vt == VT_NULL);

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if (v.vt == VT_I4)
            {
                d = (DWORD)v.lVal;
                bRet = true;
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETDWORD, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETDWORD);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETDWORD);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);
    return bRet;
}

// DOUBLE support //

////////////////////////////////////////////////////////////////////////
//
//  Function:   Set (DOUBLE)
//
//
//
//  Inputs:     Name of property to set
//              DOUBLE to be set
//  Outputs:
//
//  Return:     false if you try to set a property that is not a DOUBLE compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetDOUBLE(LPCWSTR name,  DOUBLE dub)
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        VARIANT v;
        VariantInit(&v);

        V_R8(&v) = dub;
        V_VT(&v) = VT_R8;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);
        VariantClear(&v);

		if (!bRet)
		{
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETDOUBLE, name, hr);
		}
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETDOUBLE);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETDOUBLE);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);
    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Get (DOUBLE)
//
//
//
//  Inputs:     Name of property to retrieve
//              DOUBLE buffer to receive value
//  Outputs:
//
//  Return:     false if you try to get a property that is not a DOUBLE compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetDOUBLE(LPCWSTR name,  DOUBLE& dub) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = SUCCEEDED(hr) && (v.vt == VT_R8 || v.vt == VT_NULL);

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if (v.vt == VT_R8)
            {
                dub = V_R8(&v);
                bRet = true;
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETDOUBLE, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETDOUBLE);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETDOUBLE);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Set (Byte)
//
//
//
//  Inputs:     Name of property to set
//              BYTE to be set
//  Outputs:
//
//  Return:     false if you try to set a property that is not a BYTE compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetByte(LPCWSTR name,  BYTE b)
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        VARIANT v;
        VariantInit(&v);

        v.vt   = VT_UI1;
        v.bVal = (long)b ;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);
        if (!bRet)
        {
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETBYTE, name, hr);
        }

        VariantClear(&v);
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETBYTE);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETBYTE);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   SetEmbeddedObject
//
//
//
//  Inputs:     Name of property to set
//              CInstance to be set
//  Outputs:
//
//  Return:     false if you try to set a property that is not a IUnknown compatible type
//
//  Comments:   CInstance is not released - responsibility of caller
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetEmbeddedObject(LPCWSTR name,  CInstance& cInstance )
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        IWbemClassObject *t_ClassObject = cInstance.GetClassObjectInterface();
        if ( t_ClassObject )
        {
            variant_t v;

            v.vt   = VT_UNKNOWN;
            v.punkVal = t_ClassObject;

            PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
            HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
            PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

            ASSERT_BREAK(SUCCEEDED(hr));
            bRet = (bool)SUCCEEDED(hr);

            if (!bRet)
            {
 				dwLastErr = (hr);
                LogError(IDS_FAILED, IDS_SetEmbeddedObject, name, hr);
            }
        }
		else
		{
			dwLastErr = (WBEM_E_FAILED);
		}
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SetEmbeddedObject);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SetEmbeddedObject);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Get (Byte)
//
//
//
//  Inputs:     Name of property to retrieve
//              BYTE buffer to receive value
//  Outputs:
//
//  Return:     false if you try to get a property that is not a DWORD compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetByte(LPCWSTR name,  BYTE& b) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;
        CIMTYPE  vtType;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, &vtType, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = (SUCCEEDED(hr)) && ((vtType == CIM_SINT8) || (vtType == CIM_UINT8));

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
          if( (v.vt == VT_UI1) && ( (vtType == CIM_SINT8) || (vtType == CIM_UINT8) ) )
            {
                b = v.bVal;
                bRet = true;
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETBYTE, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETBYTE);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETBYTE);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetEmbeddedObject
//
//
//
//  Inputs:     Name of property to retrieve
//              reference to buffer hold pointer to new instance
//  Outputs:
//
//  Return:     false if you try to get a property that is not a object compatible type
//
//  Comments:   Creates CInstance, user is responsible for release
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetEmbeddedObject (LPCWSTR name, CInstance** pInstance,  MethodContext*  pMethodContext) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    ASSERT_BREAK(m_piClassObject && (pInstance != NULL));

    if (m_piClassObject && name && (pInstance != NULL))
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = SUCCEEDED(hr) && (v.vt == VT_UNKNOWN || v.vt == VT_NULL);

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if (v.vt == VT_UNKNOWN)
            {
                IUnknown *t_Unknown = v.punkVal ;
                if ( t_Unknown )
                {
                    IWbemClassObject *t_Object = NULL;
                    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
                    HRESULT t_Result = t_Unknown->QueryInterface ( IID_IWbemClassObject , (void**) &t_Object ) ;
                    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

                    if ( SUCCEEDED ( t_Result ) )
                    {
                        *pInstance = new CInstance(t_Object, pMethodContext);
                        if (pInstance == NULL)
                        {
                            throw CHeap_Exception ( CHeap_Exception :: E_ALLOCATION_ERROR ) ;
                        }
                        bRet = true ;
                    }
					else
					{
						dwLastErr = (t_Result);
					}

                }
				else
				{
					dwLastErr = (WBEM_S_NO_MORE_DATA);
				}
            }
			else
			{
				if (bSuccess)
				{
					dwLastErr = (WBEM_S_NO_MORE_DATA);
				}
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GetEmbeddedObject, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GetEmbeddedObject);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GetEmbeddedObject);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

// bool support //

////////////////////////////////////////////////////////////////////////
//
//  Function:   Set (bool)
//
//
//
//  Inputs:     Name of property to set
//              bool to be set
//  Outputs:
//
//  Return:     false if you try to set a property that is not a bool compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::Setbool(LPCWSTR name,  bool b)
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        VARIANT v;
        VariantInit(&v);

        v.vt   = VT_BOOL;
        if (b)
        {
           v.boolVal = VARIANT_TRUE;
        }
        else
        {
           v.boolVal = VARIANT_FALSE;
        }

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));
        bRet = (bool)SUCCEEDED(hr);

        if (!bRet)
        {
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETBOOL, name, hr);
        }

        VariantClear(&v);
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETBOOL);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETBOOL);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   Get (bool)
//
//
//
//  Inputs:     Name of property to retrieve
//              bool buffer to receive value
//  Outputs:
//
//  Return:     false if you try to get a property that is not a bool compatible type
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::Getbool(LPCWSTR name,  bool&  b) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = (SUCCEEDED(hr)) && (v.vt == VT_BOOL || v.vt == VT_NULL);

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if (v.vt == VT_BOOL)
            {
                if (v.boolVal)
                {
                    b = true;
                }
                else
                {
                    b = false;
                }
                bRet = true;
                ASSERT_BREAK((v.boolVal == VARIANT_TRUE) || (v.boolVal == VARIANT_FALSE));
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETBOOL, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETBOOL);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETBOOL);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   SetVariant
//
//
//
//  Inputs:     const LPCWSTR name - Name of property to set
//              const VARIANT&  variant - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied variant type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetVariant( LPCWSTR name,  const VARIANT& variant )
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        HRESULT hr;

        // I realize the (VARIANT*) cast is ugly, as it is a const,
        // HOWEVER, somewhere nobody seems to understand why we would
        // possibly want to keep things const.  I could copy the VARIANT,
        // but that requires the same cast, so under duress, and to reduce
        // redundant code, I'm casting here.  Did I mention EXTREME
        // DURESS?

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        hr = m_piClassObject->Put(name, 0, (VARIANT*) &variant, NULL );
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);

        if (!bRet)
        {
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETVARIANT, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETVARIANT);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETVARIANT);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetVariant
//
//
//
//  Inputs:     const LPCWSTR name - Name of property to set
//              VARIANT&        variant - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied variant type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetVariant( LPCWSTR name,  VARIANT& variant ) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &variant, NULL, NULL );
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);

        if (!bRet)
        {
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETVARIANT, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETVARIANT);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETVARIANT);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   SetDateTime
//
//
//
//  Inputs:     const LPCWSTR     name - Name of property to set
//              const WBEMTime& wbemtime - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied time type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::SetDateTime( LPCWSTR name,  const WBEMTime& wbemtime )
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name && (wbemtime.IsOk()))
    {
		//GetDMTF may throw so get htis before modifying variant_t
		BSTR bstrTmp = wbemtime.GetDMTF(true);

        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        // Time is stored as a BSTR
        v.vt = VT_BSTR;
        v.bstrVal = bstrTmp;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr  = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);

        if (!bRet)
        {
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETDATETIME, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETDATETIME);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETDATETIME);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetDateTime
//
//
//
//  Inputs:     const LPCWSTR name - Name of property to set
//              WBEMTime&       wbemtime - Value to obtain from Name.
//
//  Outputs:
//
//  Return:     false if the supplied variant type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetDateTime( LPCWSTR name, WBEMTime& wbemtime ) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        //
        // Get the name as a BSTR and pass it into the
        // wbemtime, which handles the conversion internally
        // like a good little class.
        //

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = (SUCCEEDED(hr)) && (v.vt == VT_BSTR || v.vt == VT_NULL);

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if ((v.vt == VT_BSTR) && (v.bstrVal != NULL))
            {
                wbemtime = v.bstrVal;
                bRet = wbemtime.IsOk();

				if (!bRet)
				{
					dwLastErr = (WBEM_E_TYPE_MISMATCH);
				}
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETDATETIME, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETDATETIME);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETDATETIME);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   SetTimeSpan
//
//
//
//  Inputs:     const LPCWSTR     name - Name of property to set
//              const WBEMTimeSpan& wbemtimespan - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied timespan type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////

bool CInstance::SetTimeSpan( LPCWSTR name,  const WBEMTimeSpan& wbemtimespan )
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name && (wbemtimespan.IsOk()))
    {
		//GetBSTR may throw so get this before modifying variant_t
		BSTR bstrTmp = wbemtimespan.GetBSTR();

        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        // Time is stored as a BSTR
        v.vt = VT_BSTR;
        v.bstrVal = bstrTmp;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr  = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);
        if (!bRet)
        {
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETTIMESPAN, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETTIMESPAN);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETTIMESPAN);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetTimeSpan
//
//
//
//  Inputs:     const LPCWSTR name - Name of property to set
//              WBEMTimeSpan&   wbemtimespan - Value to obtain from Name.
//
//  Outputs:
//
//  Return:     false if the supplied timespan type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////

bool CInstance::GetTimeSpan( LPCWSTR name, WBEMTimeSpan& wbemtimespan ) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        //
        // Get the name as a BSTR and pass it into the
        // wbemtimespan, which handles the conversion
        // internally like a good little class.
        //

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = (SUCCEEDED(hr)) && (v.vt == VT_BSTR || v.vt == VT_NULL);

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if ((v.vt == VT_BSTR) && (v.bstrVal != NULL))
            {
                wbemtimespan = v.bstrVal;
                bRet = wbemtimespan.IsOk();
                // This is freed by the VariantClear
                //                      SysFreeString(v.bstrVal);

				if (!bRet)
				{
					dwLastErr = (WBEM_E_TYPE_MISMATCH);
				}
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETTIMESPAN, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETTIMESPAN);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETTIMESPAN);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   SetWBEMINT64
//
//
//
//  Inputs:     const LPCWSTR     name - Name of property to set
//              const WBEMINT64&    wbemint64 - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied wbemint64 type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////

bool CInstance::SetWBEMINT64( LPCWSTR name,  const WBEMINT64& wbemint64 )
{
    // For right now, this is just a CHString.
    return SetWCHARSplat( name, wbemint64 );
}

bool CInstance::SetWBEMINT64( LPCWSTR name, const LONGLONG i64Value )
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    WCHAR szBuff[33];

    _i64tow(i64Value, szBuff, 10);

    return SetWCHARSplat(name, szBuff);
}

bool CInstance::SetWBEMINT64( LPCWSTR name, const ULONGLONG i64Value )
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    WCHAR szBuff[33];

    _ui64tow(i64Value, szBuff, 10);

    return SetWCHARSplat(name, szBuff);
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetWBEMINT64
//
//
//
//  Inputs:     const LPCWSTR     name - Name of property to set
//              WBEMINT64&          wbemint64 - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied wbemint64 type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////

bool CInstance::GetWBEMINT64( LPCWSTR name,  WBEMINT64& wbemint64 ) const
{
    // For right now, this is just a CHString.
    return GetCHString( name, wbemint64 );
}

bool CInstance::GetWBEMINT64( LPCWSTR name, LONGLONG& i64Value) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    CHString    s;
    bool        b = GetWBEMINT64(name, s);

	if (b)
		i64Value = _wtoi64(s);

    return b;
}

bool CInstance::GetWBEMINT64( LPCWSTR name, ULONGLONG& i64Value) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    CHString    s;
    bool        b = GetWBEMINT64(name, s);

	if (b)
		i64Value = _wtoi64(s);

    return b;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   SetWBEMINT16
//
//
//
//  Inputs:     const LPCWSTR     name - Name of property to set
//              const WBEMINT16&    wbemint16 - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied wbemint16 type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////

bool CInstance::SetWBEMINT16( LPCWSTR name,  const WBEMINT16& wbemint16 )
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        VARIANT v;
        VariantInit(&v);

        v.vt   = VT_I2;
        v.iVal = wbemint16;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Put(name, 0, &v, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        ASSERT_BREAK(SUCCEEDED(hr));

        bRet = (bool)SUCCEEDED(hr);
        if (!bRet)
        {
 			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_SETWBEMINT16, name, hr);
        }

        VariantClear(&v);
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_SETWBEMINT16);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_SETWBEMINT16);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetWBEMINT16
//
//
//
//  Inputs:     const LPCWSTR     name - Name of property to set
//              WBEMINT16&          wbemint16 - Value to assign to Name.
//
//  Outputs:
//
//  Return:     false if the supplied wbemint16 type is not correct
//              for the property we are setting.
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////

bool CInstance::GetWBEMINT16( LPCWSTR name,  WBEMINT16& wbemint16 ) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = false;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;
        CIMTYPE  vtType;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, &vtType, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        // If bSuccess is TRUE, we don't need to log an error.  This keeps Gets on
        // null properties from logging an error.
        BOOL bSuccess = (SUCCEEDED(hr)) && (CIM_SINT16 == vtType) && ((v.vt == VT_I2) || (v.vt == VT_NULL));

        ASSERT_BREAK(bSuccess);

        if (SUCCEEDED(hr))
        {
            if ((vtType == CIM_SINT16) && (v.vt == VT_I2))
            {
                wbemint16 = v.iVal;
                bRet = true;
            }
			else
			{
				dwLastErr = (WBEM_S_NO_MORE_DATA);
			}
        }

        if (!bSuccess)
        {
			if (SUCCEEDED(hr))
			{
				hr = WBEM_E_TYPE_MISMATCH;
			}

			dwLastErr = (hr);
            LogError(IDS_FAILED, IDS_GETWBEMINT16, name, hr);
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
			LogError(IDS_InParam, IDS_GETWBEMINT16);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
			LogError(IDS_NOCLASS, IDS_GETWBEMINT16);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   IsNull (LPCWSTR)
//
//  Inputs:     Name of property to check
//
//  Outputs:
//
//  Return:     true if VT_NULL or (VT_BSTR and *bstr == NULL)
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::IsNull(LPCWSTR name) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool bRet = true;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        if (SUCCEEDED(hr))
        {
            if (( v.vt != VT_NULL ) &&
                ( (v.vt != VT_BSTR) || (v.bstrVal != NULL) ))
            {
                bRet = false;
            }
            else
            {
                bRet = true;
            }
        }
        else
        {
            ASSERT_BREAK(0);
            LogError(IDS_FAILED, IDS_CINSTANCEISNULL, name, hr);
        }
    }
    else
    {
        ASSERT_BREAK(0);

        if (m_piClassObject)
		{
			LogError(IDS_InParam, IDS_CINSTANCEISNULL);
		}
		else
		{
			LogError(IDS_NOCLASS, IDS_CINSTANCEISNULL);
		}
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);

    return bRet;
}

////////////////////////////////////////////////////////////////////////
//
//  Function:   GetStatus (LPCWSTR, bool&,VARTYPE &)
//
//
//
//  Inputs:     Name of property to check
//
//  Outputs:
//
//  Return:     true if succeeded, false otherwise
//
//  Comments:
//
////////////////////////////////////////////////////////////////////////
bool CInstance::GetStatus (LPCWSTR name, bool &a_Exists , VARTYPE &a_VarType ) const
{
    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);
    bool t_Status = true ;
	DWORD dwLastErr = 0;

    if (m_piClassObject && name)
    {
        // Variant_t handles the VariantInit/VariantClear
        variant_t v;

        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::WinMgmtTimer);
        HRESULT hr = m_piClassObject->Get(name, 0, &v, NULL, NULL);
        PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::FrameworkTimer);

        if (SUCCEEDED(hr))
        {
            a_Exists = true ;
            a_VarType = v.vt ;
        }
        else
        {
            a_Exists = false ;
        }
    }
    else
    {
        if (m_piClassObject)
		{
			dwLastErr = (WBEM_E_INVALID_PARAMETER);
		}
		else
		{
			dwLastErr = (WBEM_E_FAILED);
		}

        t_Status = false ;
    }

    PROVIDER_INSTRUMENTATION_START(m_pMethodContext, StopWatch::ProviderTimer);
	SetLastError(dwLastErr);

    return t_Status ;
}

////////////////////////////////////////////////////////////////////////
MethodContext* CInstance::GetMethodContext() const
{
    return m_pMethodContext;
}

////////////////////////////////////////////////////////////////////////
void CInstance::LogError(LPCWSTR errorStr, LPCWSTR pFunctionName, LPCWSTR pArgs /*= NULL*/, HRESULT hError /*= -1*/) const
{
    if (IsErrorLoggingEnabled())
    {
        CHString className(IDS_UNKNOWNCLASS);
        // GetCHString("__NAME", className);
        // okay, I'm NOT going through GetCHString to get this
        // why? what happens if it fails? it tries to call this function...
        // can you say "stack overflow?"
        if (m_piClassObject)
        {
            // Variant_t handles the VariantInit/VariantClear
            variant_t v;

            HRESULT hr = m_piClassObject->Get(IDS_CLASS, 0, &v, NULL, NULL);

            ASSERT_BREAK((SUCCEEDED(hr)) && ((v.vt == VT_NULL) || (v.vt == VT_BSTR)));
            if (SUCCEEDED(hr))
            {
                if (    v.bstrVal   !=  NULL
                    &&  v.vt        !=  VT_NULL )
                {
                    className = v.bstrVal;
                }
            }
        }

        // intent is that the error string look like:
        //      ERROR CInstance(Win32_UnlogicalDisk)::SetDoohicky(argVal) thing broke! error code: 0xFF1234
        if (hError != -1)
        {
			if (pArgs == NULL)
			{
				LogErrorMessage6(L"%s%s)::%s %s error# %X", IDS_CINSTANCEERROR, (LPCWSTR)className, pFunctionName, errorStr, hError);
			}
			else
			{
				LogErrorMessage7(L"%s%s)::%s(%s) %s error# %X", IDS_CINSTANCEERROR, (LPCWSTR)className, pFunctionName, pArgs, errorStr, hError);
			}
        }
        else
        {
			if (pArgs == NULL)
			{
				LogErrorMessage5(L"%s%s)::%s %s", IDS_CINSTANCEERROR, (LPCWSTR)className, pFunctionName, errorStr);
			}
			else
			{
				LogErrorMessage6(L"%s%s)::%s(%s) %s", IDS_CINSTANCEERROR, (LPCWSTR)className, pFunctionName, pArgs, errorStr);
			}
        }
    }
}


bool CInstance::SetCHString(LPCWSTR name,  const CHString& str)
{
    return SetWCHARSplat(name, str);
}

bool CInstance::SetCHString(LPCWSTR name, LPCWSTR str)
{
    return SetWCHARSplat(name, str);
}

bool CInstance::SetCharSplat(LPCWSTR name,  LPCWSTR pStr)
{
    return SetWCHARSplat(name, pStr);
}

bool CInstance::SetCHString(LPCWSTR name, LPCSTR str)
{
    return SetWCHARSplat(name, CHString(str));
}

bool CInstance::SetCharSplat( LPCWSTR name,  LPCSTR pStr)
{
    return SetWCHARSplat(name, CHString(pStr));
}

bool CInstance::SetCharSplat(LPCWSTR name,  DWORD dwResID)
{
    ASSERT_BREAK(DEPRECATED);
	SetLastError(WBEM_E_NOT_SUPPORTED);

    return false;
}