dbus 0.1.5

data/ext/ruby-dbus-message-iter.c

@@ -0,0 +1,661 @@
+/*--------------------------------------------------
+ * D-BUS bindings for Ruby
+ * (C) Copyright 2004 Leon Breedt
+ * (C) Copyright 2004 Provenco Group Ltd
+ *
+ * Licensed under the same terms as the D-BUS library
+ *--------------------------------------------------*/
+
+#include <stdlib.h>
+#include "ruby-dbus.h"
+
+/* NB: We wrap DBusMessageIter so that we are able to unref the associated message (if any)
+ *     when the DBusMessageIter instance is GC'd. */
+struct _RubyDBusMessageIter {
+  DBusMessageIter *real_iter;
+  DBusMessage *message;
+};
+
+VALUE cDBusMessageIter;
+
+static void _free_message_iter(RubyDBusMessageIter *iter);
+static void _ensure_arg_type(DBusMessageIter *iter, int type);
+
+RDBUS_GENERATE_NEW(cDBusMessageIter, RubyDBusMessageIter *, _free_message_iter)
+RDBUS_GENERATE_GET(RubyDBusMessageIter)
+
+static RubyDBusMessageIter *
+_alloc_message_iter(DBusMessage *message, DBusMessageIter *real_iter)
+{
+  RubyDBusMessageIter *iter;
+  
+  iter = NULL;
+  iter = ALLOC(RubyDBusMessageIter);
+  if (iter == NULL)
+    rb_raise(eDBusError, "unable to allocate DBusMessageIter");
+
+  if (real_iter != NULL)
+    iter->real_iter = real_iter;
+  else
+    iter->real_iter = ALLOC(DBusMessageIter); 
+
+  if (iter->real_iter == NULL) {
+    ruby_xfree(iter);
+    rb_raise(eDBusError, "unable to allocate real DBusMessageIter");
+  }
+
+  iter->message = message;
+  if (iter->message != NULL)
+    dbus_message_ref(iter->message);
+
+  return iter;
+}
+
+RubyDBusMessageIter *
+rdbus_message_iter_new(DBusMessage *message, short is_append_iter)
+{
+  RubyDBusMessageIter *iter;
+
+  iter = _alloc_message_iter(message, NULL);
+  if (is_append_iter) {
+    dbus_message_append_iter_init(iter->message, iter->real_iter);
+  } else
+    dbus_message_iter_init(iter->message, iter->real_iter);
+  return iter;
+}
+
+static void
+_free_message_iter(RubyDBusMessageIter *iter)
+{
+  if (iter->message != NULL)
+    dbus_message_unref(iter->message);
+  ruby_xfree(iter->real_iter);
+  iter->message = NULL;
+  iter->real_iter = NULL;
+  ruby_xfree(iter);
+}
+
+static void 
+_ensure_arg_type(DBusMessageIter *iter, int type)
+{
+  if (dbus_message_iter_get_arg_type(iter) != type)
+    rb_raise(eDBusError, "argument type mismatch");
+}
+
+/*
+ *  call-seq:
+ *      has_next => true|false
+ *
+ *  Returns true if there are additional arguments after the current
+ *  iterator argument.
+ */
+static VALUE
+cDBusMessageIter_has_next(VALUE self)
+{
+  if (dbus_message_iter_has_next(ITER_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      next => true|false
+ *
+ *  Moves the iterator to the next argument.
+ */
+static VALUE
+cDBusMessageIter_next(VALUE self)
+{
+  if (dbus_message_iter_next(ITER_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      get_arg_type => typecode
+ *
+ *  Returns the argument type of the argument that the iterator
+ *  currently points at. This is one of the TYPE_xxx codes.
+ */
+static VALUE
+cDBusMessageIter_get_arg_type(VALUE self)
+{
+  return INT2FIX(dbus_message_iter_get_arg_type(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      get_array_type => typecode
+ *
+ *  Returns the element type of the array argument that the iterator currently
+ *  points at.
+ */
+static VALUE
+cDBusMessageIter_get_array_type(VALUE self)
+{
+  return INT2FIX(dbus_message_iter_get_array_type(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      get_byte => byte
+ *
+ *  Returns the byte value of the argument that the iterator currently
+ *  points at. As Ruby does not have a byte type, the returned value is
+ *  a Fixnum.
+ */
+static VALUE
+cDBusMessageIter_get_byte(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_BYTE);
+  return INT2FIX(dbus_message_iter_get_byte(ITER_GET(self)) & 0xff);
+}
+
+/*
+ *  call-seq:
+ *      get_boolean => true|false
+ *
+ *  Returns the boolean value of the argument that the iterator currently
+ *  points at.
+ */
+static VALUE
+cDBusMessageIter_get_boolean(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_BOOLEAN);
+  if (dbus_message_iter_get_boolean(ITER_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      get_int32 => integer
+ *
+ *  Returns the 32-bit integer value of the argument that the iterator
+ *  currently points at.
+ */
+static VALUE
+cDBusMessageIter_get_int32(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_INT32);
+  return INT2NUM(dbus_message_iter_get_int32(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      get_uint32 => integer
+ *
+ *  Returns the unsigned 32-bit integer value of the argument that the
+ *  iterator currently points at.
+ */
+static VALUE
+cDBusMessageIter_get_uint32(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_UINT32);
+  return INT2NUM(dbus_message_iter_get_uint32(ITER_GET(self)));
+}
+
+#ifdef DBUS_HAVE_INT64
+#if HAVE_LONG_LONG 
+/*
+ *  call-seq:
+ *      get_int64 => integer
+ *
+ *  Returns the 64-bit integer value of the argument that the
+ *  iterator currently points at.
+ */
+static VALUE
+cDBusMessageIter_get_int64(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_INT64);
+  return LL2NUM(dbus_message_iter_get_int64(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      get_uint64 => integer
+ *
+ *  Returns the unsigned 64-bit integer value of the argument that the
+ *  iterator currently points at.
+ */
+static VALUE
+cDBusMessageIter_get_uint64(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_UINT64);
+  return ULL2NUM(dbus_message_iter_get_uint64(ITER_GET(self)));
+}
+#endif
+#endif
+
+/*
+ *  call-seq:
+ *      get_double => float
+ *
+ *  Returns the floating point value of the argument that the
+ *  iterator currently points at.
+ */
+static VALUE
+cDBusMessageIter_get_double(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_DOUBLE);
+  return rb_float_new(dbus_message_iter_get_double(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      get_string => string
+ *
+ *  Returns the string value of the argument that the iterator currently
+ *  points at.
+ */
+static VALUE
+cDBusMessageIter_get_string(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_STRING);
+  return rb_str_new2(dbus_message_iter_get_string(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      get_object_path => string
+ *
+ *  Returns the object path value of the argument that the iterator currently
+ *  points at. An object path value is a String.
+ */
+static VALUE
+cDBusMessageIter_get_object_path(VALUE self)
+{
+  _ensure_arg_type(ITER_GET(self), DBUS_TYPE_OBJECT_PATH);
+  return rb_str_new2(dbus_message_iter_get_object_path(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      get_dict_key => string
+ *  
+ *  Returns the dictionary key for a dictionary entry that the
+ *  iteratory currently points to. This will only work on iterators
+ *  returned by DBusMessageIter#dict_iter.
+ */
+static VALUE
+cDBusMessageIter_get_dict_key(VALUE self)
+{
+  return rb_str_new2(dbus_message_iter_get_dict_key(ITER_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      array_iter => iterator
+ *
+ *  Returns an array iterator for the array argument that this iterator
+ *  currently points to.
+ *
+ *  See DBusMessageIter#get_array for an example of usage.
+ */
+static VALUE
+cDBusMessageIter_array_iter_new(VALUE self)
+{
+  RubyDBusMessageIter *self_iter = NULL;
+  RubyDBusMessageIter *ary_iter = NULL;
+  int array_type = DBUS_TYPE_INVALID;
+
+  self_iter = RDBUS_GET(RubyDBusMessageIter, self);
+  _ensure_arg_type(self_iter->real_iter, DBUS_TYPE_ARRAY);
+  ary_iter = _alloc_message_iter(self_iter->message, NULL);
+  dbus_message_iter_init_array_iterator(self_iter->real_iter, ary_iter->real_iter, &array_type);
+  return RDBUS_NEW(cDBusMessageIter, ary_iter);
+}
+
+/*
+ *  call-seq:
+ *      dict_iter => iterator
+ *
+ *  Returns a dictionary iterator for the dictionary argument that this
+ *  iterator currently points to. 
+ *
+ *  See DBusMessageIter#get_dict for an example of usage.
+ */
+static VALUE
+cDBusMessageIter_dict_iter_new(VALUE self)
+{
+  RubyDBusMessageIter *self_iter = NULL;
+  RubyDBusMessageIter *dict_iter = NULL;
+
+  self_iter = RDBUS_GET(RubyDBusMessageIter, self);
+  _ensure_arg_type(self_iter->real_iter, DBUS_TYPE_DICT);
+  dict_iter = _alloc_message_iter(self_iter->message, NULL);
+  dbus_message_iter_init_dict_iterator(self_iter->real_iter, dict_iter->real_iter);
+  return RDBUS_NEW(cDBusMessageIter, dict_iter);
+}
+
+/*
+ *  call-seq:
+ *      append_nil => true|false
+ *
+ *  Appends a nil argument value to this message.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_nil(VALUE self)
+{
+  if (dbus_message_iter_append_nil(ITER_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_boolean(true|false|nil) => true|false
+ *
+ *  Appends a boolean argument value to this message. +nil+ is
+ *  regarded as a false value if passed through.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_boolean(VALUE self, VALUE value)
+{
+  dbus_bool_t val;
+  if (TYPE(value) == T_FALSE || TYPE(value) == T_NIL)
+    val = FALSE;
+  else
+    val = TRUE;
+  if (dbus_message_iter_append_boolean(ITER_GET(self), val))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_byte(byte) => true|false
+ *
+ *  Appends a byte value to this message. As Ruby has no byte type, providing
+ *  an integer representing the byte value suffices. Note that the supplied
+ *  value is clamped to 8 bits.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_byte(VALUE self, VALUE value)
+{
+  unsigned char val;
+  val = NUM2UINT(value) & 0xff;
+  if (dbus_message_iter_append_byte(ITER_GET(self), val))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_int32(integer) => true|false
+ *
+ *  Appends a signed 32-bit integer value to this message. Note that your
+ *  value will be truncated if it is larger than the associated D-BUS 
+ *  type.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_int32(VALUE self, VALUE value)
+{
+  dbus_int32_t val;
+  val = NUM2INT(value);
+  if (dbus_message_iter_append_int32(ITER_GET(self), val))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_uint32(integer) => true|false
+ *
+ *  Appends an unsigned 32-bit integer value to this message. Note that your
+ *  value will be truncated if it is larger than the associated D-BUS 
+ *  type.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_uint32(VALUE self, VALUE value)
+{
+  dbus_uint32_t val;
+  val = NUM2UINT(value);
+  if (dbus_message_iter_append_uint32(ITER_GET(self), val))
+    return Qtrue;
+  return Qfalse;
+}
+
+#ifdef DBUS_HAVE_INT64
+#if HAVE_LONG_LONG 
+/*
+ *  call-seq:
+ *      append_int64(integer) => true|false
+ *
+ *  Appends a signed 64-bit integer value to this message. Note that your
+ *  value will be truncated if it is larger than the associated D-BUS 
+ *  type.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_int64(VALUE self, VALUE value)
+{
+  dbus_int64_t val;
+  val = NUM2LL(value);
+  if (dbus_message_iter_append_int64(ITER_GET(self), val))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_uint64(integer) => true|false
+ *
+ *  Appends an unsigned 64-bit integer value to this message. Note that your
+ *  value will be truncated if it is larger than the associated D-BUS 
+ *  type.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_uint64(VALUE self, VALUE value)
+{
+  dbus_uint64_t val;
+  val = NUM2LL(value);
+  if (dbus_message_iter_append_uint64(ITER_GET(self), val))
+    return Qtrue;
+  return Qfalse;
+}
+#endif
+#endif
+
+/*
+ *  call-seq:
+ *      append_double(float) => true|false
+ *
+ *  Appends a floating point value to this message. Note that your
+ *  value will be truncated if it is larger than the associated D-BUS 
+ *  type.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_double(VALUE self, VALUE value)
+{
+  double val;
+  val = NUM2DBL(value);
+  if (dbus_message_iter_append_double(ITER_GET(self), val))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_string(string) => true|false
+ *
+ *  Appends a string value to this message. 
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_string(VALUE self, VALUE value)
+{
+  if (dbus_message_iter_append_string(ITER_GET(self), StringValuePtr(value)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_object_path(string) => true|false
+ *
+ *  Appends an object path value to this message. 
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_object_path(VALUE self, VALUE value)
+{
+  if (dbus_message_iter_append_object_path(ITER_GET(self), StringValuePtr(value)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_dict_key(string) => true|false
+ *
+ *  Appends a dictionary key value to this message. Use in
+ *  conjunction with another append call for the value to populate 
+ *  a dictionary.
+ *
+ *  See DBusMessageIter#append for an example of usage.
+ *
+ *  Returns +false+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_dict_key(VALUE self, VALUE value)
+{
+  if (dbus_message_iter_append_dict_key(ITER_GET(self), StringValuePtr(value)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      append_array(typecode) => iterator
+ *
+ *  Appends an array of the specified type to this message, and returns an
+ *  iterator for adding values to the new array.
+ *
+ *  See DBusMessageIter#append for an example of usage.
+ *
+ *  Returns +nil+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_array(VALUE self, VALUE type)
+{
+  RubyDBusMessageIter *parent = NULL;
+  RubyDBusMessageIter *child = NULL;
+
+  parent = RDBUS_GET(RubyDBusMessageIter, self);
+  child = _alloc_message_iter(parent->message, NULL);
+  if (dbus_message_iter_append_array(parent->real_iter, child->real_iter, NUM2INT(type)))
+    return RDBUS_NEW(cDBusMessageIter, child);
+  _free_message_iter(child);
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      append_dict => iterator
+ *
+ *  Appends a dictionary to this message, and returns an iterator for adding
+ *  values to the new dictionary. Use DBusMessageIter#append_dict_key in
+ *  conjunction with another append method to add <tt>key=>value</tt> pairs
+ *  to the dictionary.
+ *
+ *  See DBusMessageIter#append for an example of usage.
+ *
+ *  Returns +nil+ if no memory.
+ */
+static VALUE
+cDBusMessageIter_append_dict(VALUE self)
+{
+  RubyDBusMessageIter *parent = NULL;
+  RubyDBusMessageIter *child = NULL;
+
+  parent = RDBUS_GET(RubyDBusMessageIter, self);
+  child = _alloc_message_iter(parent->message, NULL);
+  if (dbus_message_iter_append_dict(parent->real_iter, child->real_iter))
+    return RDBUS_NEW(cDBusMessageIter, child);
+  _free_message_iter(child);
+  return Qnil;
+}
+
+/*
+ *  Document-class: DBus::Binding::DBusMessageIter
+ *
+ *  The DBusMessageIter class is an iterator abstraction for accessing the
+ *  argument values of a DBusMessage.
+ *
+ *  This abstraction is quite low-level, and it is recommended that you use
+ *  the Enumerable and Array-like methods on DBusMessage to access message
+ *  argument values instead, as they perform the necessary integration with
+ *  DBusMessageIter, and will ensure that the values you get have been
+ *  converted to the correct Ruby types.
+ */
+void Init_dbus_message_iter()
+{
+  cDBusMessageIter = rb_define_class_under(mDBusBinding, "DBusMessageIter", rb_cObject);
+
+  rb_define_singleton_method(cDBusMessageIter, "new", rdbus_private_method, 0);
+
+  rb_define_method(cDBusMessageIter, "has_next", cDBusMessageIter_has_next, 0);
+  rb_define_method(cDBusMessageIter, "next", cDBusMessageIter_next, 0);
+
+  rb_define_method(cDBusMessageIter, "get_arg_type", cDBusMessageIter_get_arg_type, 0);
+  rb_define_method(cDBusMessageIter, "get_array_type", cDBusMessageIter_get_array_type, 0);
+
+  rb_define_method(cDBusMessageIter, "get_byte", cDBusMessageIter_get_byte, 0);
+  rb_define_method(cDBusMessageIter, "get_boolean", cDBusMessageIter_get_boolean, 0);
+  rb_define_method(cDBusMessageIter, "get_int32", cDBusMessageIter_get_int32, 0);
+  rb_define_method(cDBusMessageIter, "get_uint32", cDBusMessageIter_get_uint32, 0);
+
+#ifdef DBUS_HAVE_INT64
+#if HAVE_LONG_LONG
+  rb_define_method(cDBusMessageIter, "get_int64", cDBusMessageIter_get_int64, 0);
+  rb_define_method(cDBusMessageIter, "get_uint64", cDBusMessageIter_get_uint64, 0);
+#endif
+#endif
+
+  rb_define_method(cDBusMessageIter, "get_double", cDBusMessageIter_get_double, 0);
+  rb_define_method(cDBusMessageIter, "get_string", cDBusMessageIter_get_string, 0);
+  rb_define_method(cDBusMessageIter, "get_object_path", cDBusMessageIter_get_object_path, 0);
+  rb_define_method(cDBusMessageIter, "get_dict_key", cDBusMessageIter_get_dict_key, 0);
+
+  rb_define_method(cDBusMessageIter, "array_iter", cDBusMessageIter_array_iter_new, 0);
+  rb_define_method(cDBusMessageIter, "dict_iter", cDBusMessageIter_dict_iter_new, 0);
+
+  rb_define_method(cDBusMessageIter, "append_nil", cDBusMessageIter_append_nil, 0);
+  rb_define_method(cDBusMessageIter, "append_boolean", cDBusMessageIter_append_boolean, 1);
+  rb_define_method(cDBusMessageIter, "append_byte", cDBusMessageIter_append_byte, 1);
+  rb_define_method(cDBusMessageIter, "append_int32", cDBusMessageIter_append_int32, 1);
+  rb_define_method(cDBusMessageIter, "append_uint32", cDBusMessageIter_append_uint32, 1);
+
+#ifdef DBUS_HAVE_INT64
+#if HAVE_LONG_LONG
+  rb_define_method(cDBusMessageIter, "append_int64", cDBusMessageIter_append_int64, 1);
+  rb_define_method(cDBusMessageIter, "append_uint64", cDBusMessageIter_append_uint64, 1);
+#endif
+#endif
+
+  rb_define_method(cDBusMessageIter, "append_double", cDBusMessageIter_append_double, 1);
+  rb_define_method(cDBusMessageIter, "append_string", cDBusMessageIter_append_string, 1);
+  rb_define_method(cDBusMessageIter, "append_object_path", cDBusMessageIter_append_object_path, 1);
+  rb_define_method(cDBusMessageIter, "append_dict_key", cDBusMessageIter_append_dict_key, 1);
+  rb_define_method(cDBusMessageIter, "append_array", cDBusMessageIter_append_array, 1);
+  rb_define_method(cDBusMessageIter, "append_dict", cDBusMessageIter_append_dict, 0);
+}