version 1.35, 2008/12/16 18:56:55
|
version 1.35.4.9, 2009/10/30 15:51:52
|
|
|
| |
#include "CMPI_String.h" | #include "CMPI_String.h" |
#include "CMPI_Value.h" | #include "CMPI_Value.h" |
|
#include "CMPISCMOUtilities.h" |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
|
|
} | } |
| |
/** | /** |
|
Function to convert CMPIValue to SCMBUnion |
|
*/ |
|
SCMBUnion value2SCMOValue(const CMPIValue* data,const CMPIType type) |
|
{ |
|
SCMBUnion scmoData; |
|
scmoData.simple.val.u64 = data->uint64; |
|
scmoData.simple.hasValue = 1; |
|
|
|
if (!(type&CMPI_ARRAY)) |
|
{ |
|
|
|
switch (type) |
|
{ |
|
case CMPI_dateTime: |
|
{ |
|
CIMDateTimeRep * cimdt = |
|
CMPISCMOUtilities::scmoDateTimeFromCMPI(data->dateTime); |
|
if (cimdt) |
|
{ |
|
scmoData.dateTimeValue = *cimdt; |
|
} |
|
break; |
|
} |
|
case CMPI_chars: |
|
{ |
|
scmoData.extString.pchar = (char*)data; |
|
if (scmoData.extString.pchar) |
|
{ |
|
scmoData.extString.length = |
|
strlen(scmoData.extString.pchar); |
|
} |
|
break; |
|
} |
|
case CMPI_charsptr: |
|
{ |
|
if (data && *(char**)data) |
|
{ |
|
scmoData.extString.pchar = *(char**)data; |
|
scmoData.extString.length = |
|
strlen(scmoData.extString.pchar); |
|
} |
|
break; |
|
} |
|
case CMPI_string: |
|
{ |
|
|
|
scmoData.extString.pchar = (char*)data->string->hdl; |
|
if (scmoData.extString.pchar) |
|
{ |
|
scmoData.extString.length = |
|
strlen(scmoData.extString.pchar); |
|
} |
|
break; |
|
} |
|
case CMPI_ref: |
|
case CMPI_instance: |
|
{ |
|
if (data->inst) |
|
{ |
|
scmoData.extRefPtr = (SCMOInstance*)data->inst->hdl; |
|
} |
|
break; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
//Array Implementation goes here .... |
|
} |
|
return scmoData; |
|
} |
|
|
|
|
|
/** |
Function to convert CMPIValue to CIMValue | Function to convert CMPIValue to CIMValue |
*/ | */ |
CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc) | CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc) |
|
|
} | } |
// When data is not NULL and data->array is also set | // When data is not NULL and data->array is also set |
CMPIArray *ar=data->array; | CMPIArray *ar=data->array; |
CMPIData *aData=(CMPIData*)ar->hdl; |
CMPIData *aData=(CMPIData*)((CMPI_Array*)ar->hdl)->hdl; |
| |
//Get the type of the elements in the array | //Get the type of the elements in the array |
CMPIType aType=aData->type&~CMPI_ARRAY; | CMPIType aType=aData->type&~CMPI_ARRAY; |
|
|
switch( aType ) | switch( aType ) |
{ | { |
case CMPI_ref: | case CMPI_ref: |
CopyToEncArray(CIMObjectPath,ref); |
{ |
|
Array<CIMObjectPath> arCIMObjectPath(aSize); |
|
for (int i=0; i<aSize; i++) |
|
{ |
|
SCMOInstance* scmoInst = |
|
(SCMOInstance*)aData[i].value.ref->hdl; |
|
CIMObjectPath ref; |
|
scmoInst->getCIMObjectPath(ref); |
|
arCIMObjectPath[i]=ref; |
|
} |
|
v.set(arCIMObjectPath); |
|
} |
break; | break; |
| |
case CMPI_dateTime: | case CMPI_dateTime: |
CopyToEncArray(CIMDateTime,dateTime); | CopyToEncArray(CIMDateTime,dateTime); |
break; | break; |
case CMPI_instance: | case CMPI_instance: |
CopyToEncArray(CIMObject,inst); |
{ |
|
Array<CIMObject> arCIMInstance(aSize); |
|
for (int i=0; i<aSize; i++) |
|
{ |
|
SCMOInstance* scmoInst = |
|
(SCMOInstance*)aData[i].value.inst->hdl; |
|
CIMInstance inst; |
|
scmoInst->getCIMInstance(inst); |
|
CIMObject obj(inst); |
|
arCIMInstance[i]=obj; |
|
} |
|
v.set(arCIMInstance); |
|
} |
break; | break; |
case CMPI_boolean: | case CMPI_boolean: |
CopyToArray(Boolean,boolean); | CopyToArray(Boolean,boolean); |
|
|
case CMPI_instance: | case CMPI_instance: |
if( data->inst && data->inst->hdl ) | if( data->inst && data->inst->hdl ) |
{ | { |
v.set(*((CIMObject*) data->inst->hdl)); |
SCMOInstance* scmoInst = (SCMOInstance*)data->inst->hdl; |
|
CIMInstance inst; |
|
scmoInst->getCIMInstance(inst); |
|
CIMObject obj(inst); |
|
v.set(obj); |
} | } |
else | else |
{ | { |
|
|
case CMPI_ref: | case CMPI_ref: |
if( data->ref && data->ref->hdl ) | if( data->ref && data->ref->hdl ) |
{ | { |
v.set(*((CIMObjectPath*)data->ref->hdl)); |
SCMOInstance* scmoInst = (SCMOInstance*)data->ref->hdl; |
|
CIMObjectPath ref; |
|
scmoInst->getCIMObjectPath(ref); |
|
v.set(ref); |
} | } |
else | else |
{ | { |
|
|
switch( aType ) | switch( aType ) |
{ | { |
case CMPI_ref: | case CMPI_ref: |
CopyFromEncArray(CIMObjectPath,CMPIObjectPath,ref); |
{ |
|
Array<CIMObjectPath> arRef; |
|
v.get(arRef); |
|
for (int i=0; i<aSize; i++) |
|
{ |
|
SCMOInstance* scmoRef = |
|
CMPISCMOUtilities:: |
|
getSCMOFromCIMObjectPath(arRef[i]); |
|
aData[i].value.ref= |
|
reinterpret_cast<CMPIObjectPath*>( |
|
new CMPI_Object( |
|
scmoRef, |
|
CMPI_Object::ObjectTypeObjectPath)); |
|
} |
|
} |
break; | break; |
| |
case CMPI_dateTime: | case CMPI_dateTime: |
CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime); | CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime); |
break; | break; |
|
|
case CMPI_instance: | case CMPI_instance: |
if (v.getType() == CIMTYPE_OBJECT) | if (v.getType() == CIMTYPE_OBJECT) |
{ | { |
|
|
v.get(tmpObjs); | v.get(tmpObjs); |
for (int i = 0; i < aSize ; ++i) | for (int i = 0; i < aSize ; ++i) |
{ | { |
aData[i].value.inst = reinterpret_cast<CMPIInstance*>( |
CIMInstance inst = CIMInstance(tmpObjs[i]); |
new CMPI_Object(new CIMInstance(tmpObjs[i]))); |
SCMOInstance* scmoInst = |
|
CMPISCMOUtilities::getSCMOFromCIMInstance(inst); |
|
aData[i].value.inst = |
|
reinterpret_cast<CMPIInstance*>( |
|
new CMPI_Object( |
|
scmoInst, |
|
CMPI_Object::ObjectTypeInstance)); |
} | } |
} | } |
else | else |
{ | { |
CopyFromEncArray(CIMInstance,CMPIInstance,inst); |
Array<CIMInstance> arInst; |
|
v.get(arInst); |
|
for (int i = 0; i < aSize ; ++i) |
|
{ |
|
SCMOInstance* scmoInst = |
|
CMPISCMOUtilities:: |
|
getSCMOFromCIMInstance(arInst[i]); |
|
aData[i].value.inst = |
|
reinterpret_cast<CMPIInstance*> |
|
(new CMPI_Object( |
|
scmoInst, |
|
CMPI_Object::ObjectTypeInstance)); |
|
} |
} | } |
break; | break; |
case CMPI_boolean: | case CMPI_boolean: |
|
|
return CMPI_RC_ERR_NOT_SUPPORTED; | return CMPI_RC_ERR_NOT_SUPPORTED; |
} | } |
data->value.array = reinterpret_cast<CMPIArray*>( | data->value.array = reinterpret_cast<CMPIArray*>( |
new CMPI_Object(aData-1)); |
new CMPI_Object(new CMPI_Array(aData-1))); |
} // end of array porocessing | } // end of array porocessing |
| |
//Start of non-array processing | //Start of non-array processing |
|
|
} | } |
} | } |
| |
//Checking for remaining encapulated and simple types |
//Checking for remaining encapsulated and simple types |
else | else |
switch( t ) | switch( t ) |
{ | { |
|
|
{ | { |
CIMObjectPath ref; | CIMObjectPath ref; |
v.get(ref); | v.get(ref); |
|
SCMOInstance* scmoRef = |
|
CMPISCMOUtilities:: getSCMOFromCIMObjectPath(ref); |
data->value.ref = reinterpret_cast<CMPIObjectPath*>( | data->value.ref = reinterpret_cast<CMPIObjectPath*>( |
new CMPI_Object(new CIMObjectPath(ref))); |
new CMPI_Object(scmoRef,CMPI_Object::ObjectTypeObjectPath)); |
} | } |
break; | break; |
| |
|
|
{ | { |
v.get(inst); | v.get(inst); |
} | } |
|
SCMOInstance* scmoInst = |
|
CMPISCMOUtilities::getSCMOFromCIMInstance(inst); |
data->value.inst = reinterpret_cast<CMPIInstance*>( | data->value.inst = reinterpret_cast<CMPIInstance*>( |
new CMPI_Object(new CIMInstance(inst))); |
new CMPI_Object(scmoInst, CMPI_Object::ObjectTypeInstance)); |
} | } |
break; | break; |
| |
|
|
return(CMPIType)t; | return(CMPIType)t; |
} | } |
| |
//Function to convert CMPIType to CIMType |
|
CIMType type2CIMType(CMPIType pt) |
|
{ |
|
switch( pt ) |
|
{ |
|
case CMPI_null: |
|
return(CIMType)0; |
|
|
|
case CMPI_boolean: |
|
return CIMTYPE_BOOLEAN; |
|
|
|
case CMPI_char16: |
|
return CIMTYPE_CHAR16; |
|
|
|
case CMPI_real32: |
|
return CIMTYPE_REAL32; |
|
|
|
case CMPI_real64: |
|
return CIMTYPE_REAL64; |
|
|
|
case CMPI_uint8: |
|
return CIMTYPE_UINT8; |
|
|
|
case CMPI_uint16: |
|
return CIMTYPE_UINT16; |
|
|
|
case CMPI_uint32: |
|
return CIMTYPE_UINT32; |
|
|
|
case CMPI_uint64: |
|
return CIMTYPE_UINT64; |
|
|
|
case CMPI_sint8: |
|
return CIMTYPE_SINT8; |
|
|
|
case CMPI_sint16: |
|
return CIMTYPE_SINT16; |
|
|
|
case CMPI_sint32: |
|
return CIMTYPE_SINT32; |
|
|
|
case CMPI_sint64: |
|
return CIMTYPE_SINT64; |
|
|
|
case CMPI_string: |
|
return CIMTYPE_STRING; |
|
|
|
case CMPI_chars: |
|
return CIMTYPE_STRING; |
|
|
|
case CMPI_charsptr: |
|
return CIMTYPE_STRING; |
|
|
|
case CMPI_dateTime: |
|
return CIMTYPE_DATETIME; |
|
|
|
case CMPI_ref: |
|
return CIMTYPE_REFERENCE; |
|
case CMPI_instance: |
|
return CIMTYPE_INSTANCE; |
|
default: |
|
return(CIMType)0; |
|
} |
|
} |
|
|
|
//Function to convert CIMKeyBindings to CMPIData |
|
CMPIrc key2CMPIData(const String& v, CIMKeyBinding::Type t, CMPIData *data) |
|
{ |
|
data->state=CMPI_keyValue; |
|
switch( t ) |
|
{ |
|
case CIMKeyBinding::NUMERIC: |
|
{ |
|
CString vp=v.getCString(); |
|
|
|
data->value.sint64 = 0; |
|
if( *((const char*)vp)=='-' ) |
|
{ |
|
sscanf( |
|
(const char*)vp, |
|
"%" PEGASUS_64BIT_CONVERSION_WIDTH "d", |
|
&data->value.sint64); |
|
data->type=CMPI_sint64; |
|
} |
|
else |
|
{ |
|
sscanf( |
|
(const char*)vp, |
|
"%" PEGASUS_64BIT_CONVERSION_WIDTH "u", |
|
&data->value.uint64); |
|
data->type=CMPI_uint64; |
|
} |
|
} |
|
break; |
|
|
|
case CIMKeyBinding::STRING: |
|
data->value.string=string2CMPIString(v); |
|
data->type=CMPI_string; |
|
break; |
|
|
|
case CIMKeyBinding::BOOLEAN: |
|
data->value.boolean=(String::equalNoCase(v,"true")); |
|
data->type=CMPI_boolean; |
|
break; |
|
|
|
case CIMKeyBinding::REFERENCE: |
|
data->value.ref=reinterpret_cast<CMPIObjectPath*>( |
|
new CMPI_Object(new CIMObjectPath(v))); |
|
data->type=CMPI_ref; |
|
break; |
|
|
|
default: |
|
return CMPI_RC_ERR_NOT_SUPPORTED; |
|
} |
|
return CMPI_RC_OK; |
|
} |
|
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |