sfcc 0.1.2 → 0.5.0

data/ext/sfcc/cim_client.h

@@ -7,6 +7,6 @@
 void init_cim_client();
 
 extern VALUE cSfccCimClient;
-VALUE Sfcc_wrap_cim_client(CMCIClient *client);
+VALUE Sfcc_wrap_cim_client(CIMCClient *client);
 
 #endif

data/ext/sfcc/cim_enumeration.c

@@ -1,12 +1,12 @@
 
-#include "sfcc.h"
 #include "cim_enumeration.h"
 #include "cim_object_path.h"
 
 static void
-dealloc(CMPIEnumeration *enm)
+dealloc(CIMCEnumeration *enm)
 {
-  SFCC_DEC_REFCOUNT(enm);
+/*  fprintf(stderr, "Sfcc_dealloc_cim_enumeration %p\n", enm); */
+  enm->ft->release(enm);
 }
 
 /**
@@ -20,34 +20,119 @@ dealloc(CMPIEnumeration *enm)
  */
 static VALUE each(VALUE self)
 {
-  CMPIStatus status;
-  CMPIEnumeration *ptr = NULL;
-  CMPIData next;
-  Data_Get_Struct(self, CMPIEnumeration, ptr);
+  CIMCStatus status;
+  CIMCEnumeration *ptr;
+  CIMCArray *ary;
+  CIMCData data;
+  Data_Get_Struct(self, CIMCEnumeration, ptr);
 
-  CMPIEnumeration *tmp = ptr->ft->clone(ptr, &status);
-  
+  /* since getNext() changes the Enumeration, we cannot iterate
+     use Array representation instead */
+  ary = ptr->ft->toArray(ptr, &status);
   if (!status.rc) {
-    while (tmp->ft->hasNext(tmp, NULL)) {
-      next = tmp->ft->getNext(tmp, NULL);
-      VALUE cimclass = sfcc_cimdata_to_value(next);
-      /* Strange sfcc bug, if I clone the enum, I get a NULL
-         class afterwards in the copy */
-      if (NIL_P(cimclass))
-        continue;
-      rb_yield(cimclass);
+    CIMCCount count = ary->ft->getSize(ary, NULL);
+    CIMCCount idx;
+    for (idx = 0; idx < count; ++idx) {
+      VALUE value;
+      data = ary->ft->getElementAt(ary, idx, NULL);
+      value = sfcc_cimdata_to_value(data);
+      rb_yield(value);
     }
+    return Qnil;
   }
 
-  tmp->ft->release(tmp);
   sfcc_rb_raise_if_error(status, "Can't iterate enumeration");
   return Qnil;
 }
 
+
+/**
+ * call-seq:
+ *   enumeration.to_a -> Array
+ *
+ * returns an Array representation of the enumeration
+ *
+ */
+static VALUE to_a(VALUE self)
+{
+  CIMCStatus status;
+  CIMCEnumeration *ptr;
+  CIMCArray *ary;
+  Data_Get_Struct(self, CIMCEnumeration, ptr);
+
+  ary = ptr->ft->toArray(ptr, &status);
+  if (!status.rc) {
+    CIMCData data;
+    CIMCCount count = ary->ft->getSize(ary, NULL);
+    VALUE array = rb_ary_new2(count);
+    CIMCCount idx;
+    for (idx = 0; idx < count; ++idx) {
+      VALUE value;
+      data = ary->ft->getElementAt(ary, idx, NULL);
+      value = sfcc_cimdata_to_value(data);
+      rb_ary_store(array, idx, value);
+    }
+    return array;
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't convert enumeration to Array");
+  return Qnil;
+}
+
+
+/**
+ * call-seq:
+ *   enumeration.size -> int
+ *
+ * returns the size (number of elements) of the enumeration
+ *
+ */
+static VALUE size(VALUE self)
+{
+  CIMCStatus status;
+  CIMCEnumeration *ptr;
+  CIMCArray *ary;
+  Data_Get_Struct(self, CIMCEnumeration, ptr);
+
+  ary = ptr->ft->toArray(ptr, &status);
+  if (!status.rc) {
+    CIMCCount count = ary->ft->getSize(ary, NULL);
+    return INT2NUM(count);
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't get enumeration size");
+  return Qnil;
+}
+
+
+/**
+ * call-seq:
+ *   enumeration.simple_type -> int
+ *
+ * returns the element type of the enumeration elements
+ *
+ */
+static VALUE simple_type(VALUE self)
+{
+  CIMCStatus status;
+  CIMCEnumeration *ptr;
+  CIMCArray *ary;
+  Data_Get_Struct(self, CIMCEnumeration, ptr);
+
+  ary = ptr->ft->toArray(ptr, &status);
+  if (!status.rc) {
+    CIMCType type = ary->ft->getSimpleType(ary, NULL);
+    return INT2NUM(type);
+  }
+  
+  sfcc_rb_raise_if_error(status, "Can't get enumeration type");
+  return Qnil;
+}
+
+
 VALUE
-Sfcc_wrap_cim_enumeration(CMPIEnumeration *enm)
+Sfcc_wrap_cim_enumeration(CIMCEnumeration *enm)
 {
-  SFCC_INC_REFCOUNT(enm);
   return Data_Wrap_Struct(cSfccCimEnumeration, NULL, dealloc, enm);
 }
 
@@ -60,6 +145,9 @@ void init_cim_enumeration()
   VALUE klass = rb_define_class_under(cimc, "Enumeration", rb_cObject);
   cSfccCimEnumeration = klass;
 
+  rb_include_module(klass, rb_const_get(rb_cObject, rb_intern("Enumerable")));
   rb_define_method(klass, "each", each, 0);
-  rb_include_module(klass, rb_const_get(rb_cObject, rb_intern("Enumerable"))); 
+  rb_define_method(klass, "to_a", to_a, 0);
+  rb_define_method(klass, "size", size, 0);
+  rb_define_method(klass, "simple_type", simple_type, 0);
 }

data/ext/sfcc/cim_enumeration.h

@@ -7,6 +7,6 @@
 void init_cim_enumeration();
 
 extern VALUE cSfccCimEnumeration;
-VALUE Sfcc_wrap_cim_enumeration(CMPIEnumeration *enm);
+VALUE Sfcc_wrap_cim_enumeration(CIMCEnumeration *enm);
 
 #endif

data/ext/sfcc/cim_instance.c

@@ -3,9 +3,10 @@
 #include "cim_object_path.h"
 
 static void
-dealloc(CMPIInstance *instance)
+dealloc(CIMCInstance *inst)
 {
-  SFCC_DEC_REFCOUNT(instance);
+/*  fprintf(stderr, "Sfcc_dealloc_cim_instance %p\n", inst); */
+  inst->ft->release(inst);
 }
 
 /**
@@ -16,15 +17,14 @@ dealloc(CMPIInstance *instance)
  */
 static VALUE property(VALUE self, VALUE name)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIStatus status;
-  CMPIData data;
-  Data_Get_Struct(self, CMPIInstance, ptr);
-  data = ptr->ft->getProperty(ptr, StringValuePtr(name), &status);
+  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'", StringValuePtr(name));
+  sfcc_rb_raise_if_error(status, "Can't retrieve property '%s'", to_charptr(name));
   return Qnil;
 }
 
@@ -40,13 +40,13 @@ static VALUE property(VALUE self, VALUE name)
  */
 static VALUE each_property(VALUE self)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIStatus status;
+  CIMCInstance *ptr;
+  CIMCStatus status;
   int k=0;
   int num_props=0;
-  CMPIString *property_name = NULL;
-  CMPIData data;
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  CIMCString *property_name = NULL;
+  CIMCData data;
+  Data_Get_Struct(self, CIMCInstance, ptr);
 
   num_props = ptr->ft->getPropertyCount(ptr, &status);
   if (!status.rc) {
@@ -57,7 +57,7 @@ static VALUE each_property(VALUE self)
       }
       else {
         sfcc_rb_raise_if_error(status, "Can't retrieve property #%d", k);
-      } 
+      }
       if (property_name) CMRelease(property_name);
     }
   }
