/**
* call-seq:
* cimclass.each_property_qualifier(property_name) do |name, value|
* ...
* end
*
* enumerates properties yielding the property qualifier name and
* its value
*
*/
static VALUE each_property_qualifier(VALUE self, VALUE property_name)
{
CIMCInstance *ptr;
CIMCStatus status;
int k=0;
int num_props=0;
CIMCString *property_qualifier_name = NULL;
CIMCData data;
Data_Get_Struct(self, CIMCInstance, ptr);
num_props = ptr->ft->getPropertyQualifierCount(ptr, to_charptr(property_name), &status);
if (!status.rc) {
for (; k < num_props; ++k) {
data = ptr->ft->getPropertyQualifierAt(ptr, to_charptr(property_name), k, &property_qualifier_name, &status);
if (!status.rc) {
rb_yield_values(2, (property_qualifier_name ? rb_str_new2(property_qualifier_name->ft->getCharPtr(property_qualifier_name, NULL)) : Qnil), sfcc_cimdata_to_value(data));
}
else {
sfcc_rb_raise_if_error(status, "Can't retrieve property qualifier #%d", k);
}
if (property_qualifier_name) CMRelease(property_qualifier_name);
}
}
else {
sfcc_rb_raise_if_error(status, "Can't retrieve property qualifier count");
}
return Qnil;
}
CIMCData sfcc_value_to_cimdata(VALUE value)
{
CIMCData data;
memset(&data, 0, sizeof(CIMCData));
data.state = CMPI_goodValue;
data.type = CMPI_null;
switch (TYPE(value))
{
case T_NIL:
data.type = CMPI_null;
data.state = CMPI_nullValue;
break;
case T_STRING:
data.type = CMPI_string;
data.value.string = cimcEnv->ft->newString(cimcEnv, to_charptr(value), NULL);
break;
case T_TRUE:
data.type = CMPI_boolean;
data.value.boolean = 1;
break;
case T_FALSE:
data.type = CMPI_boolean;
data.value.boolean = 0;
break;
case T_FIXNUM:
data.type = CMPI_sint64;
data.value.Long = NUM2INT(value);
break;
/* not yet supported
case T_BIGNUM:
break;
case T_FLOAT:
break;
case T_ARRAY:
break;
case T_HASH:
break;
case T_SYMBOL:
*/
case T_DATA:
default:
if (CLASS_OF(value) == cSfccCimString) {
Data_Get_Struct(value, CIMCString, data.value.string);
data.type = CMPI_string;
}
else {
VALUE cname;
const char *class_name;
data.state = CMPI_badValue;
data.type = CMPI_null;
cname = rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0);
class_name = to_charptr(cname);
rb_raise(rb_eTypeError, "unsupported data data type: %s", class_name);
return data;
}
}
return data;
}
/**
* call-seq:
* property(name)
*
* Gets a named property value, where name is a Symbol or String
*/
static VALUE property(VALUE self, VALUE name)
{
CIMCInstance *ptr;
CIMCStatus status;
CIMCData data;
Data_Get_Struct(self, CIMCInstance, ptr);
data = ptr->ft->getProperty(ptr, to_charptr(name), &status);
if ( !status.rc )
return sfcc_cimdata_to_value(data);
sfcc_rb_raise_if_error(status, "Can't retrieve property '%s'", to_charptr(name));
return Qnil;
}
/**
* call-seq:
* qualifier(name)
*
* gets a named qualifier value
*/
static VALUE qualifier(VALUE self, VALUE name)
{
CIMCInstance *ptr;
CIMCStatus status;
CIMCData data;
memset(&status, 0, sizeof(CIMCStatus));
Data_Get_Struct(self, CIMCInstance, ptr);
data = ptr->ft->getQualifier(ptr, to_charptr(name), &status);
if ( !status.rc )
return sfcc_cimdata_to_value(data);
sfcc_rb_raise_if_error(status, "Can't retrieve qualifier '%s'", to_charptr(name));
return Qnil;
}
/* callback to add each hash element to a CMPIArgs */
static int hash_to_cimargs_iterator(VALUE key, VALUE value, VALUE extra)
{
CIMCStatus status;
CIMCData data;
CIMCArgs *args = (CIMCArgs *)extra;
const char *key_cstr = to_charptr(key);
data = sfcc_value_to_cimdata(value);
status = args->ft->addArg(args, key_cstr, &data.value, data.type);
if ( !status.rc ) {
return ST_CONTINUE;
}
sfcc_rb_raise_if_error(status, "Can't add argument '%s'", to_charptr(key));
return ST_STOP;
}
/**
* call-seq:
* set_property(name, value)
*
* Adds/replaces a names property
*/
static VALUE set_property(VALUE self, VALUE name, VALUE value)
{
CIMCInstance *ptr;
CIMCData data;
Data_Get_Struct(self, CIMCInstance, ptr);
data = sfcc_value_to_cimdata(value);
ptr->ft->setProperty(ptr, to_charptr(name), &data.value, data.type);
return value;
}
/**
* call-seq:
* namespace=(ns)
*
* Set/replace the namespace component
*/
static VALUE set_namespace(VALUE self, VALUE val)
{
CIMCObjectPath *ptr;
CIMCStatus status;
Data_Get_Struct(self, CIMCObjectPath, ptr);
status = ptr->ft->setNameSpace(ptr, to_charptr(val));
if (!status.rc)
return val;
sfcc_rb_raise_if_error(status, "Can't set namespace");
return Qnil;
}
/**
* call-seq:
* property_qualifier_count(property_name)
*
* Gets the number of qualifiers contained in this property
*/
static VALUE property_qualifier_count(VALUE self, VALUE property_name)
{
CIMCInstance *ptr;
Data_Get_Struct(self, CIMCInstance, ptr);
return UINT2NUM(ptr->ft->getPropertyQualifierCount(ptr, to_charptr(property_name), NULL));
}
CIMCData sfcc_value_to_cimdata(VALUE value)
{
CIMCData data;
memset(&data, 0, sizeof(CIMCData));
data.state = CIMC_goodValue;
data.type = CIMC_null;
switch (TYPE(value))
{
case T_NIL:
data.type = CIMC_null;
data.state = CIMC_nullValue;
break;
case T_STRING:
data.type = CIMC_string;
data.value.string = cimcEnv->ft->newString(cimcEnv, to_charptr(value), NULL);
break;
case T_TRUE:
data.type = CIMC_boolean;
data.value.boolean = 1;
break;
case T_FALSE:
data.type = CIMC_boolean;
data.value.boolean = 0;
break;
case T_FIXNUM:
data.type = CIMC_sint64;
data.value.Long = NUM2INT(value);
break;
case T_FLOAT:
data.type = CIMC_real64;
data.value.real64 = NUM2DBL(value);
break;
case T_BIGNUM:
data.type = CIMC_sint64;
data.value.Long = NUM2LL(value);
break;
/* not yet supported
case T_HASH:
break;
case T_SYMBOL:
*/
case T_ARRAY: {
data.value.array = sfcc_rubyarray_to_cimcarray(value, &data.type);
if (!data.value.array) {
data.state = CIMC_badValue;
}
break;
}
case T_DATA:
default:
if (CLASS_OF(value) == cSfccCimString) {
Data_Get_Struct(value, CIMCString, data.value.string);
if (data.value.string == NULL) { /* packed a NULL pointer ? */
data.type = CIMC_null;
data.state = CIMC_nullValue;
}
else {
data.type = CIMC_string;
}
}
else if (CLASS_OF(value) == cSfccCimData) {
CIMCData *tmp;
Data_Get_Struct(value, CIMCData, tmp);
data = *tmp;
}
else if(CLASS_OF(value) == cSfccCimInstance) {
rb_sfcc_instance *obj;
Data_Get_Struct(value, rb_sfcc_instance, obj);
data.value.inst = obj->inst;
if (data.value.inst == NULL) {
data.type = CIMC_null;
data.state = CIMC_nullValue;
}else {
data.type = CIMC_instance;
}
}
else if(CLASS_OF(value) == cSfccCimObjectPath) {
rb_sfcc_object_path *obj;
Data_Get_Struct(value, rb_sfcc_object_path, obj);
data.value.ref = obj->op;
if (data.value.ref == NULL) {
data.type = CIMC_null;
data.state = CIMC_nullValue;
}else {
data.type = CIMC_ref;
}
}
else if(CLASS_OF(value) == cSfccCimEnumeration) {
rb_sfcc_enumeration *obj;
Data_Get_Struct(value, rb_sfcc_enumeration, obj);
data.value.Enum = obj->enm;
if (data.value.Enum == NULL) {
data.type = CIMC_null;
data.state = CIMC_nullValue;
}else {
data.type = CIMC_enumeration;
}
}
else if (CLASS_OF(value) == cSfccCimClass) {
Data_Get_Struct(value, CIMCClass, data.value.cls);
if (data.value.cls == NULL) {
data.type = CIMC_null;
data.state = CIMC_nullValue;
}else {
data.type = CIMC_class;
}
}
else {
VALUE cname;
const char *class_name;
data.state = CIMC_badValue;
data.type = CIMC_null;
cname = rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0);
class_name = to_charptr(cname);
rb_raise(rb_eTypeError, "unsupported data type: %s", class_name);
return data;
}
}
return data;
}
