char *
sfcb_value2Chars(CMPIType type, CMPIValue * value)
{
char str[256],
*p;
unsigned int size;
CMPIString *cStr;
str[0] = 0;
if (value) {
if (type & CMPI_ARRAY) {
} else if (type & CMPI_ENC) {
if (value->chars) {
/*
* non - null encapsulated value
*/
switch (type) {
case CMPI_instance:
break;
case CMPI_ref:
cStr = value->ref->ft->toString(value->ref, NULL); // __oft_toString(value->ref,
//
//
// NULL);
return strdup((char *) cStr->hdl);
break;
case CMPI_args:
break;
case CMPI_filter:
break;
case CMPI_chars:
if (value->chars) {
size = strlen((char *) value->chars);
p = malloc(size + 3);
sprintf(p, "\"%s\"", (char *) value->chars);
return p;
}
break;
case CMPI_string:
case CMPI_numericString:
case CMPI_booleanString:
case CMPI_dateTimeString:
if (value->string->hdl) {
size = strlen((char *) value->string->hdl);
p = malloc(size + 8);
sprintf(p, "\"%s\"", (char *) value->string->hdl);
return p;
}
break;
case CMPI_dateTime:
cStr = CMGetStringFormat(value->dateTime, NULL);
size = strlen((char *) cStr->hdl);
p = malloc(size + 8);
sprintf(p, "\"%s\"", (char *) cStr->hdl);
return p;
break;
}
}
} else if (type & CMPI_SIMPLE) {
switch (type) {
case CMPI_boolean:
return strdup(value->boolean ? "true" : "false");
case CMPI_char16:
break;
}
} else if (type & CMPI_INTEGER) {
switch (type) {
case CMPI_uint8:
sprintf(str, "%u", value->uint8);
return strdup(str);
case CMPI_sint8:
sprintf(str, "%d", value->sint8);
return strdup(str);
case CMPI_uint16:
sprintf(str, "%u", value->uint16);
return strdup(str);
case CMPI_sint16:
sprintf(str, "%d", value->sint16);
return strdup(str);
case CMPI_uint32:
sprintf(str, "%u", value->uint32);
return strdup(str);
case CMPI_sint32:
sprintf(str, "%d", value->sint32);
return strdup(str);
case CMPI_uint64:
sprintf(str, "%llu", value->uint64);
return strdup(str);
case CMPI_sint64:
sprintf(str, "%lld", value->sint64);
return strdup(str);
}
} else if (type & CMPI_REAL) {
switch (type) {
case CMPI_real32:
sprintf(str, "%g", value->real32);
return strdup(str);
case CMPI_real64:
sprintf(str, "%g", value->real64);
return strdup(str);
}
}
}
return strdup(str);
}
void print_scalar(const CMPIData& data)
{
switch(data.type)
{
case CMPI_boolean:
printf("\"%s\"", data.value.boolean ? "true" : "false");
break;
case CMPI_uint8:
printf("%u", data.value.uint8);
break;
case CMPI_sint8:
printf("%d", data.value.sint8);
break;
case CMPI_uint16:
printf("%u", data.value.uint16);
break;
case CMPI_sint16:
printf("%d", data.value.sint16);
break;
case CMPI_uint32:
printf("%u", data.value.uint32);
break;
case CMPI_sint32:
printf("%d", data.value.sint32);
break;
case CMPI_uint64:
printf("%llu", data.value.uint64);
break;
case CMPI_sint64:
printf("%lld", data.value.sint64);
break;
case CMPI_real32:
printf("%f", data.value.real32);
break;
case CMPI_real64:
printf("%lf", data.value.real64);
break;
case CMPI_char16:
printf("%u", data.value.char16);
break;
case CMPI_string:
printf("%s", CMGetCharPtr(data.value.string));
break;
case CMPI_dateTime:
{
CMPIString* tmp = CMGetStringFormat(data.value.dateTime, NULL);
printf("%s", CMGetCharPtr(tmp));
break;
}
case CMPI_ref:
{
print(data.value.ref);
break;
}
default:
assert(0);
break;
}
}
/* this is pulled from SFCC;
TODO: combine this with SFCC's (and value.c's as well)
*/
char * value2Chars (CMPIType type, CMPIValue *value)
{
char str[2048], *p;
CMPIString *cStr;
str[0]=0;
if (type & CMPI_ARRAY) {
}
else if (type & CMPI_ENC) {
switch (type) {
case CMPI_instance:
break;
case CMPI_ref:
if (value->ref) {
cStr=value->ref->ft->toString(value->ref,NULL);
p = strdup((char *) cStr->hdl);
CMRelease(cStr);
} else {
p = strdup("NULL");
}
return p;
case CMPI_args:
break;
case CMPI_filter:
break;
case CMPI_string:
case CMPI_numericString:
case CMPI_booleanString:
case CMPI_dateTimeString:
case CMPI_classNameString:
return strdup((value->string && value->string->hdl) ?
(char*)value->string->hdl : "NULL");
case CMPI_dateTime:
if (value->dateTime) {
cStr=CMGetStringFormat(value->dateTime,NULL);
p = strdup((char *) cStr->hdl);
CMRelease(cStr);
} else
p = strdup("NULL");
return p;
}
}
else if (type & CMPI_SIMPLE) {
switch (type) {
case CMPI_boolean:
return strdup(value->boolean ? "true" : "false");
case CMPI_char16:
break;
}
}
else if (type & CMPI_INTEGER) {
switch (type) {
case CMPI_uint8:
sprintf(str, "%u", value->uint8);
return strdup(str);
case CMPI_sint8:
sprintf(str, "%d", value->sint8);
return strdup(str);
case CMPI_uint16:
sprintf(str, "%u", value->uint16);
return strdup(str);
case CMPI_sint16:
sprintf(str, "%d", value->sint16);
return strdup(str);
case CMPI_uint32:
sprintf(str, "%u", value->uint32);
return strdup(str);
case CMPI_sint32:
sprintf(str, "%d", value->sint32);
return strdup(str);
case CMPI_uint64:
sprintf(str, "%llu", value->uint64);
return strdup(str);
case CMPI_sint64:
sprintf(str, "%lld", value->sint64);
return strdup(str);
}
}
else if (type & CMPI_REAL) {
switch (type) {
case CMPI_real32:
sprintf(str, "%g", value->real32);
return strdup(str);
case CMPI_real64:
sprintf(str, "%g", value->real64);
return strdup(str);
}
}
return strdup(str);
}
int
value2xml(CMPIData d, UtilStringBuffer * sb, int wv)
{
char str[256];
char *sp = str;
int splen = 0;
int freesp = 0;
if (d.type & CMPI_ARRAY) {
sb->ft->appendChars(sb, "**[]**");
return 1;
}
else {
if (wv)
SFCB_APPENDCHARS_BLOCK(sb, "<VALUE>");
if ((d.type & (CMPI_UINT | CMPI_SINT)) == CMPI_UINT) {
unsigned long long ul = 0LL;
switch (d.type) {
case CMPI_uint8:
ul = d.value.uint8;
break;
case CMPI_uint16:
ul = d.value.uint16;
break;
case CMPI_uint32:
ul = d.value.uint32;
break;
case CMPI_uint64:
ul = d.value.uint64;
break;
}
splen = sprintf(str, "%llu", ul);
}
else if (d.type & CMPI_SINT) {
long long sl = 0LL;
switch (d.type) {
case CMPI_sint8:
sl = d.value.sint8;
break;
case CMPI_sint16:
sl = d.value.sint16;
break;
case CMPI_sint32:
sl = d.value.sint32;
break;
case CMPI_sint64:
sl = d.value.sint64;
break;
}
splen = sprintf(str, "%lld", sl);
}
else if (d.type == CMPI_real32) {
splen = sprintf(str, "%.7e", d.value.real32);
}
else if (d.type == CMPI_real64) {
splen = sprintf(str, "%.16e", d.value.real64);
}
else if (d.type == CMPI_boolean)
splen = sprintf(str, "%s", d.value.boolean ? "TRUE" : "FALSE");
else if (d.type == CMPI_char16)
/* To support wide charset/unicode charset, review this line */
splen = sprintf(str, "%c", (CMPIChar16)d.value.char16);
else if (d.type == CMPI_chars) {
sp = XMLEscape(d.value.chars, &splen);
if (sp)
freesp = 1;
} else if (d.type == CMPI_string) {
sp = XMLEscape((char *) d.value.string->hdl, &splen);
if (sp)
freesp = 1;
} else if (d.type == CMPI_dateTime) {
if (d.value.dateTime) {
CMPIString *sdf = CMGetStringFormat(d.value.dateTime, NULL);
sp = (char *) sdf->hdl;
splen = 25;
} else {
splen = 0;
}
} else if (d.type == CMPI_instance) {
SFCB_APPENDCHARS_BLOCK(sb, "<![CDATA[");
instance2xml(d.value.inst, sb, 0);
SFCB_APPENDCHARS_BLOCK(sb, "]]>");
splen = 0;
} else {
mlogf(M_ERROR, M_SHOW, "%s(%d): invalid value2xml %d-%x\n", __FILE__,
__LINE__, (int) d.type, (int) d.type);
abort();
}
if (splen) {
sb->ft->appendBlock(sb, sp, splen);
}
if (wv)
SFCB_APPENDCHARS_BLOCK(sb, "</VALUE>\n");
}
if (freesp)
free(sp);
return 0;
}
VALUE sfcc_cimdata_to_value(CIMCData data)
{
CIMCString *cimstr = NULL;
VALUE rbval;
CIMCStatus status;
if (data.type & CMPI_ARRAY) {
int k = 0;
int n = 0;
VALUE rbarray = rb_ary_new();
if (!data.value.array)
return rb_ary_new();
n = data.value.array->ft->getSize(data.value.array, &status);
if (!status.rc) {
for (k = 0; k < n; ++k) {
CIMCData element = data.value.array->ft->getElementAt(data.value.array, k, NULL);
rb_ary_push(rbarray, sfcc_cimdata_to_value(element));
}
return rbarray;
}
sfcc_rb_raise_if_error(status, "Can't retrieve array size");
return Qnil;
}
else if (data.type & CMPI_ENC) {
switch (data.type) {
case CMPI_instance:
return data.value.inst ? Sfcc_wrap_cim_instance(data.value.inst->ft->clone(data.value.inst, NULL)) : Qnil;
case CMPI_class:
return data.value.cls ? Sfcc_wrap_cim_class(data.value.cls->ft->clone(data.value.cls, NULL)) : Qnil;
case CMPI_ref:
return data.value.ref ? Sfcc_wrap_cim_object_path(data.value.ref->ft->clone(data.value.ref, NULL)) : Qnil;
case CMPI_args:
return data.value.args ? sfcc_cimargs_to_hash(data.value.args) : Qnil;
case CMPI_filter:
return Qnil;
case CMPI_numericString:
case CMPI_booleanString:
case CMPI_dateTimeString:
case CMPI_classNameString:
break;
case CMPI_string:
return data.value.string ? rb_str_new2((char*)data.value.string->ft->getCharPtr(data.value.string, NULL)) : Qnil;
case CMPI_charsptr:
return data.value.chars ? rb_str_new((char*)data.value.dataPtr.ptr, data.value.dataPtr.length) : Qnil;
case CMPI_dateTime:
cimstr = data.value.dateTime ? CMGetStringFormat(data.value.dateTime,NULL) : NULL;
rbval = cimstr ? rb_str_new2(cimstr->ft->getCharPtr(cimstr, NULL)) : Qnil;
if (cimstr) CMRelease(cimstr);
return rbval;
}
}
else if (data.type & CMPI_SIMPLE) {
switch (data.type) {
case CMPI_boolean: return data.value.boolean ? Qtrue : Qfalse;
case CMPI_char16: return UINT2NUM(data.value.char16);
}
}
else if (data.type & CMPI_INTEGER) {
switch (data.type) {
case CMPI_uint8: return UINT2NUM(data.value.uint8);
case CMPI_sint8: return INT2NUM(data.value.sint8);
case CMPI_uint16: return UINT2NUM(data.value.uint16);
case CMPI_sint16: return INT2NUM(data.value.sint16);
case CMPI_uint32: return UINT2NUM(data.value.uint32);
case CMPI_sint32: return INT2NUM(data.value.sint32);
case CMPI_uint64: return UINT2NUM(data.value.uint64);
case CMPI_sint64: return INT2NUM(data.value.sint64);
}
}
else if (data.type & CMPI_REAL) {
switch (data.type) {
case CMPI_real32: return LONG2NUM(data.value.real32);
case CMPI_real64: return LONG2NUM(data.value.real64);
}
}
else if (data.type & CMPI_null ) {
return Qnil;
}
rb_raise(rb_eTypeError, "unsupported data data type %d", data.type);
return Qnil;
}
static int
_testCMPIDateTime()
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIBoolean isInterval = 0;
CMPIBoolean interval = 0;
CMPIBoolean cloneSuccessful = 0;
CMPIBoolean binaryDateTimeEqual = 0;
CMPIDateTime *dateTime = NULL;
CMPIDateTime *new_dateTime = NULL;
CMPIDateTime *clonedDateTime = NULL;
CMPIDateTime *dateTimeFromBinary = NULL;
CMPIUint64 dateTimeInBinary = UINT64_LITERAL(1150892800000000);
CMPIUint64 returnedDateTimeInBinary = 0;
CMPIString *stringDate = NULL;
CMPIString *clonedStringDate = NULL;
const char *normalString = NULL;
const char *clonedString = NULL;
void *dtptr;
dateTime = CMNewDateTime(_broker, &rc);
if (dateTime == NULL) {
return 1;
}
dateTimeFromBinary =
CMNewDateTimeFromBinary(_broker, dateTimeInBinary, interval, &rc);
returnedDateTimeInBinary = CMGetBinaryFormat(dateTimeFromBinary, &rc);
if (dateTimeInBinary == returnedDateTimeInBinary) {
binaryDateTimeEqual = 1;
}
isInterval = CMIsInterval(dateTime, &rc);
interval = 1;
new_dateTime =
CMNewDateTimeFromBinary(_broker, dateTimeInBinary, interval, &rc);
isInterval = CMIsInterval(new_dateTime, &rc);
clonedDateTime = dateTime->ft->clone(dateTime, &rc);
stringDate = CMGetStringFormat(dateTime, &rc);
clonedStringDate = CMGetStringFormat(clonedDateTime, &rc);
rc = clonedDateTime->ft->release(clonedDateTime);
normalString = CMGetCharsPtr(stringDate, &rc);
clonedString = CMGetCharsPtr(clonedStringDate, &rc);
if (strcmp(normalString, clonedString) == 0) {
cloneSuccessful = 1;
}
dtptr = dateTime->hdl;
dateTime->hdl = NULL;
CMGetBinaryFormat(dateTime, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
dateTime->ft->clone(dateTime, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
CMGetStringFormat(dateTime, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
rc = dateTime->ft->release(dateTime);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
dateTime->hdl = dtptr;
rc = dateTime->ft->release(dateTime);
return 0;
}