@@ -75,8 +75,8 @@ static VALUE each_property(VALUE self)
  */
 static VALUE property_count(VALUE self)
 {
-  CMPIInstance *ptr = NULL;
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  CIMCInstance *ptr;
+  Data_Get_Struct(self, CIMCInstance, ptr);
   return UINT2NUM(ptr->ft->getPropertyCount(ptr, NULL));
 }
 
@@ -88,11 +88,11 @@ static VALUE property_count(VALUE self)
  */
 static VALUE set_property(VALUE self, VALUE name, VALUE value)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIData data;
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  CIMCInstance *ptr;
+  CIMCData data;
+  Data_Get_Struct(self, CIMCInstance, ptr);
   data = sfcc_value_to_cimdata(value);
-  ptr->ft->setProperty(ptr, StringValuePtr(name), &data.value, data.type);
+  ptr->ft->setProperty(ptr, to_charptr(name), &data.value, data.type);
 
   return value;
 }
@@ -106,21 +106,18 @@ static VALUE set_property(VALUE self, VALUE name, VALUE value)
  */
 static VALUE object_path(VALUE self)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIObjectPath *op;
-  CMPIObjectPath *newop;
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  CIMCInstance *ptr;
+  CIMCObjectPath *op;
+  Data_Get_Struct(self, CIMCInstance, ptr);
   op = ptr->ft->getObjectPath(ptr, NULL);
