able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/winmgmt/wbemcomn/var.cpp

2961 lines
66 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) 1996-2001 Microsoft Corporation
Module Name:
VAR.H
Abstract:
CVar & CVarVector implemntation
History:
16-Apr-96 a-raymcc Created.
12//17/98 sanjes - Partially Reviewed for Out of Memory.
18-Mar-99 a-dcrews Added out-of-memory exception handling
--*/
#include "precomp.h"
#include <stdio.h>
#include <stdlib.h>
#include <var.h>
#include <wbemutil.h>
#include <genutils.h>
#include <wbemidl.h>
#include <corex.h>
#include <arrtempl.h>
#include <olewrap.h>
static wchar_t g_szNullVarString[1] = {0};
static wchar_t* g_pszNullVarString = &g_szNullVarString[0];
//***************************************************************************
//
// CVar::Empty
//
// Constructor helper.
//
// This merely clears everything. VT_EMPTY is the default.
//
//***************************************************************************
void CVar::Init()
{
m_nStatus = no_error;
m_vt = VT_EMPTY;
m_bCanDelete = TRUE;
memset(&m_value, 0, sizeof(METAVALUE));
}
//***************************************************************************
//
// CVar::~CVar
//
// Destructor.
//
//***************************************************************************
CVar::~CVar()
{
Empty();
}
//***************************************************************************
//
// CVar::CVar
//
// Copy constructor. This is implemented via the assignment operator.
//
//***************************************************************************
CVar::CVar(CVar &Src)
{
m_vt = VT_EMPTY;
m_nStatus = no_error;
memset(&m_value, 0, sizeof(METAVALUE));
*this = Src;
}
//***************************************************************************
//
// CVar::operator =
//
// NOTES:
// Observe that VT_EX_CVARVECTOR is dedicated to embedded CVarVector objects.
// Also, only pointer types require a new allocation + copy, whereas
// most of the simple types are directly assignable, in the <default>
// label of the switch statement.
//
//***************************************************************************
CVar& CVar::operator =(CVar &Src)
{
Empty();
m_vt = Src.m_vt;
m_nStatus = m_nStatus;
m_bCanDelete = TRUE;
switch (m_vt) {
case VT_LPSTR:
// Check for an allocation failure
if ( NULL != Src.m_value.pStr )
{
m_value.pStr = new char[strlen(Src.m_value.pStr) + 1];
if ( NULL == m_value.pStr )
{
throw CX_MemoryException();
}
strcpy( m_value.pStr, Src.m_value.pStr );
}
else
{
m_value.pStr = NULL;
}
break;
case VT_LPWSTR:
case VT_BSTR:
// Check for an allocation failure
if ( NULL != Src.m_value.pWStr )
{
m_value.pWStr = new wchar_t[wcslen(Src.m_value.pWStr) + 1];
if ( NULL == m_value.pWStr )
{
throw CX_MemoryException();
}
wcscpy( m_value.pWStr, Src.m_value.pWStr );
}
else
{
m_value.pWStr = NULL;
}
break;
case VT_BLOB:
// This will natively throw an exception, but make sure the
// original value is cleared in case an exception is thrown
// so we don't AV destructing this object
ZeroMemory( &m_value.Blob, sizeof( m_value.Blob ) );
m_value.Blob = BlobCopy(&Src.m_value.Blob);
break;
case VT_CLSID:
m_value.pClsId = new CLSID(*Src.m_value.pClsId);
// Check for a failed allocation
if ( NULL == m_value.pClsId )
{
throw CX_MemoryException();
}
break;
case VT_DISPATCH:
m_value.pDisp = Src.m_value.pDisp;
if(m_value.pDisp) m_value.pDisp->AddRef();
break;
case VT_UNKNOWN:
m_value.pUnk = Src.m_value.pUnk;
if(m_value.pUnk) m_value.pUnk->AddRef();
break;
// CVarVector
// ==========
case VT_EX_CVARVECTOR:
m_value.pVarVector = new CVarVector(*Src.m_value.pVarVector);
// Check for a failed allocation
if ( NULL == m_value.pVarVector )
{
throw CX_MemoryException();
}
break;
// All remaining simple types.
// ===========================
default:
m_value = Src.m_value;
}
return *this;
}
//***************************************************************************
//
// CVar::operator ==
//
// Equality test operator.
//
//***************************************************************************
int CVar::operator ==(CVar &Src)
{
return CompareTo(Src, TRUE);
}
BOOL CVar::CompareTo(CVar& Src, BOOL bIgnoreCase)
{
// If types are not the same, forget the test.
// ===========================================
if (m_vt != Src.m_vt)
return 0;
// If here, the types are the same, so test
// the fields.
// ========================================
switch (m_vt) {
case VT_LPSTR:
if(bIgnoreCase)
{
if (_stricmp(m_value.pStr, Src.m_value.pStr) == 0)
return 1;
}
else
{
if (strcmp(m_value.pStr, Src.m_value.pStr) == 0)
return 1;
}
break;
case VT_LPWSTR:
case VT_BSTR:
if(bIgnoreCase)
{
if (wbem_wcsicmp(m_value.pWStr, Src.m_value.pWStr) == 0)
return 1;
}
else
{
if (wcscmp( m_value.pWStr, Src.m_value.pWStr) == 0)
return 1;
}
break;
case VT_BLOB:
if (BlobLength(&m_value.Blob) != BlobLength(&Src.m_value.Blob))
return 0;
if (memcmp(BlobDataPtr(&m_value.Blob), BlobDataPtr(&Src.m_value.Blob),
BlobLength(&m_value.Blob)) == 0)
return 1;
break;
case VT_CLSID:
if (memcmp(m_value.pClsId, Src.m_value.pClsId, sizeof(CLSID)) == 0)
return 1;
break;
// CVarVector
// ==========
case VT_EX_CVARVECTOR:
if (m_value.pVarVector == Src.m_value.pVarVector)
return 1;
if (m_value.pVarVector == 0 || Src.m_value.pVarVector == 0)
return 0;
return *m_value.pVarVector == *Src.m_value.pVarVector;
// All remaining simple types.
// ===========================
case VT_I1:
return m_value.cVal == Src.m_value.cVal;
case VT_UI1:
return m_value.bVal == Src.m_value.bVal;
case VT_I2:
return m_value.iVal == Src.m_value.iVal;
case VT_UI2:
return m_value.wVal == Src.m_value.wVal;
case VT_I4:
return m_value.lVal == Src.m_value.lVal;
case VT_UI4:
return m_value.dwVal == Src.m_value.dwVal;
case VT_BOOL:
return m_value.boolVal == Src.m_value.boolVal;
case VT_R8:
return m_value.dblVal == Src.m_value.dblVal;
case VT_R4:
return m_value.fltVal == Src.m_value.fltVal;
case VT_DISPATCH:
// Note: no proper comparison of embedded objects.
return m_value.pDisp == Src.m_value.pDisp;
case VT_UNKNOWN:
// Note: no proper comparison of embedded objects.
return m_value.pUnk == Src.m_value.pUnk;
case VT_FILETIME:
if (memcmp(&m_value.Time, &Src.m_value.Time, sizeof(FILETIME)) == 0)
return 1;
case VT_NULL:
return 1;
}
return 0;
}
//***************************************************************************
//
// CVar::Empty
//
// Clears the CVar to 'empty', deallocates any objects based on pointers,
// unless bCanDelete is set to FALSE, indicating that the stored pointer
// is owned by somebody else.
//
//***************************************************************************
void CVar::Empty()
{
if(m_bCanDelete)
{
// Only pointer types require a deallocation phase.
// =================================================
switch (m_vt) {
case VT_LPSTR: delete m_value.pStr; break;
case VT_LPWSTR: delete m_value.pWStr; break;
case VT_BSTR: delete m_value.Str; break;
case VT_BLOB: BlobClear(&m_value.Blob); break;
case VT_CLSID: delete m_value.pClsId; break;
case VT_EX_CVARVECTOR: delete m_value.pVarVector; break;
case VT_DISPATCH: if(m_value.pDisp) m_value.pDisp->Release(); break;
case VT_UNKNOWN: if(m_value.pUnk) m_value.pUnk->Release(); break;
}
}
memset(&m_value, 0, sizeof(METAVALUE));
m_vt = VT_EMPTY;
m_nStatus = no_error;
m_bCanDelete = TRUE;
}
//***************************************************************************
//
// CVar::IsDataNull
//
// Determines if this CVar contains a NULL pointer.
//
//***************************************************************************
BOOL CVar::IsDataNull()
{
if(m_vt == VT_LPWSTR && m_value.pWStr == NULL)
return TRUE;
if(m_vt == VT_LPSTR && m_value.pStr == NULL)
return TRUE;
if(m_vt == VT_BSTR && m_value.Str == NULL)
return TRUE;
if(m_vt == VT_DISPATCH && m_value.pDisp == NULL)
return TRUE;
if(m_vt == VT_UNKNOWN && m_value.pUnk == NULL)
return TRUE;
return FALSE;
}
//***************************************************************************
//
// CVar::SetRaw
//
// Creates a CVar from raw data. Sets the type and copies the right
// number of bytes from the source to METAVALUE.
//
//***************************************************************************
void CVar::SetRaw(int vt, void* pvData, int nDataLen)
{
m_vt = vt;
memcpy(&m_value, pvData, nDataLen);
m_nStatus = no_error;
m_bCanDelete = TRUE;
}
//***************************************************************************
//
// CVar::SetSafeArray
//
// PARAMETERS:
// nType
// This is the VT_ type indicator of the SAFEARRAY.
// pArray
// This is the pointer to the SAFEARRAY which will be used as
// a source. The SAFEARRAY is not acquired; it is copied.
//
//***************************************************************************
void CVar::SetSafeArray(int nType, SAFEARRAY *pArray)
{
CVarVector *pVec = NULL;
m_nStatus = no_error;
try
{
pVec = new CVarVector(nType, pArray);
// Check for a failed allocation
if ( NULL == pVec )
{
throw CX_MemoryException();
}
SetVarVector(pVec, TRUE);
}
catch (CX_MemoryException)
{
// SetVarVector can throw an exception
// m_value aquires the pVec pointer, so auto delete will not work
if (NULL != pVec)
{
delete pVec;
pVec = NULL;
}
throw;
}
}
//***************************************************************************
//
// CVar::GetNewSafeArray
//
// RETURN VALUE:
// A pointer to newly allocated SAFEARRAY which must be released by
// SafeArrayDestroy.
//
//***************************************************************************
SAFEARRAY *CVar::GetNewSafeArray()
{
CVarVector *p = (CVarVector *) GetVarVector();
return p->GetNewSafeArray();
}
//***************************************************************************
//
// CVar::SetValue
//
// Sets the value based on an incoming VARIANT. A VARIANT containing
// a SAFEARRAY is supported as long as it is not an array of VARIANTs.
// Some of the other VARIANT types, such as IUnknown, Currency, etc.,
// are not supported. The complete list is:
// VT_UI1, VT_I2, VT_I4, VT_BSTR, VT_BOOL
// VT_R4, VT_R8, or SAFEARRAY of any of these.
//
// PARAMETERS:
// pSrc
// A pointer to the source VARIANT. This is treated as read-only.
//
// RETURN VALUES:
// no_error
// Returned on succcess.
// unsupported
// Returned if the VARIANT contains unsupported types.
//
//***************************************************************************
int CVar::SetVariant(VARIANT *pSrc, BOOL fOptimize /*=FALSE*/)
{
if(pSrc == NULL)
{
SetAsNull();
return no_error;
}
// If a SAFEARRAY, check it.
// =========================
if (pSrc->vt & VT_ARRAY)
{
CVarVector *pVec = NULL;
try
{
int nType = pSrc->vt & 0xFF; // Find the type of the array
// BEGIN MODIFIED by a-levn
// First, check if the incoming SAFEARRAY is NULL
// ==============================================
SAFEARRAY *pSafeArr;
/*
if(pSrc->parray == NULL)
{
pSafeArr = NULL;
}
else
{
// Make a copy of the SAFEARRAY using CSafeArray which will NOT
// autodestruct
// ============================================================
CSafeArray array(pSrc->parray, nType, CSafeArray::no_delete, 0);
pSafeArr = array.GetArray();
}
*/
pSafeArr = pSrc->parray;
pVec = new CVarVector( nType, pSafeArr, fOptimize );
// Check for an allocation failure.
if ( NULL == pVec )
{
throw CX_MemoryException();
}
// END MODIFIED
if (pVec->Status() != no_error)
{
// If here, the SAFEARRAY was not compatible.
// ==========================================
delete pVec;
pVec = NULL;
m_nStatus = unsupported;
m_vt = VT_EMPTY;
return unsupported;
}
SetVarVector(pVec, TRUE);
return no_error;
}
catch(CX_MemoryException)
{
// new and SetVarVector can throw exceptions
// m_value aquires the pVec pointer, so an auto delete will not work
if (NULL != pVec)
{
delete pVec;
pVec = NULL;
}
throw;
}
}
// Simple copies.
// ==============
switch (pSrc->vt) {
case VT_NULL:
SetAsNull();
return no_error;
case VT_UI1:
SetByte(pSrc->bVal);
return no_error;
case VT_I2:
SetShort(pSrc->iVal);
return no_error;
case VT_I4:
SetLong(pSrc->lVal);
return no_error;
case VT_R4:
SetFloat(pSrc->fltVal);
return no_error;
case VT_R8:
SetDouble(pSrc->dblVal);
return no_error;
case VT_BSTR:
SetBSTR(pSrc->bstrVal);
return no_error;
case VT_BOOL:
SetBool(pSrc->boolVal);
return no_error;
case VT_DISPATCH:
SetDispatch(V_DISPATCH(pSrc));
return no_error;
case VT_UNKNOWN:
SetUnknown(V_UNKNOWN(pSrc));
return no_error;
}
m_nStatus = unsupported;
return unsupported;
}
//***************************************************************************
//
// CVar::GetNewVariant
//
// RETURN VALUE:
// A pointer to a new VARIANT which contains the value of object.
// If the original value was a SAFEARRAY, then the VARIANT will contain
// the embedded SAFEARRAY.
//
//***************************************************************************
void CVar::FillVariant(VARIANT* pNew, BOOL fOptimized/* = FALSE*/)
{
switch (m_vt) {
case VT_NULL:
V_VT(pNew) = VT_NULL;
break;
case VT_BOOL:
V_VT(pNew) = VT_BOOL;
V_BOOL(pNew) = (m_value.boolVal ? VARIANT_TRUE : VARIANT_FALSE);
break;
case VT_BSTR:
// Set type afterwards here so if the SysAlloc throws an exception, the
// type will not have been reset to a VT_BSTR which could cause a subtle
// memory corruption (or worse) if VariantClear is called - SJS
V_BSTR(pNew) = COleAuto::_SysAllocString(m_value.Str);
V_VT(pNew) = VT_BSTR;
break;
case VT_DISPATCH:
V_VT(pNew) = VT_DISPATCH;
V_DISPATCH(pNew) = m_value.pDisp;
if(m_value.pDisp) m_value.pDisp->AddRef();
break;
case VT_UNKNOWN:
V_VT(pNew) = VT_UNKNOWN;
V_UNKNOWN(pNew) = m_value.pUnk;
if(m_value.pUnk) m_value.pUnk->AddRef();
break;
case VT_UI1:
V_VT(pNew) = VT_UI1;
V_UI1(pNew) = m_value.bVal;
break;
case VT_I4:
V_VT(pNew) = VT_I4;
V_I4(pNew) = m_value.lVal;
break;
case VT_I2:
V_VT(pNew) = VT_I2;
V_I2(pNew) = m_value.iVal;
break;
case VT_R4:
V_VT(pNew) = VT_R4;
V_R4(pNew) = m_value.fltVal;
break;
case VT_R8:
V_VT(pNew) = VT_R8;
V_R8(pNew) = m_value.dblVal;
break;
// An embedded CVarVector which must be converted
// to a SAFEARRAY.
// ==============================================
case VT_EX_CVARVECTOR:
{
// Set type afterwards here so if GetNewSafeArray throws an exception, the
// type will not have been reset to an Array which could cause a subtle
// memory corruption (or worse) if VariantClear is called - SJS
if ( fOptimized && m_value.pVarVector->IsOptimized() )
{
// This will get the actual SAFEARRAY pointer without
// copying what's underneath. Underlying code should
// not clear the array, since it is being acquired
V_ARRAY(pNew) = m_value.pVarVector->GetSafeArray( TRUE );
V_VT(pNew) = m_value.pVarVector->GetType() | VT_ARRAY;
}
else
{
V_ARRAY(pNew) = m_value.pVarVector->GetNewSafeArray();
V_VT(pNew) = m_value.pVarVector->GetType() | VT_ARRAY;
}
}
break;
default:
COleAuto::_VariantClear(pNew);
}
}
VARIANT *CVar::GetNewVariant()
{
VARIANT *pNew = new VARIANT;
// Check for an allocation failure.
if ( NULL == pNew )
{
throw CX_MemoryException();
}
COleAuto::_VariantInit(pNew);
FillVariant(pNew);
return pNew;
}
//***************************************************************************
//
//***************************************************************************
int CVar::DumpText(FILE *fStream)
{
return unsupported;
}
//***************************************************************************
//
// CVar::SetLPWSTR
//
// Sets the value of the CVar to the indicated LPWSTR.
//
// PARAMETERS:
// pStr
// A pointer to the source string.
// bAcquire
// If TRUE, then the ownership of pStr is trasferred and becomes
// the internal pointer to the string. If FALSE, then the string
// is copied.
//
//***************************************************************************
BOOL CVar::SetLPWSTR(LPWSTR pStr, BOOL bAcquire)
{
m_vt = VT_LPWSTR;
if (bAcquire)
{
m_value.pWStr = pStr;
return TRUE;
}
else
{
// Check for an allocation failure
if ( NULL != pStr )
{
m_value.pWStr = new wchar_t[wcslen(pStr) + 1];
if ( NULL == m_value.pWStr )
{
throw CX_MemoryException();
}
wcscpy( m_value.pWStr, pStr );
}
else
{
m_value.pWStr = NULL;
}
return TRUE;
}
}
//***************************************************************************
//
// CVar::SetLPSTR
//
// Sets the value of the CVar to the indicated LPSTR.
//
// PARAMETERS:
// pStr
// A pointer to the source string.
// bAcquire
// If TRUE, then the ownership of pStr is trasferred and becomes
// the internal pointer to the string. If FALSE, then the string
// is copied (it must have been allocated with operator new).
//
//***************************************************************************
BOOL CVar::SetLPSTR(LPSTR pStr, BOOL bAcquire)
{
m_vt = VT_LPSTR;
if (bAcquire)
{
m_value.pStr = pStr;
return TRUE;
}
else
{
if ( NULL != pStr)
{
m_value.pStr = new char[strlen(pStr) + 1];
// On failure, throw an exception
if ( NULL == m_value.pStr )
{
throw CX_MemoryException();
}
strcpy( m_value.pStr, pStr );
}
else
{
m_value.pStr = NULL;
}
return TRUE;
}
}
//***************************************************************************
//
// CVar::SetBSTR
//
// Sets the value of the CVar to the indicated BSTR.
//
// NOTE: This BSTR value is actually stored as an LPWSTR to avoid
// apartment-threading restrictions on real BSTR objects allocated
// with COleAuto::_SysAllocString.
//
// PARAMETERS:
// str
// A pointer to the string, which is copied into an internal LPWSTR.
// bAcquire
// If FALSE, then the BSTR is treated as read-only and copied.
// If TRUE, then this function becomes owner of the BSTR and
// frees it after the copy is made.
//
//***************************************************************************
BOOL CVar::SetBSTR(BSTR str, BOOL bAcquire)
{
m_vt = VT_BSTR;
if (str == 0) {
m_value.pWStr = 0;
return TRUE;
}
// Check for an allocation failure
if ( NULL != str )
{
m_value.pWStr = new wchar_t[wcslen(str) + 1];
// If allocation fails, throw an exception
if ( NULL == m_value.pWStr )
{
throw CX_MemoryException();
}
wcscpy( m_value.pWStr, str );
}
else
{
m_value.pWStr = NULL;
}
// Check that this succeeded before we free
// the string passed into us
if ( NULL != m_value.pWStr )
{
if (bAcquire)
COleAuto::_SysFreeString(str);
}
// return whether or not we obtained a value
return ( NULL != m_value.pWStr );
}
//***************************************************************************
//
// CVar::GetBSTR
//
// Returns the BSTR value of the current object.
//
// RETURN VALUE:
// A newly allocated BSTR which must be freed with COleAuto::_SysFreeString().
//
//***************************************************************************
BSTR CVar::GetBSTR()
{
if (m_vt != VT_BSTR)
return NULL;
return COleAuto::_SysAllocString(m_value.pWStr);
}
void CVar::SetDispatch(IDispatch* pDisp)
{
m_vt = VT_DISPATCH;
m_value.pDisp = pDisp;
if(pDisp)
{
pDisp->AddRef();
}
}
void CVar::SetUnknown(IUnknown* pUnk)
{
m_vt = VT_UNKNOWN;
m_value.pUnk = pUnk;
if(pUnk)
{
pUnk->AddRef();
}
}
//***************************************************************************
//
// CVar::SetBlob
//
// Sets the object to the value of the BLOB object.
//
// PARAMETERS:
// pBlob
// A pointer to a valid VT_BLOB object.
// bAcquire
// If TRUE, then the pointer to the data will be acquired. It must
// have been allocated with operator new in the current process,
// since operator delete will be used to free it.
//
//***************************************************************************
void CVar::SetBlob(BLOB *pBlob, BOOL bAcquire)
{
m_vt = VT_BLOB;
if (pBlob == 0)
BlobClear(&m_value.Blob);
else if (!bAcquire)
m_value.Blob = BlobCopy(pBlob);
else
m_value.Blob = *pBlob;
}
//***************************************************************************
//
// CVar::SetClsId
//
// Sets the value of the object to a CLSID.
//
// PARAMETERS:
// pClsId
// Points the source CLSID.
// bAcquire
// If TRUE, the ownership of the pointer is transferred to the
// object. The CLSID must have been allocated with operator new.
// If FALSE, the caller retains ownership and a copy is made.
//
//***************************************************************************
void CVar::SetClsId(CLSID *pClsId, BOOL bAcquire)
{
m_vt = VT_CLSID;
if (pClsId == 0)
m_value.pClsId = 0;
else
{
m_value.pClsId = new CLSID(*pClsId);
// Check for an allocation failure.
if ( NULL == m_value.pClsId )
{
throw CX_MemoryException();
}
}
}
//***************************************************************************
//
// CVar::SetVarVector
//
// Sets the value of the object to the specified CVarVector. This
// allows the CVar to contain a complete array.
//
// PARAMETERS:
// pVec
// A pointer to the CVarVector object which is the source.
// bAcquire
// If TRUE, then ownership of the CVarVector is transferred to
// the object. If FALSE, a new copy of the CVarVector is made and
// the caller retains ownership.
//
//***************************************************************************
void CVar::SetVarVector(CVarVector *pVec, BOOL bAcquire)
{
m_vt = VT_EX_CVARVECTOR;
if (bAcquire) {
// If here, we acquire the caller's pointer.
// =========================================
m_value.pVarVector = pVec;
return;
}
// If here, make a copy.
// =====================
m_value.pVarVector = new CVarVector(*pVec);
// Check for an allocation failure.
if ( NULL == m_value.pVarVector )
{
throw CX_MemoryException();
}
}
int CVar::GetOleType()
{
if(m_vt == VT_EX_CVARVECTOR)
{
if(m_value.pVarVector == NULL) return VT_ARRAY;
else return VT_ARRAY | m_value.pVarVector->GetType();
}
else
{
return m_vt;
}
}
//***************************************************************************
//
// CVar::GetText
//
// Produces textual representation of the Var's type and data
//
// PARAMETERS:
// long lFlags reseved, must be 0
// long lType CIM_TYPE
// LPCWSTR szFormat optional formatting string
//
//
//***************************************************************************
BSTR CVar::GetText(long lFlags, long lType, LPCWSTR szFormat)
{
if(m_vt == VT_EX_CVARVECTOR)
{
// When we get the text for the array, make sure the CIM_FLAG_ARRAY is masked out
BSTR strTemp = GetVarVector()->GetText(lFlags, lType & ~CIM_FLAG_ARRAY);
CSysFreeMe auto1(strTemp);
WCHAR* wszValue = new WCHAR[COleAuto::_SysStringLen(strTemp) + 3];
// Check for allocation failures
if ( NULL == wszValue )
{
throw CX_MemoryException();
}
CVectorDeleteMe<WCHAR> auto2(wszValue);
wcscpy(wszValue, L"{");
wcscat(wszValue, strTemp);
wcscat(wszValue, L"}");
BSTR strRet = COleAuto::_SysAllocString(wszValue);
return strRet;
}
WCHAR* wszValue = new WCHAR[100];
// Check for allocation failures
if ( NULL == wszValue )
{
throw CX_MemoryException();
}
WCHAR* pwc;
int i;
if(m_vt == VT_NULL)
{
delete [] wszValue;
return NULL;
}
if(lType == 0)
lType = m_vt;
try
{
switch(lType)
{
case CIM_SINT8:
swprintf(wszValue, szFormat ? szFormat : L"%d", (long)(signed char)GetByte());
break;
case CIM_UINT8:
swprintf(wszValue, szFormat ? szFormat : L"%d", GetByte());
break;
case CIM_SINT16:
swprintf(wszValue, szFormat ? szFormat : L"%d", (long)GetShort());
break;
case CIM_UINT16:
swprintf(wszValue, szFormat ? szFormat : L"%d", (long)(USHORT)GetShort());
break;
case CIM_SINT32:
swprintf(wszValue, szFormat ? szFormat : L"%d", GetLong());
break;
case CIM_UINT32:
swprintf(wszValue, szFormat ? szFormat : L"%lu", (ULONG)GetLong());
break;
case CIM_BOOLEAN:
swprintf(wszValue, L"%s", (GetBool()?L"TRUE":L"FALSE"));
break;
case CIM_REAL32:
{
// Since the decimal point can be localized, and MOF text should
// always be english, we will return values localized to 0x409,
CVar var( GetFloat() );
// If this fails, we can't guarantee a good value,
// so throw an exception.
if ( !var.ChangeTypeToEx( VT_BSTR ) )
{
throw CX_Exception();
}
wcscpy( wszValue, var.GetLPWSTR() );
}
break;
case CIM_REAL64:
{
// Since the decimal point can be localized, and MOF text should
// always be english, we will return values localized to 0x409,
CVar var( GetDouble() );
// If this fails, we can't guarantee a good value,
// so throw an exception.
if ( !var.ChangeTypeToEx( VT_BSTR ) )
{
throw CX_Exception();
}
wcscpy( wszValue, var.GetLPWSTR() );
}
break;
case CIM_CHAR16:
if(GetShort() == 0)
wcscpy(wszValue, L"0x0");
else
swprintf(wszValue, L"'\\x%X'", (WCHAR)GetShort());
break;
case CIM_OBJECT:
swprintf(wszValue, L"\"not supported\"");
break;
case CIM_REFERENCE:
case CIM_DATETIME:
case CIM_STRING:
case CIM_SINT64:
case CIM_UINT64:
{
// Escape all the quotes
// =====================
int nStrLen = wcslen(GetLPWSTR());
delete [] wszValue;
wszValue = NULL;
wszValue = new WCHAR[nStrLen*2+10];
// Check for allocation failures
if ( NULL == wszValue )
{
throw CX_MemoryException();
}
wszValue[0] = L'"';
pwc = wszValue+1;
for(i = 0; i < (int)nStrLen; i++)
{
WCHAR wch = GetLPWSTR()[i];
if(wch == L'\n')
{
*(pwc++) = L'\\';
*(pwc++) = L'n';
}
else if(wch == L'\t')
{
*(pwc++) = L'\\';
*(pwc++) = L't';
}
else if(wch == L'"' || wch == L'\\')
{
*(pwc++) = L'\\';
*(pwc++) = wch;
}
else
{
*(pwc++) = wch;
}
}
*(pwc++) = L'"';
*pwc = 0;
}
break;
default:
swprintf(wszValue, L"\"not supported\"");
break;
}
BSTR strRes = COleAuto::_SysAllocString(wszValue);
// Still need to clean up this value
delete [] wszValue;
return strRes;
}
catch (...)
{
// Cleanup always if this has a value
if ( NULL != wszValue )
{
delete [] wszValue;
}
// Rethrow the exception
throw;
}
}
BSTR CVar::TypeToText(int nType)
{
const WCHAR* pwcType;
switch(nType)
{
case VT_I1:
pwcType = L"sint8";
break;
case VT_UI1:
pwcType = L"uint8";
break;
case VT_I2:
pwcType = L"sint16";
break;
case VT_UI2:
pwcType = L"uint16";
break;
case VT_I4:
pwcType = L"sint32";
break;
case VT_UI4:
pwcType = L"uint32";
break;
case VT_I8:
pwcType = L"sint64";
break;
case VT_UI8:
pwcType = L"uint64";
break;
case VT_BOOL:
pwcType = L"boolean";
break;
case VT_R4:
pwcType = L"real32";
break;
case VT_R8:
pwcType = L"real64";
break;
case VT_BSTR:
pwcType = L"string";
break;
case VT_DISPATCH:
pwcType = L"object";
break;
case VT_UNKNOWN:
pwcType = L"object";
break;
default:
return NULL;
}
return COleAuto::_SysAllocString(pwcType);
}
BSTR CVar::GetTypeText()
{
if ( m_vt == VT_EX_CVARVECTOR )
{
return TypeToText(GetVarVector()->GetType());
}
else
{
return TypeToText(m_vt);
}
}
BOOL CVar::ChangeTypeTo(VARTYPE vtNew)
{
// TBD: there are more efficient ways!
// ===================================
// Create a VARIANT
// ================
VARIANT v;
CClearMe auto1(&v);
COleAuto::_VariantInit(&v);
FillVariant(&v);
// Coerce it
// =========
HRESULT hres = COleAuto::_WbemVariantChangeType(&v, &v, vtNew);
if(FAILED(hres))
return FALSE;
// Load it back in
// ===============
Empty();
SetVariant(&v, TRUE);
// If this is an array, we will now be sitting on an optimized array
// meaning that we will have acquired the actual safe array - so we should
// make sure that the CVarVector cleans up the array when it is no longer
// necessary. We will clear out the variant so it doesn't get deleted
// when VariantClear is called.
if ( m_vt == VT_EX_CVARVECTOR )
{
m_value.pVarVector->SetRawArrayBinding( CSafeArray::auto_delete );
ZeroMemory( &v, sizeof(v) );
}
return TRUE;
}
// Performs localized changes (defaults to 0x409 for this)
BOOL CVar::ChangeTypeToEx(VARTYPE vtNew, LCID lcid /*=0x409*/)
{
// TBD: there are more efficient ways!
// ===================================
// Create a VARIANT
// ================
VARIANT v;
CClearMe auto1(&v);
COleAuto::_VariantInit(&v);
FillVariant(&v);
// Coerce it
// =========
try
{
HRESULT hres = COleAuto::_VariantChangeTypeEx(&v, &v, lcid, 0L, vtNew);
if(FAILED(hres))
return FALSE;
}
catch(...)
{
return FALSE;
}
// Load it back in
// ===============
Empty();
SetVariant(&v, TRUE);
// If this is an array, we will now be sitting on an optimized array
// meaning that we will have acquired the actual safe array - so we should
// make sure that the CVarVector cleans up the array when it is no longer
// necessary. We will clear out the variant so it doesn't get deleted
// when VariantClear is called.
if ( m_vt == VT_EX_CVARVECTOR )
{
m_value.pVarVector->SetRawArrayBinding( CSafeArray::auto_delete );
ZeroMemory( &v, sizeof(v) );
}
return TRUE;
}
BOOL CVar::ToSingleChar()
{
// Defer to CVarVector for arrays
// ==============================
if(m_vt == VT_EX_CVARVECTOR)
{
return GetVarVector()->ToSingleChar();
}
// Anything that's not a string follows normal OLE rules
// =====================================================
if(m_vt != VT_BSTR)
{
return ChangeTypeTo(VT_I2);
}
// It's a string. Make sure the length is 1
// ========================================
LPCWSTR wsz = GetLPWSTR();
if(wcslen(wsz) != 1)
return FALSE;
// Take the first character
// ========================
WCHAR wc = wsz[0];
Empty();
SetShort(wc);
return TRUE;
}
BOOL CVar::ToUI4()
{
// Defer to CVarVector for arrays
// ==============================
if(m_vt == VT_EX_CVARVECTOR)
{
return GetVarVector()->ToUI4();
}
// Create a VARIANT
// ================
VARIANT v;
CClearMe auto1(&v);
COleAuto::_VariantInit(&v);
FillVariant(&v);
// Coerce it
// =========
HRESULT hres = COleAuto::_WbemVariantChangeType(&v, &v, VT_UI4);
if(FAILED(hres))
return FALSE;
// Load it back in
// ===============
Empty();
// Here we cheat and reset to VT_I4 so we can natively reset
V_VT(&v) = VT_I4;
SetVariant(&v);
return TRUE;
}
//***************************************************************************
//
// CVarVector::CVarVector
//
// Default constructor. The caller should not attempt to add any
// elements when the internal type is VT_EMPTY. Objects constructed
// with this constructor should only be used as l-values in an
// assignment of CVarVector objects.
//
//***************************************************************************
CVarVector::CVarVector()
: m_pSafeArray( NULL ),
m_pRawData( NULL )
{
m_Array.Empty();
m_nType = VT_EMPTY;
m_nStatus = no_error;
}
//***************************************************************************
//
// CVarVector::CVarVector
//
// This is the standard constructor.
//
// PARAMETERS:
// nVarType
// An OLE VT_ type indicator. Heterogeneous arrays are possible
// if the type VT_EX_CVAR is used. Embedded CVarVectors can
// occur, since a CVar can in turn hold a CVarVector.
//
// nInitSize
// The starting size of the internal CFlexArray. See FLEXARRY.CPP.
// nGrowBy
// The "grow by" factor of the internal CFlexArray. See FLEXARRAY.CPP.
//
//***************************************************************************
CVarVector::CVarVector(
int nVarType,
int nInitSize,
int nGrowBy
) :
m_Array(nInitSize, nGrowBy),
m_pSafeArray( NULL ),
m_pRawData( NULL )
{
m_nType = nVarType;
m_nStatus = no_error;
}
//***************************************************************************
//
// CVarVector::CVarVector
//
// Alternate constructor to build a new CVarVector based on a
// SAFEARRAY object. The only supported types for the SAFEARRAY
// are VT_BSTR, VT_UI1, VT_I2, VT_I4, VT_R4, and VT_R8.
//
// PARAMETERS:
// nVarType
// The VT_ type indicator of the incoming SAFEARRAY.
// pSrc
// A pointer to a SAFEARRAY, which is treated as read-only.
//
// NOTES:
// This will set the internal m_nStatus variable to <unsupported> if
// an unsupported VT_ type is in the SAFEARRAY. The caller can immediately
// call CVarVector::Status() after construction to see if the operation
// was successful.
//
//***************************************************************************
CVarVector::CVarVector(int nVarType, SAFEARRAY *pSrc, BOOL fOptimized /*= FALSE*/)
: m_pSafeArray( NULL ),
m_pRawData( NULL )
{
SAFEARRAY* pNew = NULL;
try
{
m_nType = nVarType;
// If not a valid vector type, this is unsupported
if ( !IsValidVectorArray( nVarType, pSrc ) )
{
m_nStatus = unsupported;
return;
}
if(pSrc == NULL)
{
// NULL safearray --- empty
// ========================
m_nStatus = no_error;
return;
}
// Bind to the incoming SAFEARRAY, but don't delete it during destruct.
// ====================================================================
if(COleAuto::_SafeArrayGetDim(pSrc) != 1)
{
m_nStatus = unsupported;
return;
}
long lLBound, lUBound;
COleAuto::_SafeArrayGetLBound(pSrc, 1, &lLBound);
COleAuto::_SafeArrayGetUBound(pSrc, 1, &lUBound);
if(lLBound != 0)
{
// Non-0-based safearray --- since CSafeArray doesn't support that, and
// we can't change pSrc, create a copy
// ====================================================================
if(FAILED(COleAuto::_SafeArrayCopy(pSrc, &pNew)))
{
m_nStatus = failed;
return;
}
SAFEARRAYBOUND sfb;
sfb.cElements = (lUBound - lLBound) + 1;
sfb.lLbound = 0;
COleAuto::_SafeArrayRedim(pNew, &sfb);
}
else
{
pNew = pSrc;
}
if ( fOptimized )
{
// If we rebased the array, then we need to clean it up on delete, otherwise,
// we don't
if ( pNew != pSrc )
{
m_pSafeArray = new CSafeArray( pNew, nVarType, CSafeArray::auto_delete | CSafeArray::bind);
}
else
{
m_pSafeArray = new CSafeArray( pNew, nVarType, CSafeArray::no_delete | CSafeArray::bind);
}
if ( NULL == m_pSafeArray )
{
throw CX_MemoryException();
}
if ( m_pSafeArray->Status() != CSafeArray::no_error )
{
delete m_pSafeArray;
m_pSafeArray = NULL;
m_nStatus = failed;
}
m_nStatus = no_error;
}
else
{
CSafeArray sa(pNew, nVarType, CSafeArray::no_delete | CSafeArray::bind);
for (int i = 0; i < sa.Size(); i++) {
CVar* pVar = NULL;
switch (m_nType) {
case VT_BOOL:
{
VARIANT_BOOL boolVal = sa.GetBoolAt(i);
pVar = new CVar(boolVal, VT_BOOL);
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_UI1:
{
BYTE b = sa.GetByteAt(i);
pVar = new CVar(b);
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_I2:
{
SHORT s = sa.GetShortAt(i);
pVar = new CVar(s);
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_I4:
{
LONG l = sa.GetLongAt(i);
pVar = new CVar(l);
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_R4:
{
float f = sa.GetFloatAt(i);
pVar = new CVar(f);
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_R8:
{
double d = sa.GetDoubleAt(i);
pVar = new CVar(d);
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_BSTR:
{
BSTR bstr = sa.GetBSTRAtThrow(i);
CSysFreeMe auto1(bstr);
pVar = new CVar(VT_BSTR, bstr, FALSE);
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_DISPATCH:
{
IDispatch* pDisp = sa.GetDispatchAt(i);
CReleaseMe auto2(pDisp);
pVar = new CVar;
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
pVar->SetDispatch(pDisp);
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
case VT_UNKNOWN:
{
IUnknown* pUnk = sa.GetUnknownAt(i);
CReleaseMe auto3(pUnk);
pVar = new CVar;
// Check for allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
pVar->SetUnknown(pUnk);
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
break;
}
default:
m_nStatus = unsupported;
if(pNew != pSrc)
COleAuto::_SafeArrayDestroy(pNew);
return;
}
}
if(pNew != pSrc)
COleAuto::_SafeArrayDestroy(pNew);
m_nStatus = no_error;
} // Else not bound
}
catch (CX_MemoryException)
{
// SafeArrayCopy, GetBSTRAtThrow, new can all throw exceptions
m_nStatus = failed;
if(pNew != pSrc)
COleAuto::_SafeArrayDestroy(pNew);
throw;
}
}
//***************************************************************************
//
// CVarVector::GetNewSafeArray
//
// Allocates a new SAFEARRAY equivalent to the current CVarVector.
//
// RETURN VALUE:
// A new SAFEARRAY pointer which must be deallocated with
// SafeArrayDestroy(). Returns NULL on error or unsupported types.
//
//***************************************************************************
SAFEARRAY *CVarVector::GetNewSafeArray()
{
SAFEARRAY *pRetValue = NULL;
CSafeArray *pArray = new CSafeArray(m_nType, CSafeArray::no_delete);
// Check for an allocation failure
if ( NULL == pArray )
{
throw CX_MemoryException();
}
CDeleteMe<CSafeArray> auto1(pArray);
int nSize = Size();
for (int i = 0; i < nSize; i++) {
CVar v;
FillCVarAt( i, v );
switch (m_nType) {
case VT_UI1:
pArray->AddByte(v.GetByte());
break;
case VT_I2:
pArray->AddShort(v.GetShort());
break;
case VT_I4:
pArray->AddLong(v.GetLong());
break;
case VT_R4:
pArray->AddFloat(v.GetFloat());
break;
case VT_R8:
pArray->AddDouble(v.GetDouble());
break;
case VT_BOOL:
pArray->AddBool(v.GetBool());
break;
case VT_BSTR:
{
BSTR s = v.GetBSTR();
CSysFreeMe auto2(s);
pArray->AddBSTR(s);
break;
}
case VT_DISPATCH:
{
IDispatch* pDisp = v.GetDispatch();
CReleaseMe auto3(pDisp);
pArray->AddDispatch(pDisp);
break;
}
case VT_UNKNOWN:
{
IUnknown* pUnk = v.GetUnknown();
CReleaseMe auto4(pUnk);
pArray->AddUnknown(pUnk);
break;
}
default:
// For unsupported types, return a NULL.
// Since we constructed the SAFEARRAY object to
// not delete the SAFEARRAY and we have encountered
// a condition where the internal SAFEARRAY of
// CSafeArray should not be returned, we have
// to switch our destruct policy.
// ================================================
pArray->SetDestructorPolicy(CSafeArray::auto_delete);
return 0;
} // SWITCH
}// FOR enum elements
// Final cleanup. Get the SAFEARRAY pointer, and delete
// the wrapper.
// =====================================================
pArray->Trim();
pRetValue = pArray->GetArray();
return pRetValue;
}
//***************************************************************************
//
// CVarVector::GetSafeArray
//
// Returns a direct pointer to the underlying SafeArray. If fAcquire is
// set, the array is returned, and cleared from underneath
//
// RETURN VALUE:
// A SAFEARRAY pointer which must be deallocated with
// SafeArrayDestroy() if fAcquire is set to TRUE
//
//***************************************************************************
SAFEARRAY *CVarVector::GetSafeArray( BOOL fAcquire /* = FALSE */)
{
SAFEARRAY* psa = NULL;
_DBG_ASSERT( NULL != m_pSafeArray );
if ( NULL != m_pSafeArray )
{
if ( fAcquire )
{
// Unaccess data if appropriate
if ( NULL != m_pRawData )
{
m_pSafeArray->Unaccess();
m_pRawData = NULL;
}
psa = m_pSafeArray->GetArray();
// Now clear the array
m_pSafeArray->SetDestructorPolicy( CSafeArray::no_delete );
delete m_pSafeArray;
m_pSafeArray = NULL;
}
else
{
psa = m_pSafeArray->GetArray();
}
}
return psa;
}
//***************************************************************************
//
// CVarVector::~CVarVector
//
// Destructor.
//
//***************************************************************************
CVarVector::~CVarVector()
{
Empty();
}
//***************************************************************************
//
// CVarVector::Empty
//
//***************************************************************************
void CVarVector::Empty()
{
if ( NULL != m_pSafeArray )
{
delete m_pSafeArray;
}
for (int i = 0; i < m_Array.Size(); i++) {
delete (CVar *) m_Array[i];
}
m_Array.Empty();
m_nType = VT_EMPTY;
m_nStatus = no_error;
m_pSafeArray = NULL;
m_pRawData = NULL;
}
//***************************************************************************
//
// CVarVector::CVarVector
//
// Copy constructor. This is implemented via the assignment operator.
//
//***************************************************************************
CVarVector::CVarVector(CVarVector &Src)
: m_pSafeArray( NULL ),
m_pRawData( NULL )
{
m_nType = 0;
m_nStatus = no_error;
*this = Src;
}
//***************************************************************************
//
// CVarVector::operator =
//
// Assignment operator.
//
//***************************************************************************
CVarVector& CVarVector::operator =(CVarVector &Src)
{
Empty();
if ( NULL != Src.m_pSafeArray )
{
m_pSafeArray = new CSafeArray( *Src.m_pSafeArray );
if ( NULL != m_pSafeArray )
{
if ( m_pSafeArray->Status() != CSafeArray::no_error )
{
delete m_pSafeArray;
throw CX_MemoryException();
}
}
else
{
throw CX_MemoryException();
}
}
else
{
for (int i = 0; i < Src.m_Array.Size(); i++)
{
CVar* pVar = new CVar(*(CVar *) Src.m_Array[i]);
// Check for an allocation failure
if ( NULL == pVar )
{
throw CX_MemoryException();
}
if ( m_Array.Add( pVar ) != CFlexArray::no_error )
{
delete pVar;
throw CX_MemoryException();
}
}
}
m_nStatus = Src.m_nStatus;
m_nType = Src.m_nType;
return *this;
}
//***************************************************************************
//
// CVarVector::operator ==
//
// Equality test operator.
//
//***************************************************************************
int CVarVector::operator ==(CVarVector &Src)
{
return CompareTo(Src, TRUE);
}
BOOL CVarVector::CompareTo(CVarVector& Src, BOOL bIgnoreCase)
{
if (m_nType != Src.m_nType)
return 0;
// Need to do things indirectly here, since we are possibly mixing
// CVarVectors not on SAFEARRAYs and those on SAFEARRAYs
int Src_Size = Src.Size();
if ( Size() != Src_Size )
return 0;
// Allocate the variants
for (int i = 0; i < Src_Size; i++)
{
CVar varThis;
CVar varThat;
FillCVarAt( i, varThis );
Src.FillCVarAt( i, varThat );
if ( !varThis.CompareTo( varThat, bIgnoreCase ) )
return 0;
}
return 1;
}
//***************************************************************************
//
// CVarVector::Add
//
// Adds a new CVar to the array. A reference is used so that anonymous
// objects can be constructed in the Add() call:
//
// pVec->Add(CVar(33));
//
// PARAMETERS:
// Value
// A reference to a CVar object of the correct type for the array.
// No type checking is done.
//
// RETURN VALUE:
// no_error
// failed
//
//***************************************************************************
int CVarVector::Add(CVar &Value)
{
if ( NULL != m_pSafeArray )
{
switch ( Value.GetType() )
{
case VT_BOOL:
// We can store differently from what is expected in Variants, hence we
// need to make sure to convert
m_pSafeArray->AddBool( Value.GetBool() ? VARIANT_TRUE : VARIANT_FALSE );
break;
case VT_UI1:
m_pSafeArray->AddByte( Value.GetByte() );
break;
case VT_I2:
m_pSafeArray->AddShort( Value.GetShort() );
break;
case VT_I4:
m_pSafeArray->AddLong( Value.GetLong() );
break;
case VT_R4:
m_pSafeArray->AddFloat( Value.GetFloat() );
break;
case VT_R8:
m_pSafeArray->AddDouble( Value.GetDouble() );
break;
case VT_BSTR:
m_pSafeArray->AddBSTR( Value.GetBSTR() );
break;
case VT_UNKNOWN:
m_pSafeArray->AddUnknown( Value.GetUnknown() );
break;
default:
return failed;
}
return no_error;
}
else
{
CVar *p = new CVar(Value);
// Check for allocation failures
if ( NULL == p )
{
return failed;
}
if (m_Array.Add(p) != CFlexArray::no_error)
{
delete p;
return failed;
}
return no_error;
}
}
//***************************************************************************
//
// CVarVector::Add
//
// Adds a new CVar to the array. This overload simply takes ownership
// of the incoming pointer and adds it directly.
//
// PARAMETERS:
// pAcquiredPtr
// A pointer to a CVar object which is acquired by the vector.
//
// RETURN VALUE:
// no_error
// failed
//
//***************************************************************************
int CVarVector::Add(CVar *pAcquiredPtr)
{
// Not a valid operation if we are sitting on a SAFEARRAY
_DBG_ASSERT( NULL == m_pSafeArray );
// We don't support this if we are optimized to
// us a safe array directly
if ( NULL != m_pSafeArray )
{
return failed;
}
if (m_Array.Add(pAcquiredPtr) != CFlexArray::no_error)
{
return failed;
}
return no_error;
}
//***************************************************************************
//
// CVarVector::RemoveAt
//
// Removes the array element at the specified index.
//
// PARAMETERS:
// nIndex
// The location at which to remove the element.
//
// RETURN VALUE:
// no_error
// On success.
// failed
// On range errors, etc.
//
//***************************************************************************
int CVarVector::RemoveAt(int nIndex)
{
if ( NULL != m_pSafeArray )
{
if ( m_pSafeArray->RemoveAt( nIndex ) != CSafeArray::no_error )
{
return failed;
}
}
else
{
CVar *p = (CVar *) m_Array[nIndex];
delete p;
if (m_Array.RemoveAt(nIndex) != CFlexArray::no_error)
return failed;
}
return no_error;
}
//***************************************************************************
//
// CVarVector::InsertAt
//
// Inserts the new element at the specified location.
//
// PARAMETERS:
// nIndex
// The location at which to add the new element.
// Value
// A reference to the new value.
//
// RETURN VALUE:
// no_error
// On success.
// failed
// An invalid nIndex value was specified.
//
//***************************************************************************
int CVarVector::InsertAt(int nIndex, CVar &Value)
{
// We don't support this if we are optimized to
// us a safe array directly
_DBG_ASSERT( NULL == m_pSafeArray );
if ( NULL != m_pSafeArray )
{
return failed;
}
CVar *pNew = new CVar(Value);
// Check for allocation failures
if ( NULL == pNew )
{
return failed;
}
if (m_Array.InsertAt(nIndex, pNew) != CFlexArray::no_error)
{
delete pNew;
return failed;
}
return no_error;
}
BSTR CVarVector::GetText(long lFlags, long lType/* = 0 */)
{
// Construct an array of values
// ============================
BSTR* aTexts = NULL;
int i;
try
{
aTexts = new BSTR[Size()];
// Check for allocation failures
if ( NULL == aTexts )
{
throw CX_MemoryException();
}
memset(aTexts, 0, Size() * sizeof(BSTR));
int nTotal = 0;
for(i = 0; i < Size(); i++)
{
CVar v;
FillCVarAt( i, v );
aTexts[i] = v.GetText(lFlags, lType);
nTotal += COleAuto::_SysStringLen(aTexts[i]) + 2; // 2: for ", "
}
// Allocate a BSTR to contain them all
// ===================================
BSTR strRes = COleAuto::_SysAllocStringLen(NULL, nTotal);
CSysFreeMe auto2(strRes);
*strRes = 0;
for(i = 0; i < Size(); i++)
{
if(i != 0)
{
wcscat(strRes, L", ");
}
wcscat(strRes, aTexts[i]);
COleAuto::_SysFreeString(aTexts[i]);
}
delete [] aTexts;
aTexts = NULL;
BSTR strPerfectRes = COleAuto::_SysAllocString(strRes);
return strPerfectRes;
}
catch(CX_MemoryException)
{
// new, GetText, COleAuto::_SysAllocStringLen and COleAuto::_SysAllocString can all throw exceptions
if (NULL != aTexts)
{
for(int x = 0; x < Size(); x++)
{
if (NULL != aTexts[x])
COleAuto::_SysFreeString(aTexts[x]);
}
delete [] aTexts;
aTexts = NULL;
}
throw;
}
}
BOOL CVarVector::ToSingleChar()
{
// Handle this differently if we are sitting directly on a safearray
if ( NULL != m_pSafeArray )
{
int nSize = Size();
// One element at a time is converted and copied into the new array
CSafeArray* pNewArray = new CSafeArray( VT_I2, CSafeArray::auto_delete, nSize );
for ( int i = 0; i < nSize; i++ )
{
CVar v;
FillCVarAt( i, v );
if ( !v.ToSingleChar() )
{
delete pNewArray;
return FALSE;
}
if ( pNewArray->AddShort( v.GetShort() ) != CSafeArray::no_error )
{
delete pNewArray;
return FALSE;
}
}
// Now replace the old pointer
delete m_pSafeArray;
m_pSafeArray = pNewArray;
}
else
{
// One element at a time, convert in place
for(int i = 0; i < Size(); i++)
{
if(!GetAt(i).ToSingleChar())
return FALSE;
}
}
// Since all of the conversions succeeded, we will
// assume the vector type is now VT_I2.
m_nType = VT_I2;
return TRUE;
}
BOOL CVarVector::ToUI4()
{
// Handle this differently if we are sitting directly on a safearray
if ( NULL != m_pSafeArray )
{
int nSize = Size();
// One element at a time is converted and copied into the new array
CSafeArray* pNewArray = new CSafeArray( VT_I4, CSafeArray::auto_delete, nSize );
for ( int i = 0; i < nSize; i++ )
{
CVar v;
FillCVarAt( i, v );
if ( !v.ToUI4() )
{
delete pNewArray;
return FALSE;
}
if ( pNewArray->AddLong( v.GetLong() ) != CSafeArray::no_error )
{
delete pNewArray;
return FALSE;
}
}
// Now replace the old pointer
delete m_pSafeArray;
m_pSafeArray = pNewArray;
}
else
{
// One element at a time, convert in place
for(int i = 0; i < Size(); i++)
{
if(!GetAt(i).ToUI4())
return FALSE;
}
}
// Since all of the conversions succeeded, we will
// assume the vector type is now VT_I4.
m_nType = VT_I4;
return TRUE;
}
BOOL CVarVector::IsValidVectorType( int nVarType )
{
if ( VT_BOOL == nVarType ||
VT_UI1 == nVarType ||
VT_I2 == nVarType ||
VT_I4 == nVarType ||
VT_R4 == nVarType ||
VT_R8 == nVarType ||
VT_BSTR == nVarType ||
VT_DISPATCH == nVarType ||
VT_UNKNOWN == nVarType )
{
return TRUE;
}
else
{
return FALSE;
}
}
BOOL CVarVector::IsValidVectorArray( int nVarType, SAFEARRAY* pArray )
{
BOOL fReturn = IsValidVectorType( nVarType );
if ( !fReturn )
{
// We do supprt VT_VARIANT if the array is zero length
if ( VT_VARIANT == nVarType )
{
if ( NULL != pArray )
{
// If lUBound is 1 less than lLBound, it's a zero length array
long lLBound = 0,
lUBound = 0;
COleAuto::_SafeArrayGetLBound(pArray, 1, &lLBound);
COleAuto::_SafeArrayGetUBound(pArray, 1, &lUBound);
fReturn = ( lUBound == ( lLBound - 1 ) );
}
} // IF VT_VARIANT
} // IF Invalid Type
return fReturn;
}
int CVarVector::Size()
{
if ( NULL == m_pSafeArray )
{
return m_Array.Size();
}
else
{
return m_pSafeArray->Size();
}
}
HRESULT CVarVector::AccessRawArray( void** ppv )
{
if ( NULL == m_pSafeArray )
{
return E_FAIL;
}
return m_pSafeArray->Access( ppv );
}
HRESULT CVarVector::UnaccessRawArray( void )
{
if ( NULL == m_pSafeArray )
{
return E_FAIL;
}
if ( NULL != m_pRawData )
{
m_pRawData = NULL;
}
return m_pSafeArray->Unaccess();
}
HRESULT CVarVector::InternalRawArrayAccess( void )
{
if ( NULL == m_pSafeArray )
{
return E_FAIL;
}
if ( NULL != m_pRawData )
{
return WBEM_E_INVALID_OPERATION;
}
return m_pSafeArray->Access( &m_pRawData );
}
CVar& CVarVector::GetAt(int nIndex)
{
// Not a valid operation if we are sitting on a SAFEARRAY
_DBG_ASSERT( NULL == m_pSafeArray );
if ( NULL == m_pSafeArray )
{
return *(CVar *) m_Array[nIndex];
}
else
{
throw CX_VarVectorException();
}
}
CVar& CVarVector::operator [](int nIndex)
{
// Not a valid operation if we are sitting on a SAFEARRAY
_DBG_ASSERT( NULL == m_pSafeArray );
if ( NULL == m_pSafeArray )
{
return *(CVar *) m_Array[nIndex];
}
else
{
throw CX_VarVectorException();
}
}
void CVarVector::FillCVarAt(int nIndex, CVar& vTemp)
{
if ( NULL == m_pSafeArray )
{
vTemp = *(CVar *) m_Array[nIndex];
}
else if ( NULL == m_pRawData )
{
switch( m_nType )
{
case VT_BOOL:
vTemp.SetBool( m_pSafeArray->GetBoolAt( nIndex ) );
break;
case VT_UI1:
vTemp.SetByte( m_pSafeArray->GetByteAt( nIndex ) );
break;
case VT_I2:
vTemp.SetShort( m_pSafeArray->GetShortAt( nIndex ) );
break;
case VT_I4:
vTemp.SetLong( m_pSafeArray->GetLongAt( nIndex ) );
break;
case VT_R4:
vTemp.SetFloat( m_pSafeArray->GetFloatAt( nIndex ) );
break;
case VT_R8:
vTemp.SetDouble( m_pSafeArray->GetDoubleAt( nIndex ) );
break;
case VT_BSTR:
vTemp.SetBSTR( m_pSafeArray->GetBSTRAtThrow( nIndex ), TRUE );
break;
case VT_UNKNOWN:
IUnknown* pUnk = m_pSafeArray->GetUnknownAt(nIndex);
CReleaseMe rm( pUnk );
vTemp.SetUnknown( pUnk );
break;
}
}
else
{
// When we pull data in this state, we're using the CVar as a
// passthrough, so it won't do any allocations or addref()
// hence it shouldn't do any cleanup either.
int nDataLen = 0L;
void* pvElement = m_pRawData;
switch( m_nType )
{
case VT_UI1:
nDataLen = sizeof(BYTE);
pvElement = (void*) &((BYTE*) m_pRawData)[nIndex];
break;
case VT_BOOL:
case VT_I2:
nDataLen = sizeof(short);
pvElement = (void*) &((short*) m_pRawData)[nIndex];
break;
case VT_I4:
nDataLen = sizeof(long);
pvElement = (void*) &((long*) m_pRawData)[nIndex];
break;
case VT_R4:
nDataLen = sizeof(float);
pvElement = (void*) &((float*) m_pRawData)[nIndex];
break;
case VT_R8:
nDataLen = sizeof(double);
pvElement = (void*) &((double*) m_pRawData)[nIndex];
break;
case VT_BSTR:
nDataLen = sizeof(BSTR);
pvElement = (void*) &((BSTR*) m_pRawData)[nIndex];
// If the BSTR is a NULL, old code converted to "", so
// we will point to a pointer to "".
if ( (*(BSTR*) pvElement ) == NULL )
{
pvElement = (void*) &g_pszNullVarString;
}
break;
case VT_UNKNOWN:
nDataLen = sizeof(IUnknown*);
pvElement = (void*) &((IUnknown**) m_pRawData)[nIndex];
break;
}
// Splat the raw value in, and Can Delete is FALSE
// This is strictly to support optimized pass-through logic
vTemp.SetRaw( m_nType, pvElement, nDataLen);
vTemp.SetCanDelete( FALSE );
}
}
// This only works if there are no elements in the safe array
BOOL CVarVector::MakeOptimized( int nVarType, int nInitSize, int nGrowBy )
{
BOOL fReturn = FALSE;
if ( NULL == m_pSafeArray )
{
if ( m_Array.Size() == 0 )
{
m_pSafeArray = new CSafeArray( nVarType, CSafeArray::auto_delete, nInitSize, nGrowBy );
if ( NULL != m_pSafeArray )
{
if ( m_pSafeArray->Status() == CSafeArray::no_error )
{
m_nType = nVarType;
m_nStatus = no_error;
fReturn = TRUE;
}
else
{
delete m_pSafeArray;
m_pSafeArray = NULL;
m_nStatus = failed;
}
}
else
{
m_nStatus = failed;
}
} // IF no elements in array
}
return fReturn;
}
BOOL CVarVector::DoesVectorTypeMatchArrayType( void )
{
// If we have an underlying safe array, sometimes the actualy type of the
// data in the safe array may be different from the type that was reported
// to us in VARANTARG. This info is critical in determining how we will
// go about handling certain operations
BOOL fReturn = TRUE;
if ( NULL != m_pSafeArray )
{
VARTYPE vt;
// Only return TRUE if the actual types are equal
if ( m_pSafeArray->GetActualVarType( &vt ) == no_error )
{
fReturn = ( vt == m_nType );
}
else
{
fReturn = FALSE;
}
}
return fReturn;
}
void CVarVector::SetRawArrayBinding( int nBinding )
{
if ( NULL != m_pSafeArray )
{
m_pSafeArray->SetDestructorPolicy( nBinding );
}
}
HRESULT CVarVector::SetRawArrayData( void* pvData, int nNumElements, int nElementSize )
{
_DBG_ASSERT( NULL != m_pSafeArray );
HRESULT hr = WBEM_S_NO_ERROR;
if ( NULL != m_pSafeArray )
{
if ( m_pSafeArray->SetRawData( pvData, nNumElements, nElementSize ) != CSafeArray::no_error )
hr = WBEM_E_FAILED;
}
else
{
hr = WBEM_E_FAILED;
}
return hr;
}
HRESULT CVarVector::GetRawArrayData( void* pvDest, int nBuffSize )
{
_DBG_ASSERT( NULL != m_pSafeArray );
HRESULT hr = WBEM_S_NO_ERROR;
if ( NULL != m_pSafeArray )
{
if ( m_pSafeArray->GetRawData( pvDest, nBuffSize ) != CSafeArray::no_error )
hr = WBEM_E_FAILED;
}
else
{
hr = WBEM_E_FAILED;
}
return hr;
}
BOOL CVarVector::SetRawArraySize( int nSize )
{
_DBG_ASSERT( NULL != m_pSafeArray );
BOOL fReturn = FALSE;
if ( NULL != m_pSafeArray )
{
m_pSafeArray->SetRawArrayMaxElement( nSize - 1 );
fReturn = TRUE;
}
return fReturn;
}
int CVarVector::GetElementSize( void )
{
_DBG_ASSERT( NULL != m_pSafeArray );
int nReturn = 0L;
if ( NULL != m_pSafeArray )
{
nReturn = m_pSafeArray->ElementSize();
}
return nReturn;
}
Reference in a new issue Copy permalink