/** * call-seq: * instance.each_property do |name, value| * ... * end * * enumerates properties yielding the property name and * its value * */ static VALUE each_property(VALUE self) { CIMCInstance *ptr; CIMCStatus status; int k=0; int num_props=0; CIMCString *property_name = NULL; CIMCData data; Data_Get_Struct(self, CIMCInstance, ptr); num_props = ptr->ft->getPropertyCount(ptr, &status); if (!status.rc) { for (; k < num_props; ++k) { data = ptr->ft->getPropertyAt(ptr, k, &property_name, &status); if (!status.rc) { rb_yield_values(2, (property_name ? rb_str_intern(rb_str_new2(property_name->ft->getCharPtr(property_name, NULL))) : Qnil), sfcc_cimdata_to_value(data)); } else { sfcc_rb_raise_if_error(status, "Can't retrieve property #%d", k); } if (property_name) CMRelease(property_name); } } else { sfcc_rb_raise_if_error(status, "Can't retrieve property count"); } return Qnil; }
VALUE sfcc_cimargs_to_hash(CMPIArgs *args) { CMPIArgs *ptr = NULL; int i = 0; int n = 0; VALUE hash; CMPIString *argname; CMPIData argdata; CMPIStatus status; char *argname_cstr = NULL; //Data_Get_Struct(args, CMPIArgs, ptr); ptr = args; if (!ptr) { rb_raise(rb_eRuntimeError, "Can't retrieve args pointer"); return Qnil; } n = ptr->ft->getArgCount(ptr, NULL); hash = rb_hash_new(); for (; i < n; ++i) { argname = NULL; argdata = ptr->ft->getArgAt(ptr, i, &argname, &status); if (!status.rc && argdata.state == CMPI_goodValue ) { argname_cstr = argname->ft->getCharPtr(argname, &status); if (!argname_cstr) { rb_raise(rb_eRuntimeError, "Can't retrieve argument name"); return Qnil; } if (!status.rc) { rb_hash_aset(hash, rb_funcall(rb_str_new2(argname_cstr), rb_intern("to_sym"), 0), sfcc_cimdata_to_value(argdata)); } else { sfcc_rb_raise_if_error(status, "Can't retrieve argument name"); return Qnil; } } else { sfcc_rb_raise_if_error(status, "Can't retrieve argument"); return Qnil; } } return hash; }
VALUE sfcc_cimargs_to_hash(CIMCArgs *args, VALUE client) { int i = 0; int n = 0; VALUE hash; CIMCString *argname; CIMCData argdata; CIMCStatus status; char *argname_cstr = NULL; /* Data_Get_Struct(value, CIMCArgs, args); */ if (!args) { rb_raise(rb_eRuntimeError, "Can't retrieve args pointer"); return Qnil; } n = args->ft->getArgCount(args, NULL); hash = rb_hash_new(); for (; i < n; ++i) { argname = NULL; argdata = args->ft->getArgAt(args, i, &argname, &status); if (!status.rc && argdata.state == CIMC_goodValue ) { argname_cstr = argname->ft->getCharPtr(argname, &status); if (!argname_cstr) { rb_raise(rb_eRuntimeError, "Can't retrieve argument name"); return Qnil; } if (!status.rc) { rb_hash_aset(hash, rb_funcall(rb_str_new2(argname_cstr), rb_intern("to_sym"), 0), sfcc_cimdata_to_value(&argdata, client)); } else { sfcc_rb_raise_if_error(status, "Can't retrieve argument name"); return Qnil; } } else { sfcc_rb_raise_if_error(status, "Can't retrieve argument"); return Qnil; } } return hash; }
/** * 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: * namespace=(ns) * * Set/replace the namespace component */ static VALUE set_namespace(VALUE self, VALUE val) { CMPIObjectPath *ptr = NULL; CMPIStatus status; Data_Get_Struct(self, CMPIObjectPath, ptr); status = ptr->ft->setNameSpace(ptr, StringValuePtr(val)); if (!status.rc) return val; sfcc_rb_raise_if_error(status, "Can't set namespace"); return Qnil; }
/** * 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; }
VALUE sfcc_cimcarray_to_rubyarray(CIMCArray *array, VALUE client) { CIMCCount size; CIMCCount i; CIMCStatus st = { 0, NULL }; VALUE ary; if (!array) rb_raise(rb_eArgError, "Cannot convert NULL array"); size = array->ft->getSize(array, &st); sfcc_rb_raise_if_error(st, "Can't get array size"); ary = rb_ary_new2(size); for (i = 0; i < size; ++i) { CIMCData data; VALUE value; array->ft->getElementAt(array,i,&st); sfcc_rb_raise_if_error(st, "Can't get array element %d of %d", i, size); value = sfcc_cimdata_to_value(&data, client); rb_ary_store(ary,i,value); } return ary; }
/** * 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; }
/* callback to add each hash element to a CMPIArgs */ static int hash_to_cimargs_iterator(VALUE key, VALUE value, VALUE extra) { CMPIStatus status; CMPIData data; CMPIArgs *args = (CMPIArgs *)extra; VALUE key_str = rb_funcall(key, rb_intern("to_s"), 0); char *key_cstr = StringValuePtr(key_str); 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'", StringValuePtr(key)); return ST_STOP; }
/** * call-seq: * set_property_filter(property_list, keys) * * Directs CIMC to ignore any setProperty operations for this * instance for any properties not in this list. * * +property_list+ If not nil, the members of the array define one * or more Property names to be accepted by set_property operations. * * +keys+ Array of key property names of this instance. This array * must be specified. * */ static VALUE set_property_filter(VALUE self, VALUE property_list, VALUE keys) { CIMCStatus status; CIMCInstance *ptr; char **prop_a; char **key_a; Data_Get_Struct(self, CIMCInstance, ptr); prop_a = sfcc_value_array_to_string_array(property_list); key_a = sfcc_value_array_to_string_array(keys); status = ptr->ft->setPropertyFilter(ptr, prop_a, key_a); free(prop_a); free(key_a); sfcc_rb_raise_if_error(status, "Can't set property filter"); return self; }
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; }
VALUE sfcc_cimdata_to_value(CIMCData *data, VALUE client) { VALUE rbval; CIMCStatus status; if ((data->state != CIMC_goodValue) && (data->state != CIMC_keyValue)) { if (data->state & CIMC_nullValue) return Qnil; if (data->state & CIMC_notFound) rb_raise(rb_eRuntimeError, "Value not found"); if (data->state & CIMC_badValue) rb_raise(rb_eArgError, "Bad value"); } if (data->type & CIMC_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, client)); } return rbarray; } sfcc_rb_raise_if_error(status, "Can't retrieve array size"); return Qnil; } else if (data->type & CIMC_ENC) { switch (data->type) { case CIMC_instance: return data->value.inst ? Sfcc_wrap_cim_instance(data->value.inst->ft->clone(data->value.inst, NULL), client) : Qnil; case CIMC_ref: return data->value.ref ? Sfcc_wrap_cim_object_path(data->value.ref->ft->clone(data->value.ref, NULL), client) : Qnil; case CIMC_args: return data->value.args ? sfcc_cimargs_to_hash(data->value.args, client) : Qnil; case CIMC_class: return data->value.cls ? Sfcc_wrap_cim_class(data->value.cls->ft->clone(data->value.cls, NULL)) : Qnil; case CIMC_filter: return Qnil; case CIMC_enumeration: return data->value.Enum ? Sfcc_wrap_cim_enumeration(data->value.Enum->ft->clone(data->value.Enum, NULL), client) : Qnil; case CIMC_string: if (data->value.string) { const char *strval = data->value.string->ft->getCharPtr(data->value.string, NULL); /* getCharPtr() might return NULL and rb_str_new2 doesn't like that */ if (strval) return rb_str_new2(strval); } return Qnil; case CIMC_chars: return data->value.chars ? rb_str_new2(data->value.chars) : Qnil; case CIMC_charsptr: return data->value.chars ? rb_str_new((char*)data->value.dataPtr.ptr, data->value.dataPtr.length) : Qnil; case CIMC_dateTime: if (data->value.dateTime) { CIMCUint64 bintime; bintime = data->value.dateTime->ft->getBinaryFormat(data->value.dateTime, NULL); rbval = rb_time_new((time_t) (bintime / 1000000L), (time_t) (bintime % 1000000)); } else { rbval = Qnil; } return rbval; default: rb_raise(rb_eTypeError, "Unhandled type 0x%04x", data->type); } } else if (data->type & CIMC_SIMPLE) { switch (data->type) { case CIMC_boolean: return data->value.boolean ? Qtrue : Qfalse; case CIMC_char16: return UINT2NUM(data->value.char16); } } else if (data->type & CIMC_INTEGER) { switch (data->type) { case CIMC_uint8: return UINT2NUM(data->value.uint8); case CIMC_sint8: return INT2NUM(data->value.sint8); case CIMC_uint16: return UINT2NUM(data->value.uint16); case CIMC_sint16: return INT2NUM(data->value.sint16); case CIMC_uint32: return UINT2NUM(data->value.uint32); case CIMC_sint32: return INT2NUM(data->value.sint32); case CIMC_uint64: return UINT2NUM(data->value.uint64); case CIMC_sint64: return INT2NUM(data->value.sint64); } } else if (data->type & CIMC_REAL) { switch (data->type) { case CIMC_real32: return rb_float_new(data->value.real32); case CIMC_real64: return rb_float_new(data->value.real64); } } else if (data->type & CIMC_null ) { return Qnil; } rb_raise(rb_eTypeError, "unsupported data type %d", data->type); return Qnil; }