-  newop = op->ft->clone(op, NULL);
-  op->ft->release(op);
-  return Sfcc_wrap_cim_object_path(newop);
+  return Sfcc_wrap_cim_object_path(op);
 }
 
 /**
  * call-seq:
  *   set_property_filter(property_list, keys)
  *
- * Directs CMPI to ignore any setProperty operations for this
+ * 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
@@ -132,12 +129,12 @@ static VALUE object_path(VALUE self)
  */
 static VALUE set_property_filter(VALUE self, VALUE property_list, VALUE keys)
 {
-  CMPIStatus status;
-  CMPIInstance *ptr = NULL;
+  CIMCStatus status;
+  CIMCInstance *ptr;
   char **prop_a;
   char **key_a;
 
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  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);
@@ -158,16 +155,16 @@ static VALUE set_property_filter(VALUE self, VALUE property_list, VALUE keys)
  */
 static VALUE qualifier(VALUE self, VALUE name)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIStatus status;
-  CMPIData data;
-  memset(&status, 0, sizeof(CMPIStatus));
-  Data_Get_Struct(self, CMPIInstance, ptr);
-  data = ptr->ft->getQualifier(ptr, StringValuePtr(name), &status);
+  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'", StringValuePtr(name));
+  sfcc_rb_raise_if_error(status, "Can't retrieve qualifier '%s'", to_charptr(name));
   return Qnil;
 }
 
@@ -183,13 +180,13 @@ static VALUE qualifier(VALUE self, VALUE name)
  */
 static VALUE each_qualifier(VALUE self)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIStatus status;
+  CIMCInstance *ptr;
+  CIMCStatus status;
   int k=0;
   int num_props=0;
-  CMPIString *qualifier_name = NULL;
-  CMPIData data;
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  CIMCString *qualifier_name = NULL;
+  CIMCData data;
+  Data_Get_Struct(self, CIMCInstance, ptr);
 
   num_props = ptr->ft->getQualifierCount(ptr, &status);
   if (!status.rc) {
@@ -200,7 +197,7 @@ static VALUE each_qualifier(VALUE self)
       }
       else {
         sfcc_rb_raise_if_error(status, "Can't retrieve qualifier #%d", k);
-      } 
+      }
       if (qualifier_name) CMRelease(qualifier_name);
     }
   }
@@ -218,8 +215,8 @@ static VALUE each_qualifier(VALUE self)
  */
 static VALUE qualifier_count(VALUE self)
 {
-  CMPIInstance *ptr = NULL;
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  CIMCInstance *ptr;
+  Data_Get_Struct(self, CIMCInstance, ptr);
   return UINT2NUM(ptr->ft->getQualifierCount(ptr, NULL));
 }
 
@@ -231,17 +228,17 @@ static VALUE qualifier_count(VALUE self)
  */
 static VALUE property_qualifier(VALUE self, VALUE property_name, VALUE qualifier_name)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIStatus status;
