2005-06-12 Colin Walters <walters@verbum.org>

	Async signals and various bugfixes and testing by
	Ross Burton <ross@burtonini.com>.

	* glib/dbus-gvalue.h: (struct DBusBasicGValue): Delete.
	(dbus_gvalue_genmarshal_name_from_type)
	(dbus_gvalue_ctype_from_type): Moved to dbus-binding-tool-glib.c.
	(dbus_gtype_to_dbus_type): Renamed to dbus_gtype_from_signature.
	(dbus_g_value_types_init, dbus_gtype_from_signature)
	(dbus_gtype_from_signature_iter, dbus_gtype_to_signature)
	(dbus_gtypes_from_arg_signature): New function prototypes.
	(dbus_gvalue_demarshal): Take context and error arguments.
	(dbus_gvalue_demarshal_variant): New function.
	(dbus_gvalue_demarshal_message): New function.
	(dbus_gvalue_store): Delete.

	* glib/dbus-gvalue.c:

	File has been almost entirely rewritten; now we special-case
	more types such as DBUS_TYPE_SIGNATURE, handle arrays and
	hash tables correctly, etc.  Full support for recursive values
	is not yet complete.

	* glib/dbus-gproxy.c (dbus_g_proxy_class_init): Change last
	argument of signal to G_TYPE_POINTER since we now pass a
	structure.
	(lookup_g_marshaller): Delete in favor of
	_dbus_gobject_lookup_marshaller.
	(marshal_dbus_message_to_g_marshaller): Use
	_dbus_gobject_lookup_marshaller and dbus_gvalue_demarshal_message
	to handle remote signal callbacks.
	(dbus_g_proxy_new_from_proxy): New function; creates a new
	DBusGProxy by copying an existing one.
	(dbus_g_proxy_get_interface, dbus_g_proxy_set_interface)
	(dbus_g_proxy_get_path): New functions.
	(dbus_g_proxy_marshal_args_to_message): New function;
	factored out of existing code.
	(DBUS_G_VALUE_ARRAY_COLLECT_ALL): Collect all arguments
	from a varargs array.
	(dbus_g_proxy_begin_call_internal): New function.
	(dbus_g_proxy_end_call_internal): New function.
	(dbus_g_proxy_begin_call): Take GTypes instead of DBus types
	as arguments; simply invoke dbus_g_proxy_begin_call_internal
	after collecting args into value array.
	(dbus_g_proxy_end_call): Take GTypes instead of DBus types;
	invoke dbus_g_proxy_end_call_internal.
	(dbus_g_proxy_invoke): Simply invoke begin_call_interanl and
	end_call_internal.
	(dbus_g_proxy_call_no_reply): Take GTypes instead of DBus
	types.
	(array_free_all): New function.
	(dbus_g_proxy_add_signal): Take GTypes.

	* glib/dbus-gobject.h:
	(_dbus_glib_marshal_dbus_message_to_gvalue_array): Delete.
	(_dbus_gobject_get_path, _dbus_gobject_lookup_marshaller):
	Prototype.

	* glib/dbus-gobject.c: Add a global marshal_table hash which
	stores mappings from type signatures to marshallers.  Change lots
	of invocations of dbus_gtype_to_dbus_type to
	dbus_gtype_to_signature.
	(_dbus_glib_marshal_dbus_message_to_gvalue_array): Delete.
	(introspect_signals): Fix test for query.return_type.
	(set_object_property): Update invocation of dbus_gvalue_demarshal.
	(invoke_object_method): Many changes.  Handle asynchronous
	invocations.  Convert arguments with
	dbus_gvalue_demarshal_message.  Handle errors.  Use
	DBusSignatureIter instead of strlen on args. Handle all arguments
	generically.  Special-case variants.
	(dbus_g_method_return, dbus_g_method_return_error): New function.
	(DBusGSignalClosure): New structure, closes over signal
	information.
	(dbus_g_signal_closure_new): New function.
	(dbus_g_signal_closure_finalize): New function.
	(signal_emitter_marshaller): New function; is special marshaller
	which emits signals on bus.
	(export_signals): New function; introspects object signals and
	connects to them.
	(dbus_g_object_type_install_info): Take GType instead of
	GObjectClass.
	(dbus_g_connection_register_g_object): Invoke export_signals.
	(dbus_g_connection_lookup_g_object): New function.
	(DBusGFuncSignature) New structure; used for mapping type
	signatures to marshallers.
	(funcsig_hash): New function; hashes DBusGFuncSignature.
	(funcsig_equal): New function; compares DBusGFuncSignature.
	(_dbus_gobject_lookup_marshaller): New function.
	(dbus_g_object_register_marshaller): New function; used to
	register a marshaller at runtime for a particular signature.

	* glib/dbus-gmain.c (_dbus_gmain_test): Add various tests.

	* glib/dbus-binding-tool-glib.h: Add DBUS_GLIB_ANNOTATION_ASYNC
	which notes a server method implementation should be
	asynchronous.

	* glib/dbus-binding-tool-glib.c
	(dbus_binding_tool_output_glib_server): Call
	dbus_g_value_types_init.
	(write_formal_parameters): Use dbus_gtype_from_signature.  Handle
	variants specially.
	(dbus_g_type_get_lookup_function): Turn GType into an invocation
	of a lookup function.
	(write_args_for_direction): Use dbus_g_type_get_lookup_function.
	(write_untyped_out_args): New method; write output arguments.
	(write_formal_declarations_for_direction): Function for
	writing prototypes.
	(write_formal_parameters_for_direction): Function for
	writing implementations.
	(write_typed_args_for_direction): Function for writing
	arguments prefixed with GTypes.
	(write_async_method_client): Write out async version
	of method.

	* glib/dbus-binding-tool-glib.c: Include dbus-gvalue-utils.h.
	(dbus_g_type_get_marshal_name): Move mapping from GType
	to marshal name into here.
	(dbus_g_type_get_c_name): Move into here.
	(compute_marshaller): Convert signature to type with
	dbus_gtype_from_signature, use dbus_g_type_get_marshal_name.
	(compute_marshaller_name): Ditto.
	(compute_marshaller): Handle async signal annotations.
	(gather_marshallers): Return if we don't have a known
	prefix.
	(generate_glue): Collect introspection blob here, and
	write all of the blob at the end.  This allows an object
	with multiple interfaces to work.
	Mark async methods in introspection blob.

	* glib/Makefile.am (libdbus_glib_1_la_SOURCES): Add
	dbus-gtype-specialized.c, dbus-gtype-specialized.h,
	dbus-gvalue-utils.h, dbus-gvalue-utils.c.

	* dbus/dbus-glib.h: Don't include dbus-protocol.h; this
	avoids people accidentally using DBUS_TYPE_* which should
	not be necessary anymore.
	Do include dbus-gtype-specialized.h, which are utilities
	for GLib container types.
	Add various #defines for types such as
	DBUS_TYPE_G_BOOLEAN_ARRAY.
	(DBusGValueIterator, DBusGValue): Define, not fully used
	yet.
	(dbus_g_value_get_g_type): Type for recursive value.
	(dbus_g_value_open, dbus_g_value_iterator_get_value)
	(dbus_g_value_iterator_get_values, dbus_g_value_iterator_recurse)
	(dbus_g_value_free): Prototypes.
	(dbus_g_object_register_marshaller, dbus_g_proxy_new_from_proxy): Prototype.
	(dbus_g_proxy_set_interface): Prototype.
	(dbus_g_proxy_begin_call, dbus_g_proxy_end_call)
	(dbus_g_proxy_call_no_reply): Take GLib types instead of DBus
	types.
	(dbus_g_proxy_get_path, dbus_g_proxy_get_interface):
	Accessors.
	(DBusGAsyncData, DBusGMethodInvocation): Structures for
	doing async invocations.
	(dbus_g_method_return, dbus_g_method_return_error):
	Prototypes.
	* doc/dbus-tutorial.xml: Update GLib section.

	* tools/dbus-viewer.c (load_child_nodes): Update
	for new invocation type of dbus_g_proxy_end_call.
	(load_from_service_thread_func): Ditto.

	* tools/print-introspect.c (main): Ditto.

	* tools/dbus-names-model.c (have_names_notify)
	(names_model_reload, names_model_set_connection)
	Use GTypes.

	* python/Makefile.am (INCLUDES): Define DBUS_COMPILATION,
	needed since Python bindings use GLib bindings.

	* test/glib/Makefile.am (INCLUDES): Define DBUS_COMPILATION.
	Add --prefix argument.

	* tools/Makefile.am: Define DBUS_COMPILATION.  Remove
	unneeded --ignore-unsupported arg.

	* test/glib/test-service-glib.c:
	* test/glib/test-service-glib.xml:
	* test/glib/test-dbus-glib.c: Add many more tests.

