|
|
/*++
Copyright (C) 1995-2001 Microsoft Corporation
Module Name:
DATACONV.CPP
Abstract:
Provides a some generic data conversion routines. In particular, OMSVariantChangeType and OMSVariantClear provide the same capabilities as the Ole VariantChangeType and VariantClear functions except that the OMS versions handle more data types.
History:
a-davj 19-Oct-95 Created.
--*/
#include "precomp.h"
#include "resource.h"
#include "CVariant.h"
#include <ole2.h>
//***************************************************************************
//
// char * WideToNarrow
//
// DESCRIPTION:
//
// Takes a WCHAR string and creates a MBS equivalent. The caller should
// free the string when done.
//
// PARAMETERS:
//
// pConv UNICODE string to convert.
//
// RETURN VALUE:
//
// NULL if out of memory, otherwise a mbs string that the caller should free
// via CoTaskMemFree.
//
//***************************************************************************
char * WideToNarrow( IN LPCWSTR pConv){ char * cpRet = NULL; int iMBSLen = wcstombs(NULL,pConv,0) + 1; if(iMBSLen == 0) return NULL; cpRet = (char *)CoTaskMemAlloc(iMBSLen); if(cpRet) { memset(cpRet, 0, iMBSLen); wcstombs(cpRet,pConv,iMBSLen); } return cpRet;}
int gDiag;
char * WideToNarrowA( IN LPCWSTR pConv){ char * cpRet = NULL; int iMBSLen = wcstombs(NULL,pConv,0) + 1; if(iMBSLen == 0) return NULL; cpRet = new char[iMBSLen]; gDiag = iMBSLen; if(cpRet) { memset(cpRet, 0, iMBSLen); wcstombs(cpRet,pConv,iMBSLen); } return cpRet;}//***************************************************************************
//
// SAFEARRAY * OMSSafeArrayCreate
//
// DESCRIPTION:
//
// Creates a safe array.
//
// PARAMETERS:
//
// vt element type
// iNumElements number of elements
//
// RETURN VALUE:
//
// Returns null if there is a problem.
//
//***************************************************************************
SAFEARRAY * OMSSafeArrayCreate( IN VARTYPE vt, IN int iNumElements){ if(iTypeSize(vt) < 1 || iNumElements < 1) return NULL; SAFEARRAYBOUND rgsabound[1]; rgsabound[0].lLbound = 0; rgsabound[0].cElements = iNumElements; return SafeArrayCreate(vt,1,rgsabound);}
//***************************************************************************
//
// SCODE OMSVariantChangeType
//
// DESCRIPTION:
//
// Converts a variant from one type into another. This functions takes the
// same arguments and does the same action as the standard
// VariantChangeType except that it also handles arrays.
//
//
// PARAMETERS:
//
// pDest points to the variant which is to be updated
// pSrc points to the variant that is the source
// wFlags flags which are passed on to VariantChangeType
// vtDest Type that the pDest is conveted to
//
// RETURN VALUE:
//
// S_OK All is well.
// WBEM_E_INVALID_PARAMETER Invalid argument
// WBEM_E_OUT_OF_MEMORY Out of memory
// otherwise various return codes from VariantChangeType, or safe array
// manipulation
//
//***************************************************************************
HRESULT OMSVariantChangeType( IN OUT VARIANTARG * pDest, IN VARIANTARG *pSrc, IN USHORT wFlags, IN VARTYPE vtDest){ SCODE sc;
// Verify arguments and clear out the destination
if(pDest == NULL || pSrc == NULL || iTypeSize(vtDest)<1 || iTypeSize(pSrc->vt)<1) return WBEM_E_INVALID_PARAMETER; // Junk args
OMSVariantClear(pDest);
// if both are arrays,
if(vtDest & VT_ARRAY && pSrc->vt & VT_ARRAY) {
// Set the VARTYPES without the VT_ARRAY bits
VARTYPE vtDestSimple = vtDest & ~VT_ARRAY; VARTYPE vtSrcSimple = pSrc->vt &~ VT_ARRAY;
// Determine the size of the source array. Also make sure that the array
// only has one dimension
unsigned int uDim = SafeArrayGetDim(pSrc->parray); if(uDim != 1) return WBEM_E_FAILED; // Bad array, or too many dimensions
long ix[2] = {0,0}; long lLower, lUpper; sc = SafeArrayGetLBound(pSrc->parray,1,&lLower); if(sc != S_OK) return sc; sc = SafeArrayGetUBound(pSrc->parray,1,&lUpper); if(sc != S_OK) return sc; int iNumElements = lUpper - lLower +1;
// Create a destination array of equal size
SAFEARRAY * pDestArray = OMSSafeArrayCreate(vtDestSimple,iNumElements); if(pDestArray == NULL) return WBEM_E_FAILED; // Most likely a bad type!
// For each element in the source array
for(ix[0] = lLower; ix[0] <= lUpper && sc == S_OK; ix[0]++) { CVariant varSrc, varDest; // Set Temp CVariant to the source data
sc = SafeArrayGetElement(pSrc->parray,ix,varSrc.GetDataPtr()); if(sc != S_OK) break; varSrc.SetType(vtSrcSimple);
// Convert to destination data using VariantConvert
sc = VariantChangeType(varDest.GetVarPtr(),varSrc.GetVarPtr(),wFlags,vtDestSimple); if(sc != S_OK) break;
// Set destination data into the array
if(vtDestSimple == VT_BSTR || vtDestSimple == VT_UNKNOWN || vtDestSimple == VT_DISPATCH) sc = SafeArrayPutElement(pDestArray,ix,(void *)varDest.GetBstr()); else sc = SafeArrayPutElement(pDestArray,ix,(void *)varDest.GetDataPtr());
}
if(sc != S_OK){ SafeArrayDestroy(pDestArray); } else { // set the VARTYPE of the destination
pDest->vt = vtDest; pDest->parray = pDestArray; } return sc; } // if one, but not the other is an array, bail out
if(vtDest & VT_ARRAY || pSrc->vt & VT_ARRAY) return WBEM_E_FAILED;
// Attempt to use standard conversion
return VariantChangeType(pDest,pSrc,wFlags,vtDest); }
//***************************************************************************
//
// OMSVariantClear
//
// DESCRIPTION:
//
// Does the same as the Ole VariantClear function except
// that it also sets the data to all 0.
//
// PARAMETERS:
//
// pClear Variant to be cleared.
//
// RETURN VALUE:
//
// Result from VariantClear, most always S_OK
//
//***************************************************************************
HRESULT OMSVariantClear( IN OUT VARIANTARG * pClear){ HRESULT sc; sc = VariantClear(pClear); memset((void *)&pClear->lVal,0,8); return sc;}
//***************************************************************************
//
// int ITypeSize
//
// DESCRIPTION:
//
// Gets the number of bytes acutally used to store
// a variant type. 0 if the type is unknown
//
// PARAMETERS:
//
// vtTest Type in question.
//
//
// RETURN VALUE:
//
// see description
//
//***************************************************************************
int iTypeSize( IN VARTYPE vtTest){ int iRet; vtTest &= ~ VT_ARRAY; // get rid of possible array bit
switch (vtTest) { case VT_UI1: case VT_LPSTR: iRet = 1; break; case VT_LPWSTR: case VT_BSTR: case VT_I2: iRet = 2; break; case VT_I4: case VT_R4: iRet = 4; break; case VT_R8: iRet = 8; break; case VT_BOOL: iRet = sizeof(VARIANT_BOOL); break; case VT_ERROR: iRet = sizeof(SCODE); break; case VT_CY: iRet = sizeof(CY); break; case VT_DATE: iRet = sizeof(DATE); break; case CIM_SINT64: case CIM_UINT64: iRet = 8; break;
default: iRet = 0; } return iRet;}
|