-  CMPIData data;
-  memset(&status, 0, sizeof(CMPIStatus));
-  Data_Get_Struct(self, CMPIInstance, ptr);
-  data = ptr->ft->getPropertyQualifier(ptr, StringValuePtr(property_name),
-                                        StringValuePtr(qualifier_name), &status);
+  CIMCInstance *ptr;
+  CIMCStatus status;
+  CIMCData data;
+  memset(&status, 0, sizeof(CIMCStatus));
+  Data_Get_Struct(self, CIMCInstance, ptr);
+  data = ptr->ft->getPropertyQualifier(ptr, to_charptr(property_name),
+                                        to_charptr(qualifier_name), &status);
   if ( !status.rc )
     return sfcc_cimdata_to_value(data);
 
-  sfcc_rb_raise_if_error(status, "Can't retrieve property qualifier '%s'", StringValuePtr(qualifier_name));
+  sfcc_rb_raise_if_error(status, "Can't retrieve property qualifier '%s'", to_charptr(qualifier_name));
   return Qnil;
 }
 
@@ -257,24 +254,24 @@ static VALUE property_qualifier(VALUE self, VALUE property_name, VALUE qualifier
  */
 static VALUE each_property_qualifier(VALUE self, VALUE property_name)
 {
-  CMPIInstance *ptr = NULL;
-  CMPIStatus status;
+  CIMCInstance *ptr;
+  CIMCStatus status;
   int k=0;
   int num_props=0;
-  CMPIString *property_qualifier_name = NULL;
-  CMPIData data;
-  Data_Get_Struct(self, CMPIInstance, ptr);
+  CIMCString *property_qualifier_name = NULL;
+  CIMCData data;
+  Data_Get_Struct(self, CIMCInstance, ptr);
 
-  num_props = ptr->ft->getPropertyQualifierCount(ptr, StringValuePtr(property_name), &status);
+  num_props = ptr->ft->getPropertyQualifierCount(ptr, to_charptr(property_name), &status);
   if (!status.rc) {
     for (; k < num_props; ++k) {
-      data = ptr->ft->getPropertyQualifierAt(ptr, StringValuePtr(property_name), k, &property_qualifier_name, &status);
+      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);
     }
   }
@@ -292,9 +289,9 @@ static VALUE each_property_qualifier(VALUE self, VALUE property_name)
  */
 static VALUE property_qualifier_count(VALUE self, VALUE property_name)
 {
-  CMPIInstance *ptr = NULL;
-  Data_Get_Struct(self, CMPIInstance, ptr);
-  return UINT2NUM(ptr->ft->getPropertyQualifierCount(ptr, StringValuePtr(property_name), NULL));
+  CIMCInstance *ptr;
+  Data_Get_Struct(self, CIMCInstance, ptr);
+  return UINT2NUM(ptr->ft->getPropertyQualifierCount(ptr, to_charptr(property_name), NULL));
 }
 
 /**
@@ -306,26 +303,22 @@ static VALUE property_qualifier_count(VALUE self, VALUE property_name)
  */
 static VALUE new(VALUE klass, VALUE object_path)
 {
-  CMPIStatus status;
-  CMPIInstance *ptr;
-  CMPIInstance *newins;
-  CMPIObjectPath *op;
+  CIMCStatus status;
+  CIMCInstance *ptr;
+  CIMCObjectPath *op;
 
-  Data_Get_Struct(object_path, CMPIObjectPath, op);
-  ptr = newCMPIInstance(op, &status);
-  newins = ptr->ft->clone(ptr, &status);
-  ptr->ft->release(ptr);
+  Data_Get_Struct(object_path, CIMCObjectPath, op);
+  ptr = cimcEnv->ft->newInstance(cimcEnv, op, &status);
 
   if (!status.rc)
-    return Sfcc_wrap_cim_instance(newins);
+    return Sfcc_wrap_cim_instance(ptr);
   sfcc_rb_raise_if_error(status, "Can't create instance");
   return Qnil;
 }
 
 VALUE
-Sfcc_wrap_cim_instance(CMPIInstance *instance)
+Sfcc_wrap_cim_instance(CIMCInstance *instance)
 {
-  SFCC_INC_REFCOUNT(instance);
   return Data_Wrap_Struct(cSfccCimInstance, NULL, dealloc, instance);
 }