From beb9cd2eb219e04f9872c6a4dd743d5d1c36b4b1 Mon Sep 17 00:00:00 2001 From: Colin Walters Date: Mon, 13 Jun 2005 03:01:30 +0000 Subject: 2005-06-12 Colin Walters Async signals and various bugfixes and testing by Ross Burton . * 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. --- glib/dbus-gvalue-utils.c | 715 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 715 insertions(+) create mode 100644 glib/dbus-gvalue-utils.c (limited to 'glib/dbus-gvalue-utils.c') 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 +#include +#include + + +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); +} -- cgit