1 files changed, 715 insertions, 0 deletions

diff --git a/glib/dbus-gvalue-utils.c b/glib/dbus-gvalue-utils.c
new file mode 100644
index 00000000..9eea4bf0
--- /dev/null
+++ b/glib/dbus-gvalue-utils.c
@@ -0,0 +1,715 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-gvalue-utils.c: Non-DBus-specific functions related to GType/GValue 
+ *
+ * Copyright (C) 2005 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 2.1
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "dbus/dbus-glib.h"
+#include "dbus-gvalue-utils.h"
+#include <glib.h>
+#include <string.h>
+#include <gobject/gvaluecollector.h>
+
+
+static guint
+fixed_type_get_size (GType type)
+{
+  switch (type)
+    {
+    case G_TYPE_CHAR:
+    case G_TYPE_UCHAR:
+      return sizeof (gchar);
+    case G_TYPE_BOOLEAN:
+      return sizeof (gboolean);
+    case G_TYPE_LONG:
+    case G_TYPE_ULONG:
+      return sizeof (glong);
+    case G_TYPE_INT:
+    case G_TYPE_UINT:
+      return sizeof (gint);
+    case G_TYPE_INT64:
+    case G_TYPE_UINT64:
+      return sizeof (gint64);
+    case G_TYPE_FLOAT:
+      return sizeof (gfloat);
+    case G_TYPE_DOUBLE:
+      return sizeof (gdouble);
+    default:
+      return 0;
+    }
+}
+
+gboolean
+dbus_g_type_is_fixed (GType type)
+{
+  return fixed_type_get_size (type) > 0;
+}
+
+guint
+dbus_g_type_fixed_get_size (GType type)
+{
+  g_assert (dbus_g_type_is_fixed (type));
+  return fixed_type_get_size (type);
+}
+
+gboolean
+dbus_gvalue_store (GValue          *value,
+		   gpointer        storage)
+{
+  /* FIXME - can we use the GValue lcopy_value method
+   * to do this in a cleaner way?
+   */
+  switch (g_type_fundamental (G_VALUE_TYPE (value)))
+    {
+    case G_TYPE_CHAR:
+      *((gchar *) storage) = g_value_get_char (value);
+      return TRUE;
+    case G_TYPE_UCHAR:
+      *((guchar *) storage) = g_value_get_uchar (value);
+      return TRUE;
+    case G_TYPE_BOOLEAN:
+      *((gboolean *) storage) = g_value_get_boolean (value);
+      return TRUE;
+    case G_TYPE_LONG:
+      *((glong *) storage) = g_value_get_long (value);
+      return TRUE;
+    case G_TYPE_ULONG:
+      *((gulong *) storage) = g_value_get_ulong (value);
+      return TRUE;
+    case G_TYPE_INT:
+      *((gint *) storage) = g_value_get_int (value);
+      return TRUE;
+    case G_TYPE_UINT:
+      *((guint *) storage) = g_value_get_uint (value);
+      return TRUE;
+    case G_TYPE_INT64:
+      *((gint64 *) storage) = g_value_get_int64 (value);
+      return TRUE;
+    case G_TYPE_UINT64:
+      *((guint64 *) storage) = g_value_get_uint64 (value);
+      return TRUE;
+    case G_TYPE_DOUBLE:
+      *((gdouble *) storage) = g_value_get_double (value);
+      return TRUE;
+    case G_TYPE_STRING:
+      *((gchar **) storage) = (char*) g_value_get_string (value);
+      return TRUE;
+    case G_TYPE_POINTER:
+      *((gpointer *) storage) = g_value_get_pointer (value);
+      return TRUE;
+    case G_TYPE_OBJECT:
+      *((gpointer *) storage) = g_value_get_object (value);
+      return TRUE;
+    case G_TYPE_BOXED:
+      *((gpointer *) storage) = g_value_get_boxed (value);
+      return TRUE;
+    default:
+      return FALSE;
+    }
+}
+
+gboolean
+dbus_gvalue_set_from_pointer (GValue          *value,
+			      gconstpointer    storage)
+{
+  /* FIXME - is there a better way to do this? */
+  switch (g_type_fundamental (G_VALUE_TYPE (value)))
+    {
+    case G_TYPE_CHAR:
+      g_value_set_char (value, *((gchar *) storage));
+      return TRUE;
+    case G_TYPE_UCHAR:
+      g_value_set_uchar (value, *((guchar *) storage));
+      return TRUE;
+    case G_TYPE_BOOLEAN:
+      g_value_set_boolean (value, *((gboolean *) storage));
+      return TRUE;
+    case G_TYPE_LONG:
+      g_value_set_long (value, *((glong *) storage));
+      return TRUE;
+    case G_TYPE_ULONG:
+      g_value_set_ulong (value, *((gulong *) storage));
+      return TRUE;
+    case G_TYPE_INT:
+      g_value_set_int (value, *((gint *) storage));
+      return TRUE;
+    case G_TYPE_UINT:
+      g_value_set_uint (value, *((guint *) storage));
+      return TRUE;
+    case G_TYPE_INT64:
+      g_value_set_int64 (value, *((gint64 *) storage));
+      return TRUE;
+    case G_TYPE_UINT64:
+      g_value_set_uint64 (value, *((guint64 *) storage));
+      return TRUE;
+    case G_TYPE_DOUBLE:
+      g_value_set_double (value, *((gdouble *) storage));
+      return TRUE;
+    case G_TYPE_STRING:
+      g_value_set_string (value, *((gchar **) storage));
+      return TRUE;
+    case G_TYPE_POINTER:
+      g_value_set_pointer (value, *((gpointer *) storage));
+      return TRUE;
+    case G_TYPE_OBJECT:
+      g_value_set_object (value, *((gpointer *) storage));
+      return TRUE;
+    case G_TYPE_BOXED:
+      g_value_set_boxed (value, *((gpointer *) storage));
+      return TRUE;
+    default:
+      return FALSE;
+    }
+}
+
+gboolean
+dbus_gvalue_take (GValue          *value,
+		  GTypeCValue     *cvalue)
+{
+  GType g_type;
+  GTypeValueTable *value_table;
+  char *error_msg;
+
+  g_type = G_VALUE_TYPE (value);
+  value_table = g_type_value_table_peek (g_type);
+
+  error_msg = value_table->collect_value (value, 1, cvalue, G_VALUE_NOCOPY_CONTENTS);
+  if (error_msg)
+    {
+      g_warning ("%s: %s", G_STRLOC, error_msg);
+      g_free (error_msg);
+      return FALSE;
+    }
+  /* Clear the NOCOPY_CONTENTS flag; we want to take ownership
+   * of the value.
+   */
+  value->data[1].v_uint &= ~(G_VALUE_NOCOPY_CONTENTS);
+  return TRUE;
+}
+
+static gboolean
+hash_func_from_gtype (GType gtype, GHashFunc *func)
+{
+  switch (gtype)
+    {
+    case G_TYPE_CHAR:
+    case G_TYPE_UCHAR:
+    case G_TYPE_BOOLEAN:
+    case G_TYPE_INT:
+    case G_TYPE_UINT:
+      *func = NULL;
+      return TRUE;
+    case G_TYPE_STRING:
+      *func = g_str_hash;
+      return TRUE;
+    default:
+      return FALSE;
+    }
+}
+
+static gboolean
+hash_free_from_gtype (GType gtype, GDestroyNotify *func)
+{
+  switch (gtype)
+    {
+    case G_TYPE_CHAR:
+    case G_TYPE_UCHAR:
+    case G_TYPE_BOOLEAN:
+    case G_TYPE_INT:
+    case G_TYPE_UINT:
+      *func = NULL;
+      return TRUE;
+    case G_TYPE_STRING:
+      *func = g_free;
+      return TRUE;
+    default:
+      if (gtype == G_TYPE_VALUE)
+	{
+	  *func = (GDestroyNotify) g_value_unset;
+	  return TRUE;
+	}
+      return FALSE;
+    }
+}
+
+gboolean
+dbus_gtype_is_valid_hash_key (GType type)
+{
+  GHashFunc func;
+  return hash_func_from_gtype (type, &func);
+}
+
+gboolean
+dbus_gtype_is_valid_hash_value (GType type)
+{
+  GDestroyNotify func;
+  return hash_free_from_gtype (type, &func);
+}
+
+GHashFunc
+dbus_g_hash_func_from_gtype (GType gtype)
+{
+  GHashFunc func;
+  gboolean ret;
+  ret = hash_func_from_gtype (gtype, &func);
+  g_assert (ret != FALSE);
+  return func;
+}
+
+GEqualFunc
+dbus_g_hash_equal_from_gtype (GType gtype)
+{
+  g_assert (dbus_gtype_is_valid_hash_key (gtype));
+
+  switch (gtype)
+    {
+    case G_TYPE_CHAR:
+    case G_TYPE_UCHAR:
+    case G_TYPE_BOOLEAN:
+    case G_TYPE_INT:
+    case G_TYPE_UINT:
+      return NULL;
+    case G_TYPE_STRING:
+      return g_str_equal;
+    default:
+      g_assert_not_reached ();
+      return NULL;
+    }
+}
+
+GDestroyNotify
+dbus_g_hash_free_from_gtype (GType gtype)
+{
+  GDestroyNotify func;
+  gboolean ret;
+  ret = hash_free_from_gtype (gtype, &func);
+  g_assert (ret != FALSE);
+  return func;
+}
+
+static void
+gvalue_from_hash_value (GValue *value, gpointer instance)
+{
+  switch (g_type_fundamental (G_VALUE_TYPE (value)))
+    {
+    case G_TYPE_CHAR:
+      g_value_set_char (value, (gchar) GPOINTER_TO_INT (instance));
+      break;
+    case G_TYPE_UCHAR:
+      g_value_set_uchar (value, (guchar) GPOINTER_TO_UINT (instance));
+      break;
+    case G_TYPE_BOOLEAN:
+      g_value_set_boolean (value, (gboolean) GPOINTER_TO_UINT (instance));
+      break;
+    case G_TYPE_INT:
+      g_value_set_int (value, GPOINTER_TO_INT (instance));
+      break;
+    case G_TYPE_UINT:
+      g_value_set_uint (value, GPOINTER_TO_UINT (instance));
+      break;
+    case G_TYPE_STRING:
+      g_value_set_static_string (value, instance);
+      break;
+    case G_TYPE_POINTER:
+      g_value_set_pointer (value, instance);
+      break;
+    case G_TYPE_BOXED:
+      g_value_set_static_boxed (value, instance);
+      break;
+    case G_TYPE_OBJECT:
+      g_value_set_object (value, instance);
+      g_object_unref (g_value_get_object (value));
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+}
+
+static gpointer
+hash_value_from_gvalue (GValue *value)
+{
+  switch (g_type_fundamental (G_VALUE_TYPE (value)))
+    {
+    case G_TYPE_CHAR:
+      return GINT_TO_POINTER ((int) g_value_get_char (value));
+      break;
+    case G_TYPE_UCHAR:
+      return GUINT_TO_POINTER ((guint) g_value_get_uchar (value));
+      break;
+    case G_TYPE_BOOLEAN:
+      return GUINT_TO_POINTER ((guint) g_value_get_boolean (value));
+      break;
+    case G_TYPE_INT:
+      return GINT_TO_POINTER (g_value_get_int (value));
+      break;
+    case G_TYPE_UINT:
+      return GUINT_TO_POINTER (g_value_get_uint (value));
+      break;
+    case G_TYPE_STRING:
+      return (gpointer) g_value_get_string (value);
+      break;
+    case G_TYPE_POINTER:
+      return g_value_get_pointer (value);
+      break;
+    case G_TYPE_BOXED:
+      return g_value_get_boxed (value);
+      break;
+    case G_TYPE_OBJECT:
+      return g_value_get_object (value);
+      break;
+    default:
+      g_assert_not_reached ();
+      return NULL;
+    }
+}
+
+struct DBusGHashTableValueForeachData
+{
+  DBusGTypeSpecializedMapIterator func;
+  GType key_type;
+  GType value_type;
+  gpointer data;
+};
+
+static void
+hashtable_foreach_with_values (gpointer key, gpointer value, gpointer user_data)
+{
+  GValue key_val = {0, };
+  GValue value_val = {0, };
+  struct DBusGHashTableValueForeachData *data = user_data;
+  
+  g_value_init (&key_val, data->key_type);
+  g_value_init (&value_val, data->value_type);
+  gvalue_from_hash_value (&key_val, key);
+  gvalue_from_hash_value (&value_val, value);
+
+  data->func (&key_val, &value_val, data->data);
+}
+
+
+static void
+hashtable_iterator (GType                           hash_type,
+		    gpointer                        instance,
+		    DBusGTypeSpecializedMapIterator iterator,
+		    gpointer                        user_data)
+{
+  struct DBusGHashTableValueForeachData data;
+  GType key_gtype;
+  GType value_gtype;
+
+  key_gtype = dbus_g_type_get_map_key_specialization (hash_type);
+  value_gtype = dbus_g_type_get_map_value_specialization (hash_type);
+
+  data.func = iterator;
+  data.key_type = key_gtype;
+  data.value_type = value_gtype;
+  data.data = user_data;
+
+  g_hash_table_foreach (instance, hashtable_foreach_with_values, &data);
+}
+
+void
+dbus_g_hash_table_insert_steal_values (GHashTable *table,
+				       GValue     *key_val,
+				       GValue     *value_val)
+{
+  gpointer key, val;
+  
+  key = hash_value_from_gvalue (key_val);
+  val = hash_value_from_gvalue (value_val);
+
+  g_hash_table_insert (table, key, val);
+}
+
+static gpointer
+hashtable_constructor (GType type)
+{
+  GHashTable *ret;
+  GType key_gtype;
+  GType value_gtype;
+
+  key_gtype = dbus_g_type_get_map_key_specialization (type);
+  value_gtype = dbus_g_type_get_map_value_specialization (type);
+
+  ret = g_hash_table_new_full (dbus_g_hash_func_from_gtype (key_gtype),
+			       dbus_g_hash_equal_from_gtype (key_gtype),
+			       dbus_g_hash_free_from_gtype (key_gtype),
+			       dbus_g_hash_free_from_gtype (value_gtype));
+  return ret;
+}
+
+static void
+hashtable_insert_values (GHashTable       *table,
+			 const GValue     *key_val,
+			 const GValue     *value_val)
+{
+  GValue key_copy = {0, };
+  GValue value_copy = {0, };
+
+  g_value_init (&key_copy, G_VALUE_TYPE (key_val));
+  g_value_copy (key_val, &key_copy);
+  g_value_init (&value_copy, G_VALUE_TYPE (value_val));
+  g_value_copy (value_val, &value_copy);
+  
+  dbus_g_hash_table_insert_steal_values (table, &key_copy, &value_copy);
+}
+
+static void
+hashtable_foreach_copy (const GValue *key, const GValue *val, gpointer data)
+{
+  hashtable_insert_values ((GHashTable *) data, key, val);
+}
+
+static gpointer
+hashtable_copy (GType type, gpointer src)
+{
+  GHashTable *ghash;
+  GHashTable *ret;
+  GValue hashval = {0,};
+
+  ghash = src;
+
+  ret = hashtable_constructor (type);
+
+  g_value_init (&hashval, type);
+  g_value_set_static_boxed (&hashval, ghash); 
+  dbus_g_type_map_value_iterate (&hashval, hashtable_foreach_copy, ret);
+  return ret;
+}
+
+static void
+hashtable_free (GType type, gpointer val)
+{
+  g_hash_table_destroy (val);
+}
+
+static gpointer
+array_constructor (GType type)
+{
+  GArray *array;
+  guint elt_size;
+  GType elt_type;
+  gboolean zero_terminated;
+  gboolean clear;
+
+  elt_type = dbus_g_type_get_collection_specialization (type);
+  g_assert (elt_type != G_TYPE_INVALID);
+
+  elt_size = dbus_g_type_fixed_get_size (elt_type);
+
+  /* These are "safe" defaults */ 
+  zero_terminated = TRUE; /* ((struct _DBusGRealArray*) garray)->zero_terminated; */
+  clear = TRUE; /* ((struct _DBusGRealArray*) garray)->clear; */
+
+  array = g_array_new (zero_terminated, clear, elt_size);
+  return array;
+}
+
+static gpointer
+array_copy (GType type, gpointer src)
+{
+  GArray *garray;
+  GArray *new;
+
+  garray = src;
+
+  new = array_constructor (type);
+  g_array_append_vals (new, garray->data, garray->len);
+
+  return new;
+}
+
+static void
+array_free (GType type, gpointer val)
+{
+  GArray *array;
+  array = val;
+  g_array_free (array, TRUE);
+}
+
+static gboolean
+array_fixed_accessor (GType type, gpointer instance, gpointer *values, guint *len)
+{
+  GType elt_type;
+  GArray *array = instance;
+
+  elt_type = dbus_g_type_get_collection_specialization (type);
+  if (!dbus_g_type_is_fixed (elt_type))
+    return FALSE;
+
+  *values = array->data;
+  *len = array->len;
+  return TRUE;
+}
+
+static gpointer
+ptrarray_constructor (GType type)
+{
+  /* Later we should determine a destructor, need g_ptr_array_destroy */
+  return g_ptr_array_new ();
+}
+
+static void
+gvalue_from_ptrarray_value (GValue *value, gpointer instance)
+{
+  switch (g_type_fundamental (G_VALUE_TYPE (value)))
+    {
+    case G_TYPE_POINTER:
+      g_value_set_pointer (value, instance);
+      break;
+    case G_TYPE_BOXED:
+      g_value_set_static_boxed (value, instance);
+      break;
+    case G_TYPE_OBJECT:
+      g_value_set_object (value, instance);
+      g_object_unref (g_value_get_object (value));
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+}
+
+static gpointer
+ptrarray_value_from_gvalue (const GValue *value)
+{
+  switch (g_type_fundamental (G_VALUE_TYPE (value)))
+    {
+    case G_TYPE_POINTER:
+      return g_value_get_pointer (value);
+      break;
+    case G_TYPE_BOXED:
+      return g_value_get_boxed (value);
+      break;
+    case G_TYPE_OBJECT:
+      return g_value_get_object (value);
+      break;
+    default:
+      g_assert_not_reached ();
+      return NULL;
+    }
+}
+
+static void
+ptrarray_iterator (GType                                   hash_type,
+		   gpointer                                instance,
+		   DBusGTypeSpecializedCollectionIterator  iterator,
+		   gpointer                                user_data)
+{
+  GPtrArray *ptrarray;
+  GType elt_gtype;
+  guint i;
+
+  ptrarray = instance;
+
+  elt_gtype = dbus_g_type_get_collection_specialization (hash_type);
+
+  for (i = 0; i < ptrarray->len; i++)
+    {
+      GValue val = {0, };
+      g_value_init (&val, elt_gtype);
+      gvalue_from_ptrarray_value (&val, g_ptr_array_index (ptrarray, i));
+      iterator (&val, user_data);
+    }
+}
+
+static void
+ptrarray_copy_elt (const GValue *val, gpointer user_data)
+{
+  GPtrArray *dest = user_data;
+  GValue val_copy = {0, }; 
+  
+  g_value_init (&val_copy, G_VALUE_TYPE (val));
+  g_value_copy (val, &val_copy);
+
+  g_ptr_array_add (dest, ptrarray_value_from_gvalue (&val_copy));
+}
+
+static gpointer
+ptrarray_copy (GType type, gpointer src)
+{
+  GPtrArray *new;
+  GValue array_val = {0, };
+
+  g_value_init (&array_val, type);
+  g_value_set_static_boxed (&array_val, src);
+
+  new = ptrarray_constructor (type);
+  dbus_g_type_collection_value_iterate (&array_val, ptrarray_copy_elt, new);
+
+  return new;
+}
+
+static void
+ptrarray_free (GType type, gpointer val)
+{
+  GArray *array;
+  array = val;
+  g_array_free (array, TRUE);
+}
+
+void
+dbus_g_type_specialized_builtins_init (void)
+{
+  static const DBusGTypeSpecializedCollectionVtable array_vtable = {
+    {
+      array_constructor,
+      array_free,
+      array_copy,
+      NULL,
+      NULL,
+      NULL
+    },
+    array_fixed_accessor,
+    NULL
+  };
+
+  dbus_g_type_register_collection ("GArray", &array_vtable, 0);
+
+  static const DBusGTypeSpecializedCollectionVtable ptrarray_vtable = {
+    {
+      ptrarray_constructor,
+      ptrarray_free,
+      ptrarray_copy,
+      NULL,
+      NULL,
+      NULL
+    },
+    NULL,
+    ptrarray_iterator
+  };
+
+  dbus_g_type_register_collection ("GPtrArray", &ptrarray_vtable, 0);
+
+  static const DBusGTypeSpecializedMapVtable hashtable_vtable = {
+    {
+      hashtable_constructor,
+      hashtable_free,
+      hashtable_copy,
+      NULL,
+      NULL,
+      NULL
+    },
+    hashtable_iterator
+  };
+
+  dbus_g_type_register_map ("GHashTable", &hashtable_vtable, 0);
+}