Symaptic: os/ossrv/ofdbus/dbus-glib/dbus/dbus-gvalue-utils.c@bde4ae8d615e (annotated)

sl@0	1	/* -- mode: C; c-file-style: "gnu" -- */
sl@0	2	/* dbus-gvalue-utils.c: Non-DBus-specific functions related to GType/GValue
sl@0	3	*
sl@0	4	* Copyright (C) 2005 Red Hat, Inc.
sl@0	5	* Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
sl@0	6	* Licensed under the Academic Free License version 2.1
sl@0	7	*
sl@0	8	* This program is free software; you can redistribute it and/or modify
sl@0	9	* it under the terms of the GNU General Public License as published by
sl@0	10	* the Free Software Foundation; either version 2 of the License, or
sl@0	11	* (at your option) any later version.
sl@0	12	*
sl@0	13	* This program is distributed in the hope that it will be useful,
sl@0	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
sl@0	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
sl@0	16	* GNU General Public License for more details.
sl@0	17	*
sl@0	18	* You should have received a copy of the GNU General Public License
sl@0	19	* along with this program; if not, write to the Free Software
sl@0	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
sl@0	21	*
sl@0	22	*/
sl@0	23
sl@0	24	#ifndef __SYMBIAN32__
sl@0	25	#include <config.h>
sl@0	26	#else
sl@0	27	#include "config.h"
sl@0	28	#endif //__SYMBIAN32__
sl@0	29	#include "dbus/dbus-glib.h"
sl@0	30	#include "dbus-gvalue-utils.h"
sl@0	31	#include "dbus-gtest.h"
sl@0	32	#include <glib.h>
sl@0	33	#include <string.h>
sl@0	34	#include <gobject/gvaluecollector.h>
sl@0	35
sl@0	36
sl@0	37	static guint
sl@0	38	fixed_type_get_size (GType type)
sl@0	39	{
sl@0	40	switch (type)
sl@0	41	{
sl@0	42	case G_TYPE_CHAR:
sl@0	43	case G_TYPE_UCHAR:
sl@0	44	return sizeof (gchar);
sl@0	45	case G_TYPE_BOOLEAN:
sl@0	46	return sizeof (gboolean);
sl@0	47	case G_TYPE_LONG:
sl@0	48	case G_TYPE_ULONG:
sl@0	49	return sizeof (glong);
sl@0	50	case G_TYPE_INT:
sl@0	51	case G_TYPE_UINT:
sl@0	52	return sizeof (gint);
sl@0	53	case G_TYPE_INT64:
sl@0	54	case G_TYPE_UINT64:
sl@0	55	return sizeof (gint64);
sl@0	56	case G_TYPE_FLOAT:
sl@0	57	return sizeof (gfloat);
sl@0	58	case G_TYPE_DOUBLE:
sl@0	59	return sizeof (gdouble);
sl@0	60	default:
sl@0	61	return 0;
sl@0	62	}
sl@0	63	}
sl@0	64
sl@0	65	gboolean
sl@0	66	_dbus_g_type_is_fixed (GType type)
sl@0	67	{
sl@0	68	return fixed_type_get_size (type) > 0;
sl@0	69	}
sl@0	70
sl@0	71	guint
sl@0	72	_dbus_g_type_fixed_get_size (GType type)
sl@0	73	{
sl@0	74	g_assert (_dbus_g_type_is_fixed (type));
sl@0	75	return fixed_type_get_size (type);
sl@0	76	}
sl@0	77
sl@0	78	gboolean
sl@0	79	_dbus_gvalue_store (GValue *value,
sl@0	80	gpointer storage)
sl@0	81	{
sl@0	82	/* FIXME - can we use the GValue lcopy_value method
sl@0	83	* to do this in a cleaner way?
sl@0	84	*/
sl@0	85	switch (g_type_fundamental (G_VALUE_TYPE (value)))
sl@0	86	{
sl@0	87	case G_TYPE_CHAR:
sl@0	88	((gchar ) storage) = g_value_get_char (value);
sl@0	89	return TRUE;
sl@0	90	case G_TYPE_UCHAR:
sl@0	91	((guchar ) storage) = g_value_get_uchar (value);
sl@0	92	return TRUE;
sl@0	93	case G_TYPE_BOOLEAN:
sl@0	94	((gboolean ) storage) = g_value_get_boolean (value);
sl@0	95	return TRUE;
sl@0	96	case G_TYPE_LONG:
sl@0	97	((glong ) storage) = g_value_get_long (value);
sl@0	98	return TRUE;
sl@0	99	case G_TYPE_ULONG:
sl@0	100	((gulong ) storage) = g_value_get_ulong (value);
sl@0	101	return TRUE;
sl@0	102	case G_TYPE_INT:
sl@0	103	((gint ) storage) = g_value_get_int (value);
sl@0	104	return TRUE;
sl@0	105	case G_TYPE_UINT:
sl@0	106	((guint ) storage) = g_value_get_uint (value);
sl@0	107	return TRUE;
sl@0	108	case G_TYPE_INT64:
sl@0	109	((gint64 ) storage) = g_value_get_int64 (value);
sl@0	110	return TRUE;
sl@0	111	case G_TYPE_UINT64:
sl@0	112	((guint64 ) storage) = g_value_get_uint64 (value);
sl@0	113	return TRUE;
sl@0	114	case G_TYPE_DOUBLE:
sl@0	115	((gdouble ) storage) = g_value_get_double (value);
sl@0	116	return TRUE;
sl@0	117	case G_TYPE_STRING:
sl@0	118	((gchar ) storage) = (char) g_value_get_string (value);
sl@0	119	return TRUE;
sl@0	120	case G_TYPE_OBJECT:
sl@0	121	((gpointer ) storage) = g_value_get_object (value);
sl@0	122	return TRUE;
sl@0	123	case G_TYPE_BOXED:
sl@0	124	((gpointer ) storage) = g_value_get_boxed (value);
sl@0	125	return TRUE;
sl@0	126	default:
sl@0	127	return FALSE;
sl@0	128	}
sl@0	129	}
sl@0	130
sl@0	131	gboolean
sl@0	132	_dbus_gvalue_set_from_pointer (GValue *value,
sl@0	133	gconstpointer storage)
sl@0	134	{
sl@0	135	/* FIXME - is there a better way to do this? */
sl@0	136	switch (g_type_fundamental (G_VALUE_TYPE (value)))
sl@0	137	{
sl@0	138	case G_TYPE_CHAR:
sl@0	139	g_value_set_char (value, ((gchar ) storage));
sl@0	140	return TRUE;
sl@0	141	case G_TYPE_UCHAR:
sl@0	142	g_value_set_uchar (value, ((guchar ) storage));
sl@0	143	return TRUE;
sl@0	144	case G_TYPE_BOOLEAN:
sl@0	145	g_value_set_boolean (value, ((gboolean ) storage));
sl@0	146	return TRUE;
sl@0	147	case G_TYPE_LONG:
sl@0	148	g_value_set_long (value, ((glong ) storage));
sl@0	149	return TRUE;
sl@0	150	case G_TYPE_ULONG:
sl@0	151	g_value_set_ulong (value, ((gulong ) storage));
sl@0	152	return TRUE;
sl@0	153	case G_TYPE_INT:
sl@0	154	g_value_set_int (value, ((gint ) storage));
sl@0	155	return TRUE;
sl@0	156	case G_TYPE_UINT:
sl@0	157	g_value_set_uint (value, ((guint ) storage));
sl@0	158	return TRUE;
sl@0	159	case G_TYPE_INT64:
sl@0	160	g_value_set_int64 (value, ((gint64 ) storage));
sl@0	161	return TRUE;
sl@0	162	case G_TYPE_UINT64:
sl@0	163	g_value_set_uint64 (value, ((guint64 ) storage));
sl@0	164	return TRUE;
sl@0	165	case G_TYPE_DOUBLE:
sl@0	166	g_value_set_double (value, ((gdouble ) storage));
sl@0	167	return TRUE;
sl@0	168	case G_TYPE_STRING:
sl@0	169	g_value_set_string (value, ((gchar *) storage));
sl@0	170	return TRUE;
sl@0	171	case G_TYPE_OBJECT:
sl@0	172	g_value_set_object (value, ((gpointer ) storage));
sl@0	173	return TRUE;
sl@0	174	case G_TYPE_BOXED:
sl@0	175	g_value_set_boxed (value, ((gpointer ) storage));
sl@0	176	return TRUE;
sl@0	177	default:
sl@0	178	return FALSE;
sl@0	179	}
sl@0	180	}
sl@0	181
sl@0	182	gboolean
sl@0	183	_dbus_gvalue_take (GValue *value,
sl@0	184	GTypeCValue *cvalue)
sl@0	185	{
sl@0	186	GType g_type;
sl@0	187	GTypeValueTable *value_table;
sl@0	188	char *error_msg;
sl@0	189
sl@0	190	g_type = G_VALUE_TYPE (value);
sl@0	191	value_table = g_type_value_table_peek (g_type);
sl@0	192
sl@0	193	error_msg = value_table->collect_value (value, 1, cvalue, G_VALUE_NOCOPY_CONTENTS);
sl@0	194	if (error_msg)
sl@0	195	{
sl@0	196	g_warning ("%s: %s", G_STRLOC, error_msg);
sl@0	197	g_free (error_msg);
sl@0	198	return FALSE;
sl@0	199	}
sl@0	200	/* Clear the NOCOPY_CONTENTS flag; we want to take ownership
sl@0	201	* of the value.
sl@0	202	*/
sl@0	203	value->data[1].v_uint &= ~(G_VALUE_NOCOPY_CONTENTS);
sl@0	204	return TRUE;
sl@0	205	}
sl@0	206
sl@0	207	gboolean
sl@0	208	_dbus_gtype_can_signal_error (GType gtype)
sl@0	209	{
sl@0	210	switch (gtype)
sl@0	211	{
sl@0	212	case G_TYPE_BOOLEAN:
sl@0	213	case G_TYPE_INT:
sl@0	214	case G_TYPE_UINT:
sl@0	215	case G_TYPE_STRING:
sl@0	216	case G_TYPE_BOXED:
sl@0	217	case G_TYPE_OBJECT:
sl@0	218	return TRUE;
sl@0	219	default:
sl@0	220	return FALSE;
sl@0	221	}
sl@0	222	}
sl@0	223
sl@0	224	gboolean
sl@0	225	_dbus_gvalue_signals_error (const GValue *value)
sl@0	226	{
sl@0	227	/* Hardcoded rules for return value semantics for certain
sl@0	228	* types. Perhaps in the future we'd want an annotation
sl@0	229	* specifying which return values are errors, but in
sl@0	230	* reality people will probably just use boolean and
sl@0	231	* boxed, and there the semantics are pretty standard.
sl@0	232	*/
sl@0	233	switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)))
sl@0	234	{
sl@0	235	case G_TYPE_BOOLEAN:
sl@0	236	return (g_value_get_boolean (value) == FALSE);
sl@0	237	break;
sl@0	238	case G_TYPE_INT:
sl@0	239	return (g_value_get_int (value) < 0);
sl@0	240	break;
sl@0	241	case G_TYPE_UINT:
sl@0	242	return (g_value_get_uint (value) == 0);
sl@0	243	break;
sl@0	244	case G_TYPE_STRING:
sl@0	245	return (g_value_get_string (value) == NULL);
sl@0	246	break;
sl@0	247	case G_TYPE_BOXED:
sl@0	248	return (g_value_get_boxed (value) == NULL);
sl@0	249	break;
sl@0	250	case G_TYPE_OBJECT:
sl@0	251	return (g_value_get_object (value) == NULL);
sl@0	252	break;
sl@0	253	default:
sl@0	254	g_assert_not_reached ();
sl@0	255	}
sl@0	256	}
sl@0	257
sl@0	258
sl@0	259	static gboolean
sl@0	260	hash_func_from_gtype (GType gtype, GHashFunc *func)
sl@0	261	{
sl@0	262	switch (gtype)
sl@0	263	{
sl@0	264	case G_TYPE_CHAR:
sl@0	265	case G_TYPE_UCHAR:
sl@0	266	case G_TYPE_BOOLEAN:
sl@0	267	case G_TYPE_INT:
sl@0	268	case G_TYPE_UINT:
sl@0	269	*func = NULL;
sl@0	270	return TRUE;
sl@0	271	case G_TYPE_STRING:
sl@0	272	*func = g_str_hash;
sl@0	273	return TRUE;
sl@0	274	default:
sl@0	275	return FALSE;
sl@0	276	}
sl@0	277	}
sl@0	278
sl@0	279	static void
sl@0	280	unset_and_free_g_value (gpointer val)
sl@0	281	{
sl@0	282	GValue *value = val;
sl@0	283
sl@0	284	g_value_unset (value);
sl@0	285	g_free (value);
sl@0	286	}
sl@0	287
sl@0	288	static gboolean
sl@0	289	hash_free_from_gtype (GType gtype, GDestroyNotify *func)
sl@0	290	{
sl@0	291	switch (gtype)
sl@0	292	{
sl@0	293	case G_TYPE_CHAR:
sl@0	294	case G_TYPE_UCHAR:
sl@0	295	case G_TYPE_BOOLEAN:
sl@0	296	case G_TYPE_INT:
sl@0	297	case G_TYPE_UINT:
sl@0	298	*func = NULL;
sl@0	299	return TRUE;
sl@0	300	case G_TYPE_DOUBLE:
sl@0	301	case G_TYPE_STRING:
sl@0	302	*func = g_free;
sl@0	303	return TRUE;
sl@0	304	default:
sl@0	305	if (gtype == G_TYPE_VALUE)
sl@0	306	{
sl@0	307	*func = unset_and_free_g_value;
sl@0	308	return TRUE;
sl@0	309	}
sl@0	310	else if (gtype == G_TYPE_VALUE_ARRAY)
sl@0	311	{
sl@0	312	*func = (GDestroyNotify) g_value_array_free;
sl@0	313	return TRUE;
sl@0	314	}
sl@0	315	else if (dbus_g_type_is_collection (gtype))
sl@0	316	{
sl@0	317	const DBusGTypeSpecializedCollectionVtable* vtable;
sl@0	318	vtable = dbus_g_type_collection_peek_vtable (gtype);
sl@0	319	if (vtable->base_vtable.simple_free_func)
sl@0	320	{
sl@0	321	*func = vtable->base_vtable.simple_free_func;
sl@0	322	return TRUE;
sl@0	323	}
sl@0	324	}
sl@0	325	else if (dbus_g_type_is_map (gtype))
sl@0	326	{
sl@0	327	const DBusGTypeSpecializedMapVtable* vtable;
sl@0	328	vtable = dbus_g_type_map_peek_vtable (gtype);
sl@0	329	if (vtable->base_vtable.simple_free_func)
sl@0	330	{
sl@0	331	*func = vtable->base_vtable.simple_free_func;
sl@0	332	return TRUE;
sl@0	333	}
sl@0	334	}
sl@0	335	else if (dbus_g_type_is_struct (gtype))
sl@0	336	{
sl@0	337	const DBusGTypeSpecializedStructVtable *vtable;
sl@0	338	vtable = dbus_g_type_struct_peek_vtable (gtype);
sl@0	339	if (vtable->base_vtable.simple_free_func)
sl@0	340	{
sl@0	341	*func = vtable->base_vtable.simple_free_func;
sl@0	342	return TRUE;
sl@0	343	}
sl@0	344	}
sl@0	345	return FALSE;
sl@0	346	}
sl@0	347	}
sl@0	348
sl@0	349	gboolean
sl@0	350	_dbus_gtype_is_valid_hash_key (GType type)
sl@0	351	{
sl@0	352	GHashFunc func;
sl@0	353	return hash_func_from_gtype (type, &func);
sl@0	354	}
sl@0	355
sl@0	356	gboolean
sl@0	357	_dbus_gtype_is_valid_hash_value (GType type)
sl@0	358	{
sl@0	359	GDestroyNotify func;
sl@0	360	return hash_free_from_gtype (type, &func);
sl@0	361	}
sl@0	362
sl@0	363	GHashFunc
sl@0	364	_dbus_g_hash_func_from_gtype (GType gtype)
sl@0	365	{
sl@0	366	GHashFunc func;
sl@0	367	gboolean ret;
sl@0	368	ret = hash_func_from_gtype (gtype, &func);
sl@0	369	g_assert (ret != FALSE);
sl@0	370	return func;
sl@0	371	}
sl@0	372
sl@0	373	GEqualFunc
sl@0	374	_dbus_g_hash_equal_from_gtype (GType gtype)
sl@0	375	{
sl@0	376	g_assert (_dbus_gtype_is_valid_hash_key (gtype));
sl@0	377
sl@0	378	switch (gtype)
sl@0	379	{
sl@0	380	case G_TYPE_CHAR:
sl@0	381	case G_TYPE_UCHAR:
sl@0	382	case G_TYPE_BOOLEAN:
sl@0	383	case G_TYPE_INT:
sl@0	384	case G_TYPE_UINT:
sl@0	385	return NULL;
sl@0	386	case G_TYPE_STRING:
sl@0	387	return g_str_equal;
sl@0	388	default:
sl@0	389	g_assert_not_reached ();
sl@0	390	return NULL;
sl@0	391	}
sl@0	392	}
sl@0	393
sl@0	394	GDestroyNotify
sl@0	395	_dbus_g_hash_free_from_gtype (GType gtype)
sl@0	396	{
sl@0	397	GDestroyNotify func;
sl@0	398	gboolean ret;
sl@0	399	ret = hash_free_from_gtype (gtype, &func);
sl@0	400	g_assert (ret != FALSE);
sl@0	401	return func;
sl@0	402	}
sl@0	403
sl@0	404	static void gvalue_take_ptrarray_value (GValue *value, gpointer instance);
sl@0	405
sl@0	406	static void
sl@0	407	gvalue_take_hash_value (GValue *value, gpointer instance)
sl@0	408	{
sl@0	409	switch (g_type_fundamental (G_VALUE_TYPE (value)))
sl@0	410	{
sl@0	411	case G_TYPE_CHAR:
sl@0	412	g_value_set_char (value, (gchar) GPOINTER_TO_INT (instance));
sl@0	413	break;
sl@0	414	case G_TYPE_UCHAR:
sl@0	415	g_value_set_uchar (value, (guchar) GPOINTER_TO_UINT (instance));
sl@0	416	break;
sl@0	417	case G_TYPE_BOOLEAN:
sl@0	418	g_value_set_boolean (value, (gboolean) GPOINTER_TO_UINT (instance));
sl@0	419	break;
sl@0	420	case G_TYPE_INT:
sl@0	421	g_value_set_int (value, GPOINTER_TO_INT (instance));
sl@0	422	break;
sl@0	423	case G_TYPE_UINT:
sl@0	424	g_value_set_uint (value, GPOINTER_TO_UINT (instance));
sl@0	425	break;
sl@0	426	case G_TYPE_DOUBLE:
sl@0	427	g_value_set_double (value, (gdouble ) instance);
sl@0	428	break;
sl@0	429	default:
sl@0	430	gvalue_take_ptrarray_value (value, instance);
sl@0	431	break;
sl@0	432	}
sl@0	433	}
sl@0	434
sl@0	435	static gpointer ptrarray_value_from_gvalue (const GValue *value);
sl@0	436
sl@0	437	static gpointer
sl@0	438	hash_value_from_gvalue (GValue *value)
sl@0	439	{
sl@0	440	switch (g_type_fundamental (G_VALUE_TYPE (value)))
sl@0	441	{
sl@0	442	case G_TYPE_CHAR:
sl@0	443	return GINT_TO_POINTER ((int) g_value_get_char (value));
sl@0	444	break;
sl@0	445	case G_TYPE_UCHAR:
sl@0	446	return GUINT_TO_POINTER ((guint) g_value_get_uchar (value));
sl@0	447	break;
sl@0	448	case G_TYPE_BOOLEAN:
sl@0	449	return GUINT_TO_POINTER ((guint) g_value_get_boolean (value));
sl@0	450	break;
sl@0	451	case G_TYPE_INT:
sl@0	452	return GINT_TO_POINTER (g_value_get_int (value));
sl@0	453	break;
sl@0	454	case G_TYPE_UINT:
sl@0	455	return GUINT_TO_POINTER (g_value_get_uint (value));
sl@0	456	break;
sl@0	457	case G_TYPE_DOUBLE:
sl@0	458	{
sl@0	459	gdouble p = (gdouble ) g_malloc0 (sizeof (gdouble));
sl@0	460	*p = g_value_get_double (value);
sl@0	461	return (gpointer) p;
sl@0	462	}
sl@0	463	break;
sl@0	464	default:
sl@0	465	return ptrarray_value_from_gvalue (value);
sl@0	466	break;
sl@0	467	}
sl@0	468	}
sl@0	469
sl@0	470	struct DBusGHashTableValueForeachData
sl@0	471	{
sl@0	472	DBusGTypeSpecializedMapIterator func;
sl@0	473	GType key_type;
sl@0	474	GType value_type;
sl@0	475	gpointer data;
sl@0	476	};
sl@0	477
sl@0	478	static void
sl@0	479	hashtable_foreach_with_values (gpointer key, gpointer value, gpointer user_data)
sl@0	480	{
sl@0	481	GValue key_val = {0, };
sl@0	482	GValue value_val = {0, };
sl@0	483	struct DBusGHashTableValueForeachData *data = user_data;
sl@0	484
sl@0	485	g_value_init (&key_val, data->key_type);
sl@0	486	g_value_init (&value_val, data->value_type);
sl@0	487	gvalue_take_hash_value (&key_val, key);
sl@0	488	gvalue_take_hash_value (&value_val, value);
sl@0	489
sl@0	490	data->func (&key_val, &value_val, data->data);
sl@0	491	}
sl@0	492
sl@0	493
sl@0	494	static void
sl@0	495	hashtable_iterator (GType hash_type,
sl@0	496	gpointer instance,
sl@0	497	DBusGTypeSpecializedMapIterator iterator,
sl@0	498	gpointer user_data)
sl@0	499	{
sl@0	500	struct DBusGHashTableValueForeachData data;
sl@0	501	GType key_gtype;
sl@0	502	GType value_gtype;
sl@0	503
sl@0	504	key_gtype = dbus_g_type_get_map_key_specialization (hash_type);
sl@0	505	value_gtype = dbus_g_type_get_map_value_specialization (hash_type);
sl@0	506
sl@0	507	data.func = iterator;
sl@0	508	data.key_type = key_gtype;
sl@0	509	data.value_type = value_gtype;
sl@0	510	data.data = user_data;
sl@0	511
sl@0	512	g_hash_table_foreach (instance, hashtable_foreach_with_values, &data);
sl@0	513	}
sl@0	514
sl@0	515	void
sl@0	516	_dbus_g_hash_table_insert_steal_values (GHashTable *table,
sl@0	517	GValue *key_val,
sl@0	518	GValue *value_val)
sl@0	519	{
sl@0	520	gpointer key, val;
sl@0	521
sl@0	522	key = hash_value_from_gvalue (key_val);
sl@0	523	val = hash_value_from_gvalue (value_val);
sl@0	524
sl@0	525	g_hash_table_insert (table, key, val);
sl@0	526	}
sl@0	527
sl@0	528	static void
sl@0	529	hashtable_append (DBusGTypeSpecializedAppendContext *ctx,
sl@0	530	GValue *key,
sl@0	531	GValue *val)
sl@0	532	{
sl@0	533	GHashTable *table;
sl@0	534
sl@0	535	table = g_value_get_boxed (ctx->val);
sl@0	536	_dbus_g_hash_table_insert_steal_values (table, key, val);
sl@0	537	}
sl@0	538
sl@0	539	static gpointer
sl@0	540	hashtable_constructor (GType type)
sl@0	541	{
sl@0	542	GHashTable *ret;
sl@0	543	GType key_gtype;
sl@0	544	GType value_gtype;
sl@0	545
sl@0	546	key_gtype = dbus_g_type_get_map_key_specialization (type);
sl@0	547	value_gtype = dbus_g_type_get_map_value_specialization (type);
sl@0	548
sl@0	549	ret = g_hash_table_new_full (_dbus_g_hash_func_from_gtype (key_gtype),
sl@0	550	_dbus_g_hash_equal_from_gtype (key_gtype),
sl@0	551	_dbus_g_hash_free_from_gtype (key_gtype),
sl@0	552	_dbus_g_hash_free_from_gtype (value_gtype));
sl@0	553	return ret;
sl@0	554	}
sl@0	555
sl@0	556	static void
sl@0	557	hashtable_insert_values (GHashTable *table,
sl@0	558	const GValue *key_val,
sl@0	559	const GValue *value_val)
sl@0	560	{
sl@0	561	GValue key_copy = {0, };
sl@0	562	GValue value_copy = {0, };
sl@0	563
sl@0	564	g_value_init (&key_copy, G_VALUE_TYPE (key_val));
sl@0	565	g_value_copy (key_val, &key_copy);
sl@0	566	g_value_init (&value_copy, G_VALUE_TYPE (value_val));
sl@0	567	g_value_copy (value_val, &value_copy);
sl@0	568
sl@0	569	_dbus_g_hash_table_insert_steal_values (table, &key_copy, &value_copy);
sl@0	570	}
sl@0	571
sl@0	572	static void
sl@0	573	hashtable_foreach_copy (const GValue key, const GValue val, gpointer data)
sl@0	574	{
sl@0	575	hashtable_insert_values ((GHashTable *) data, key, val);
sl@0	576	}
sl@0	577
sl@0	578	static gpointer
sl@0	579	hashtable_copy (GType type, gpointer src)
sl@0	580	{
sl@0	581	GHashTable *ghash;
sl@0	582	GHashTable *ret;
sl@0	583	GValue hashval = {0,};
sl@0	584
sl@0	585	ghash = src;
sl@0	586
sl@0	587	ret = hashtable_constructor (type);
sl@0	588
sl@0	589	g_value_init (&hashval, type);
sl@0	590	g_value_set_static_boxed (&hashval, ghash);
sl@0	591	dbus_g_type_map_value_iterate (&hashval, hashtable_foreach_copy, ret);
sl@0	592	return ret;
sl@0	593	}
sl@0	594
sl@0	595	static void
sl@0	596	hashtable_simple_free (gpointer val)
sl@0	597	{
sl@0	598	g_hash_table_destroy (val);
sl@0	599	}
sl@0	600
sl@0	601	static gpointer
sl@0	602	valuearray_constructor (GType type)
sl@0	603	{
sl@0	604	GValueArray *ret;
sl@0	605	guint size = dbus_g_type_get_struct_size (type);
sl@0	606	guint i;
sl@0	607	ret = g_value_array_new (size);
sl@0	608	for (i=0; i < size; i++)
sl@0	609	{
sl@0	610	GValue val = {0,};
sl@0	611	g_value_init (&val, dbus_g_type_get_struct_member_type (type, i));
sl@0	612	g_value_array_append(ret, &val);
sl@0	613	}
sl@0	614	return (gpointer)ret;
sl@0	615	}
sl@0	616
sl@0	617	static gpointer
sl@0	618	valuearray_copy (GType type, gpointer src)
sl@0	619	{
sl@0	620	return g_value_array_copy ((GValueArray*) src);
sl@0	621	}
sl@0	622
sl@0	623	static void
sl@0	624	valuearray_simple_free (gpointer val)
sl@0	625	{
sl@0	626	g_value_array_free (val);
sl@0	627	}
sl@0	628
sl@0	629	static gboolean
sl@0	630	valuearray_get_member (GType type, gpointer instance,
sl@0	631	guint member, GValue *ret)
sl@0	632	{
sl@0	633	GValueArray va = (GValueArray) instance;
sl@0	634	const GValue *val;
sl@0	635	if (member < dbus_g_type_get_struct_size (type))
sl@0	636	{
sl@0	637	val = g_value_array_get_nth (va, member);
sl@0	638	g_value_copy (val, ret);
sl@0	639	return TRUE;
sl@0	640	}
sl@0	641	else
sl@0	642	return FALSE;
sl@0	643	}
sl@0	644
sl@0	645	static gboolean
sl@0	646	valuearray_set_member (GType type, gpointer instance,
sl@0	647	guint member, const GValue *member_type)
sl@0	648	{
sl@0	649	GValueArray va = (GValueArray) instance;
sl@0	650	GValue *vp;
sl@0	651	if (member < dbus_g_type_get_struct_size (type))
sl@0	652	{
sl@0	653	vp = g_value_array_get_nth (va, member);
sl@0	654	g_value_copy (member_type, vp);
sl@0	655	return TRUE;
sl@0	656	}
sl@0	657	else
sl@0	658	return FALSE;
sl@0	659	}
sl@0	660
sl@0	661
sl@0	662	static gpointer
sl@0	663	array_constructor (GType type)
sl@0	664	{
sl@0	665	GArray *array;
sl@0	666	guint elt_size;
sl@0	667	GType elt_type;
sl@0	668	gboolean zero_terminated;
sl@0	669	gboolean clear;
sl@0	670
sl@0	671	elt_type = dbus_g_type_get_collection_specialization (type);
sl@0	672	g_assert (elt_type != G_TYPE_INVALID);
sl@0	673
sl@0	674	elt_size = _dbus_g_type_fixed_get_size (elt_type);
sl@0	675
sl@0	676	/* These are "safe" defaults */
sl@0	677	zero_terminated = TRUE; /* ((struct _DBusGRealArray) garray)->zero_terminated; /
sl@0	678	clear = TRUE; /* ((struct _DBusGRealArray) garray)->clear; /
sl@0	679
sl@0	680	array = g_array_new (zero_terminated, clear, elt_size);
sl@0	681	return array;
sl@0	682	}
sl@0	683
sl@0	684	static gpointer
sl@0	685	array_copy (GType type, gpointer src)
sl@0	686	{
sl@0	687	GArray *garray;
sl@0	688	GArray *new;
sl@0	689
sl@0	690	garray = src;
sl@0	691
sl@0	692	new = array_constructor (type);
sl@0	693	g_array_append_vals (new, garray->data, garray->len);
sl@0	694
sl@0	695	return new;
sl@0	696	}
sl@0	697
sl@0	698	static void
sl@0	699	array_simple_free (gpointer val)
sl@0	700	{
sl@0	701	GArray *array;
sl@0	702	array = val;
sl@0	703	g_array_free (array, TRUE);
sl@0	704	}
sl@0	705
sl@0	706	static gboolean
sl@0	707	array_fixed_accessor (GType type, gpointer instance, gpointer values, guint len)
sl@0	708	{
sl@0	709	GType elt_type;
sl@0	710	GArray *array = instance;
sl@0	711
sl@0	712	elt_type = dbus_g_type_get_collection_specialization (type);
sl@0	713	if (!_dbus_g_type_is_fixed (elt_type))
sl@0	714	return FALSE;
sl@0	715
sl@0	716	*values = array->data;
sl@0	717	*len = array->len;
sl@0	718	return TRUE;
sl@0	719	}
sl@0	720
sl@0	721	static gpointer
sl@0	722	ptrarray_constructor (GType type)
sl@0	723	{
sl@0	724	/* Later we should determine a destructor, need g_ptr_array_destroy */
sl@0	725	return g_ptr_array_new ();
sl@0	726	}
sl@0	727
sl@0	728	static void
sl@0	729	gvalue_take_ptrarray_value (GValue *value, gpointer instance)
sl@0	730	{
sl@0	731	switch (g_type_fundamental (G_VALUE_TYPE (value)))
sl@0	732	{
sl@0	733	case G_TYPE_STRING:
sl@0	734	g_value_take_string (value, instance);
sl@0	735	break;
sl@0	736	case G_TYPE_BOXED:
sl@0	737	g_value_take_boxed (value, instance);
sl@0	738	break;
sl@0	739	case G_TYPE_OBJECT:
sl@0	740	g_value_take_object (value, instance);
sl@0	741	break;
sl@0	742	default:
sl@0	743	g_assert_not_reached ();
sl@0	744	break;
sl@0	745	}
sl@0	746	}
sl@0	747
sl@0	748	static gpointer
sl@0	749	ptrarray_value_from_gvalue (const GValue *value)
sl@0	750	{
sl@0	751	GValue tmp = {0, };
sl@0	752
sl@0	753	/* if the NOCOPY flag is set, then value was created via set_static and hence
sl@0	754	* is not owned by us. in order to preserve the "take" semantics that the API
sl@0	755	* has in general (which avoids copying in the common case), we must copy any
sl@0	756	* static values so that we can indiscriminately free the entire collection
sl@0	757	* later. */
sl@0	758	if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
sl@0	759	{
sl@0	760	g_value_init (&tmp, G_VALUE_TYPE (value));
sl@0	761	g_value_copy (value, &tmp);
sl@0	762	value = &tmp;
sl@0	763	}
sl@0	764
sl@0	765	switch (g_type_fundamental (G_VALUE_TYPE (value)))
sl@0	766	{
sl@0	767	case G_TYPE_STRING:
sl@0	768	return (gpointer) g_value_get_string (value);
sl@0	769	break;
sl@0	770	case G_TYPE_BOXED:
sl@0	771	return g_value_get_boxed (value);
sl@0	772	break;
sl@0	773	case G_TYPE_OBJECT:
sl@0	774	return g_value_get_object (value);
sl@0	775	break;
sl@0	776	default:
sl@0	777	g_assert_not_reached ();
sl@0	778	return NULL;
sl@0	779	}
sl@0	780	}
sl@0	781
sl@0	782	static void
sl@0	783	ptrarray_iterator (GType ptrarray_type,
sl@0	784	gpointer instance,
sl@0	785	DBusGTypeSpecializedCollectionIterator iterator,
sl@0	786	gpointer user_data)
sl@0	787	{
sl@0	788	GPtrArray *ptrarray;
sl@0	789	GType elt_gtype;
sl@0	790	guint i;
sl@0	791
sl@0	792	ptrarray = instance;
sl@0	793
sl@0	794	elt_gtype = dbus_g_type_get_collection_specialization (ptrarray_type);
sl@0	795
sl@0	796	for (i = 0; i < ptrarray->len; i++)
sl@0	797	{
sl@0	798	GValue val = {0, };
sl@0	799	g_value_init (&val, elt_gtype);
sl@0	800	gvalue_take_ptrarray_value (&val, g_ptr_array_index (ptrarray, i));
sl@0	801	iterator (&val, user_data);
sl@0	802	}
sl@0	803	}
sl@0	804
sl@0	805	static void
sl@0	806	ptrarray_copy_elt (const GValue *val, gpointer user_data)
sl@0	807	{
sl@0	808	GPtrArray *dest = user_data;
sl@0	809	GValue val_copy = {0, };
sl@0	810
sl@0	811	g_value_init (&val_copy, G_VALUE_TYPE (val));
sl@0	812	g_value_copy (val, &val_copy);
sl@0	813
sl@0	814	g_ptr_array_add (dest, ptrarray_value_from_gvalue (&val_copy));
sl@0	815	}
sl@0	816
sl@0	817	static gpointer
sl@0	818	ptrarray_copy (GType type, gpointer src)
sl@0	819	{
sl@0	820	GPtrArray *new;
sl@0	821	GValue array_val = {0, };
sl@0	822
sl@0	823	g_value_init (&array_val, type);
sl@0	824	g_value_set_static_boxed (&array_val, src);
sl@0	825
sl@0	826	new = ptrarray_constructor (type);
sl@0	827	dbus_g_type_collection_value_iterate (&array_val, ptrarray_copy_elt, new);
sl@0	828
sl@0	829	return new;
sl@0	830	}
sl@0	831
sl@0	832	static void
sl@0	833	ptrarray_append (DBusGTypeSpecializedAppendContext ctx, GValue value)
sl@0	834	{
sl@0	835	GPtrArray *array;
sl@0	836
sl@0	837	array = g_value_get_boxed (ctx->val);
sl@0	838
sl@0	839	g_ptr_array_add (array, ptrarray_value_from_gvalue (value));
sl@0	840	}
sl@0	841
sl@0	842	static void
sl@0	843	ptrarray_free (GType type, gpointer val)
sl@0	844	{
sl@0	845	GPtrArray *array;
sl@0	846	GValue elt_val = {0, };
sl@0	847	GType elt_gtype;
sl@0	848	unsigned int i;
sl@0	849
sl@0	850	array = val;
sl@0	851
sl@0	852	elt_gtype = dbus_g_type_get_collection_specialization (type);
sl@0	853
sl@0	854	for (i = 0; i < array->len; i++)
sl@0	855	{
sl@0	856	g_value_init (&elt_val, elt_gtype);
sl@0	857	gvalue_take_ptrarray_value (&elt_val, g_ptr_array_index (array, i));
sl@0	858	g_value_unset (&elt_val);
sl@0	859	}
sl@0	860
sl@0	861	g_ptr_array_free (array, TRUE);
sl@0	862	}
sl@0	863
sl@0	864	static gpointer
sl@0	865	slist_constructor (GType type)
sl@0	866	{
sl@0	867	return NULL;
sl@0	868	}
sl@0	869
sl@0	870	static void
sl@0	871	slist_iterator (GType list_type,
sl@0	872	gpointer instance,
sl@0	873	DBusGTypeSpecializedCollectionIterator iterator,
sl@0	874	gpointer user_data)
sl@0	875	{
sl@0	876	GSList *slist;
sl@0	877	GType elt_gtype;
sl@0	878
sl@0	879	slist = instance;
sl@0	880
sl@0	881	elt_gtype = dbus_g_type_get_collection_specialization (list_type);
sl@0	882
sl@0	883	for (slist = instance; slist != NULL; slist = slist->next)
sl@0	884	{
sl@0	885	GValue val = {0, };
sl@0	886	g_value_init (&val, elt_gtype);
sl@0	887	gvalue_take_ptrarray_value (&val, slist->data);
sl@0	888	iterator (&val, user_data);
sl@0	889	}
sl@0	890	}
sl@0	891
sl@0	892	static void
sl@0	893	slist_copy_elt (const GValue *val, gpointer user_data)
sl@0	894	{
sl@0	895	GSList **dest = user_data;
sl@0	896	GValue val_copy = {0, };
sl@0	897
sl@0	898	g_value_init (&val_copy, G_VALUE_TYPE (val));
sl@0	899	g_value_copy (val, &val_copy);
sl@0	900
sl@0	901	dest = g_slist_append (dest, ptrarray_value_from_gvalue (&val_copy));
sl@0	902	}
sl@0	903
sl@0	904	static gpointer
sl@0	905	slist_copy (GType type, gpointer src)
sl@0	906	{
sl@0	907	GSList *new;
sl@0	908	GValue slist_val = {0, };
sl@0	909
sl@0	910	g_value_init (&slist_val, type);
sl@0	911	g_value_set_static_boxed (&slist_val, src);
sl@0	912
sl@0	913	new = slist_constructor (type);
sl@0	914	dbus_g_type_collection_value_iterate (&slist_val, slist_copy_elt, &new);
sl@0	915
sl@0	916	return new;
sl@0	917	}
sl@0	918
sl@0	919	static void
sl@0	920	slist_append (DBusGTypeSpecializedAppendContext ctx, GValue value)
sl@0	921	{
sl@0	922	GSList *list;
sl@0	923
sl@0	924	list = g_value_get_boxed (ctx->val);
sl@0	925	list = g_slist_prepend (list, ptrarray_value_from_gvalue (value));
sl@0	926	g_value_set_static_boxed (ctx->val, list);
sl@0	927	}
sl@0	928
sl@0	929	static void
sl@0	930	slist_end_append (DBusGTypeSpecializedAppendContext *ctx)
sl@0	931	{
sl@0	932	GSList *list;
sl@0	933
sl@0	934	/* if you append multiple times to the slist, this will reverse the existing
sl@0	935	* elements... we need an init_append function */
sl@0	936	list = g_value_get_boxed (ctx->val);
sl@0	937	list = g_slist_reverse (list);
sl@0	938
sl@0	939	g_value_take_boxed (ctx->val, list);
sl@0	940	}
sl@0	941
sl@0	942	static void
sl@0	943	slist_free (GType type, gpointer val)
sl@0	944	{
sl@0	945	GSList *list;
sl@0	946	GType elt_gtype;
sl@0	947	list = val;
sl@0	948
sl@0	949	elt_gtype = dbus_g_type_get_collection_specialization (type);
sl@0	950
sl@0	951	while (list != NULL)
sl@0	952	{
sl@0	953	GValue elt_val = {0, };
sl@0	954	g_value_init (&elt_val, elt_gtype);
sl@0	955	gvalue_take_ptrarray_value (&elt_val, list->data);
sl@0	956	g_value_unset (&elt_val);
sl@0	957	list = g_slist_next(list);
sl@0	958	}
sl@0	959	list=val;
sl@0	960	g_slist_free (list);
sl@0	961	}
sl@0	962
sl@0	963	void
sl@0	964	_dbus_g_type_specialized_builtins_init (void)
sl@0	965	{
sl@0	966	/* types with a simple_free function can be freed at run-time without
sl@0	967	* the destroy function needing to know the type, so they can be
sl@0	968	* stored in hash tables */
sl@0	969
sl@0	970	static const DBusGTypeSpecializedCollectionVtable array_vtable = {
sl@0	971	{
sl@0	972	array_constructor,
sl@0	973	NULL,
sl@0	974	array_copy,
sl@0	975	array_simple_free,
sl@0	976	NULL,
sl@0	977	NULL,
sl@0	978	},
sl@0	979	array_fixed_accessor,
sl@0	980	NULL,
sl@0	981	NULL,
sl@0	982	NULL
sl@0	983	};
sl@0	984
sl@0	985
sl@0	986	static const DBusGTypeSpecializedCollectionVtable ptrarray_vtable = {
sl@0	987	{
sl@0	988	ptrarray_constructor,
sl@0	989	ptrarray_free,
sl@0	990	ptrarray_copy,
sl@0	991	NULL,
sl@0	992	NULL,
sl@0	993	NULL,
sl@0	994	},
sl@0	995	NULL,
sl@0	996	ptrarray_iterator,
sl@0	997	ptrarray_append,
sl@0	998	NULL,
sl@0	999	};
sl@0	1000
sl@0	1001
sl@0	1002	static const DBusGTypeSpecializedCollectionVtable slist_vtable = {
sl@0	1003	{
sl@0	1004	slist_constructor,
sl@0	1005	slist_free,
sl@0	1006	slist_copy,
sl@0	1007	NULL,
sl@0	1008	NULL,
sl@0	1009	NULL,
sl@0	1010	},
sl@0	1011	NULL,
sl@0	1012	slist_iterator,
sl@0	1013	slist_append,
sl@0	1014	slist_end_append,
sl@0	1015	};
sl@0	1016
sl@0	1017	static const DBusGTypeSpecializedMapVtable hashtable_vtable = {
sl@0	1018	{
sl@0	1019	hashtable_constructor,
sl@0	1020	NULL,
sl@0	1021	hashtable_copy,
sl@0	1022	hashtable_simple_free,
sl@0	1023	NULL,
sl@0	1024	NULL
sl@0	1025	},
sl@0	1026	hashtable_iterator,
sl@0	1027	hashtable_append
sl@0	1028	};
sl@0	1029
sl@0	1030	static const DBusGTypeSpecializedStructVtable valuearray_vtable = {
sl@0	1031	{
sl@0	1032	valuearray_constructor,
sl@0	1033	NULL,
sl@0	1034	valuearray_copy,
sl@0	1035	valuearray_simple_free,
sl@0	1036	NULL,
sl@0	1037	NULL
sl@0	1038	},
sl@0	1039	valuearray_get_member,
sl@0	1040	valuearray_set_member
sl@0	1041	};
sl@0	1042
sl@0	1043	dbus_g_type_register_collection ("GSList", &slist_vtable, 0);
sl@0	1044	dbus_g_type_register_collection ("GArray", &array_vtable, 0);
sl@0	1045	dbus_g_type_register_collection ("GPtrArray", &ptrarray_vtable, 0);
sl@0	1046	dbus_g_type_register_map ("GHashTable", &hashtable_vtable, 0);
sl@0	1047	dbus_g_type_register_struct ("GValueArray", &valuearray_vtable, 0);
sl@0	1048	}
sl@0	1049
sl@0	1050	#ifdef DBUS_BUILD_TESTS
sl@0	1051
sl@0	1052	typedef struct
sl@0	1053	{
sl@0	1054	gboolean seen_foo;
sl@0	1055	gboolean seen_baz;
sl@0	1056	} TestSpecializedHashData;
sl@0	1057
sl@0	1058	static void
sl@0	1059	test_specialized_hash (const GValue key, const GValue val, gpointer user_data)
sl@0	1060	{
sl@0	1061	TestSpecializedHashData *data = user_data;
sl@0	1062
sl@0	1063	g_assert (G_VALUE_HOLDS_STRING (key));
sl@0	1064	g_assert (G_VALUE_HOLDS_STRING (val));
sl@0	1065
sl@0	1066	if (!strcmp (g_value_get_string (key), "foo"))
sl@0	1067	{
sl@0	1068	data->seen_foo = TRUE;
sl@0	1069	g_assert (!strcmp (g_value_get_string (val), "bar"));
sl@0	1070	}
sl@0	1071	else if (!strcmp (g_value_get_string (key), "baz"))
sl@0	1072	{
sl@0	1073	data->seen_baz = TRUE;
sl@0	1074	g_assert (!strcmp (g_value_get_string (val), "moo"));
sl@0	1075	}
sl@0	1076	else
sl@0	1077	{
sl@0	1078	g_assert_not_reached ();
sl@0	1079	}
sl@0	1080	}
sl@0	1081
sl@0	1082	static void
sl@0	1083	test_specialized_hash_2 (const GValue key, const GValue val, gpointer user_data)
sl@0	1084	{
sl@0	1085	TestSpecializedHashData *data = user_data;
sl@0	1086	const GValue *realval;
sl@0	1087
sl@0	1088	g_assert (G_VALUE_HOLDS_STRING (key));
sl@0	1089	g_assert (G_VALUE_TYPE (val) == G_TYPE_VALUE);
sl@0	1090
sl@0	1091	realval = g_value_get_boxed (val);
sl@0	1092
sl@0	1093	if (!strcmp (g_value_get_string (key), "foo"))
sl@0	1094	{
sl@0	1095	data->seen_foo = TRUE;
sl@0	1096	g_assert (G_VALUE_HOLDS_UINT (realval));
sl@0	1097	g_assert (g_value_get_uint (realval) == 20);
sl@0	1098	}
sl@0	1099	else if (!strcmp (g_value_get_string (key), "baz"))
sl@0	1100	{
sl@0	1101	data->seen_baz = TRUE;
sl@0	1102	g_assert (G_VALUE_HOLDS_STRING (realval));
sl@0	1103	g_assert (!strcmp ("bar", g_value_get_string (realval)));
sl@0	1104	}
sl@0	1105	else
sl@0	1106	{
sl@0	1107	g_assert_not_reached ();
sl@0	1108	}
sl@0	1109	}
sl@0	1110
sl@0	1111	#ifdef __SYMBIAN32__
sl@0	1112	EXPORT_C
sl@0	1113	#endif
sl@0	1114	gboolean
sl@0	1115	_dbus_gvalue_utils_test (const char *datadir)
sl@0	1116	{
sl@0	1117	GType type;
sl@0	1118
sl@0	1119	dbus_g_type_specialized_init ();
sl@0	1120	_dbus_g_type_specialized_builtins_init ();
sl@0	1121
sl@0	1122	type = dbus_g_type_get_collection ("GArray", G_TYPE_UINT);
sl@0	1123	g_assert (dbus_g_type_is_collection (type));
sl@0	1124	g_assert (dbus_g_type_get_collection_specialization (type) == G_TYPE_UINT);
sl@0	1125	{
sl@0	1126	GArray *instance;
sl@0	1127
sl@0	1128	instance = dbus_g_type_specialized_construct (type);
sl@0	1129
sl@0	1130	g_assert (instance->len == 0);
sl@0	1131
sl@0	1132	g_array_free (instance, TRUE);
sl@0	1133	}
sl@0	1134
sl@0	1135	type = dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING);
sl@0	1136	g_assert (dbus_g_type_is_map (type));
sl@0	1137	g_assert (dbus_g_type_get_map_key_specialization (type) == G_TYPE_STRING);
sl@0	1138	g_assert (dbus_g_type_get_map_value_specialization (type) == G_TYPE_STRING);
sl@0	1139	{
sl@0	1140	GHashTable *instance;
sl@0	1141	GValue val = { 0, };
sl@0	1142	TestSpecializedHashData hashdata;
sl@0	1143
sl@0	1144	instance = dbus_g_type_specialized_construct (type);
sl@0	1145
sl@0	1146	g_assert (g_hash_table_size (instance) == 0);
sl@0	1147	g_hash_table_insert (instance, g_strdup ("foo"), g_strdup ("bar"));
sl@0	1148	g_hash_table_insert (instance, g_strdup ("baz"), g_strdup ("moo"));
sl@0	1149	g_assert (g_hash_table_size (instance) == 2);
sl@0	1150
sl@0	1151	g_value_init (&val, type);
sl@0	1152	g_value_set_boxed_take_ownership (&val, instance);
sl@0	1153	hashdata.seen_foo = FALSE;
sl@0	1154	hashdata.seen_baz = FALSE;
sl@0	1155	dbus_g_type_map_value_iterate (&val,
sl@0	1156	test_specialized_hash,
sl@0	1157	&hashdata);
sl@0	1158
sl@0	1159	g_assert (hashdata.seen_foo);
sl@0	1160	g_assert (hashdata.seen_baz);
sl@0	1161
sl@0	1162	g_value_unset (&val);
sl@0	1163	}
sl@0	1164
sl@0	1165	type = dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE);
sl@0	1166	g_assert (dbus_g_type_is_map (type));
sl@0	1167	g_assert (dbus_g_type_get_map_key_specialization (type) == G_TYPE_STRING);
sl@0	1168	g_assert (dbus_g_type_get_map_value_specialization (type) == G_TYPE_VALUE);
sl@0	1169	{
sl@0	1170	GHashTable *instance;
sl@0	1171	GValue val = { 0, };
sl@0	1172	TestSpecializedHashData hashdata;
sl@0	1173	DBusGTypeSpecializedAppendContext ctx;
sl@0	1174	GValue *eltval;
sl@0	1175
sl@0	1176	instance = dbus_g_type_specialized_construct (type);
sl@0	1177	g_value_init (&val, type);
sl@0	1178	g_value_set_boxed_take_ownership (&val, instance);
sl@0	1179
sl@0	1180	dbus_g_type_specialized_init_append (&val, &ctx);
sl@0	1181
sl@0	1182	{
sl@0	1183	GValue keyval = { 0, };
sl@0	1184	GValue valval = { 0, };
sl@0	1185	g_value_init (&keyval, G_TYPE_STRING);
sl@0	1186	g_value_set_string (&keyval, "foo");
sl@0	1187
sl@0	1188	g_value_init (&valval, G_TYPE_VALUE);
sl@0	1189	eltval = g_new0 (GValue, 1);
sl@0	1190	g_value_init (eltval, G_TYPE_UINT);
sl@0	1191	g_value_set_uint (eltval, 20);
sl@0	1192	g_value_set_boxed_take_ownership (&valval, eltval);
sl@0	1193	dbus_g_type_specialized_map_append (&ctx, &keyval, &valval);
sl@0	1194	}
sl@0	1195
sl@0	1196	{
sl@0	1197	GValue keyval = { 0, };
sl@0	1198	GValue valval = { 0, };
sl@0	1199	g_value_init (&keyval, G_TYPE_STRING);
sl@0	1200	g_value_set_string (&keyval, "baz");
sl@0	1201	g_value_init (&valval, G_TYPE_VALUE);
sl@0	1202	eltval = g_new0 (GValue, 1);
sl@0	1203	g_value_init (eltval, G_TYPE_STRING);
sl@0	1204	g_value_set_string (eltval, "bar");
sl@0	1205	g_value_set_boxed_take_ownership (&valval, eltval);
sl@0	1206	dbus_g_type_specialized_map_append (&ctx, &keyval, &valval);
sl@0	1207	}
sl@0	1208
sl@0	1209	hashdata.seen_foo = FALSE;
sl@0	1210	hashdata.seen_baz = FALSE;
sl@0	1211	dbus_g_type_map_value_iterate (&val,
sl@0	1212	test_specialized_hash_2,
sl@0	1213	&hashdata);
sl@0	1214
sl@0	1215	g_assert (hashdata.seen_foo);
sl@0	1216	g_assert (hashdata.seen_baz);
sl@0	1217
sl@0	1218	g_value_unset (&val);
sl@0	1219	}
sl@0	1220
sl@0	1221	type = dbus_g_type_get_collection ("GSList", G_TYPE_OBJECT);
sl@0	1222	g_assert (dbus_g_type_is_collection (type));
sl@0	1223	g_assert (dbus_g_type_get_collection_specialization (type) == G_TYPE_OBJECT);
sl@0	1224	{
sl@0	1225	GSList instance, tmp, *copy;
sl@0	1226	GValue val = {0, };
sl@0	1227	GValue copyval = {0, };
sl@0	1228	DBusGTypeSpecializedAppendContext ctx;
sl@0	1229	GObject *objects[3];
sl@0	1230	int i;
sl@0	1231
sl@0	1232	instance = dbus_g_type_specialized_construct (type);
sl@0	1233	g_assert (instance == NULL);
sl@0	1234
sl@0	1235	g_value_init (&val, type);
sl@0	1236	g_value_take_boxed (&val, instance);
sl@0	1237
sl@0	1238	dbus_g_type_specialized_init_append (&val, &ctx);
sl@0	1239
sl@0	1240	for (i = 0; i < 3; i++)
sl@0	1241	{
sl@0	1242	GValue eltval = { 0, };
sl@0	1243	GObject *obj = g_object_new (G_TYPE_OBJECT, NULL);
sl@0	1244
sl@0	1245	g_assert (obj != NULL);
sl@0	1246	objects[i] = obj;
sl@0	1247	g_object_add_weak_pointer (obj, (gpointer) (objects + i));
sl@0	1248
sl@0	1249	g_value_init (&eltval, G_TYPE_OBJECT);
sl@0	1250	g_value_take_object (&eltval, obj);
sl@0	1251	dbus_g_type_specialized_collection_append (&ctx, &eltval);
sl@0	1252	}
sl@0	1253
sl@0	1254	dbus_g_type_specialized_collection_end_append (&ctx);
sl@0	1255
sl@0	1256	instance = g_value_get_boxed (&val);
sl@0	1257	g_assert (g_slist_length (instance) == 3);
sl@0	1258
sl@0	1259	for (tmp = instance; tmp; tmp = tmp->next)
sl@0	1260	{
sl@0	1261	GObject *obj = tmp->data;
sl@0	1262	g_assert (G_IS_OBJECT (obj));
sl@0	1263	g_assert (obj->ref_count == 1);
sl@0	1264	}
sl@0	1265
sl@0	1266	g_value_init (&copyval, type);
sl@0	1267	g_value_copy (&val, &copyval);
sl@0	1268
sl@0	1269	copy = g_value_get_boxed (&copyval);
sl@0	1270	g_assert (g_slist_length (copy) == 3);
sl@0	1271
sl@0	1272	for (tmp = copy; tmp; tmp = tmp->next)
sl@0	1273	{
sl@0	1274	GObject *obj = tmp->data;
sl@0	1275	g_assert (G_IS_OBJECT (obj));
sl@0	1276	g_assert (obj->ref_count == 2);
sl@0	1277	}
sl@0	1278
sl@0	1279	g_value_unset (&copyval);
sl@0	1280
sl@0	1281	for (i = 0; i < 3; i++)
sl@0	1282	{
sl@0	1283	g_assert (objects[i] != NULL);
sl@0	1284	}
sl@0	1285
sl@0	1286	for (tmp = instance; tmp; tmp = tmp->next)
sl@0	1287	{
sl@0	1288	GObject *obj = tmp->data;
sl@0	1289	g_assert (G_IS_OBJECT (obj));
sl@0	1290	g_assert (obj->ref_count == 1);
sl@0	1291	}
sl@0	1292
sl@0	1293	g_value_unset (&val);
sl@0	1294
sl@0	1295	for (i = 0; i < 3; i++)
sl@0	1296	{
sl@0	1297	g_assert (objects[i] == NULL);
sl@0	1298	}
sl@0	1299	}
sl@0	1300
sl@0	1301	type = dbus_g_type_get_collection ("GPtrArray", G_TYPE_STRING);
sl@0	1302	g_assert (dbus_g_type_is_collection (type));
sl@0	1303	g_assert (dbus_g_type_get_collection_specialization (type) == G_TYPE_STRING);
sl@0	1304	{
sl@0	1305	GPtrArray *instance;
sl@0	1306	DBusGTypeSpecializedAppendContext ctx;
sl@0	1307	GValue val = {0, };
sl@0	1308	GValue eltval = {0, };
sl@0	1309
sl@0	1310	instance = dbus_g_type_specialized_construct (type);
sl@0	1311
sl@0	1312	g_assert (instance->len == 0);
sl@0	1313
sl@0	1314	g_value_init (&val, type);
sl@0	1315	g_value_set_boxed_take_ownership (&val, instance);
sl@0	1316
sl@0	1317	dbus_g_type_specialized_init_append (&val, &ctx);
sl@0	1318
sl@0	1319	g_value_init (&eltval, G_TYPE_STRING);
sl@0	1320	g_value_set_static_string (&eltval, "foo");
sl@0	1321	dbus_g_type_specialized_collection_append (&ctx, &eltval);
sl@0	1322
sl@0	1323	g_value_reset (&eltval);
sl@0	1324	g_value_set_static_string (&eltval, "bar");
sl@0	1325	dbus_g_type_specialized_collection_append (&ctx, &eltval);
sl@0	1326
sl@0	1327	g_value_reset (&eltval);
sl@0	1328	g_value_set_static_string (&eltval, "baz");
sl@0	1329	dbus_g_type_specialized_collection_append (&ctx, &eltval);
sl@0	1330
sl@0	1331	dbus_g_type_specialized_collection_end_append (&ctx);
sl@0	1332
sl@0	1333	g_assert (instance->len == 3);
sl@0	1334
sl@0	1335	g_assert (!strcmp ("foo", g_ptr_array_index (instance, 0)));
sl@0	1336	g_assert (!strcmp ("bar", g_ptr_array_index (instance, 1)));
sl@0	1337	g_assert (!strcmp ("baz", g_ptr_array_index (instance, 2)));
sl@0	1338
sl@0	1339	g_value_unset (&val);
sl@0	1340	}
sl@0	1341
sl@0	1342	type = dbus_g_type_get_struct ("GValueArray", G_TYPE_STRING, G_TYPE_UINT, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
sl@0	1343	g_assert (dbus_g_type_is_struct (type));
sl@0	1344	g_assert (dbus_g_type_get_struct_size (type) == 3);
sl@0	1345	g_assert (dbus_g_type_get_struct_member_type (type, 0) == G_TYPE_STRING);
sl@0	1346	g_assert (dbus_g_type_get_struct_member_type (type, 1) == G_TYPE_UINT);
sl@0	1347	g_assert (dbus_g_type_get_struct_member_type (type, 2) == DBUS_TYPE_G_OBJECT_PATH);
sl@0	1348	{
sl@0	1349	GValueArray *instance;
sl@0	1350	GValue val = {0, };
sl@0	1351	GValue memval = {0, };
sl@0	1352
sl@0	1353	instance = dbus_g_type_specialized_construct (type);
sl@0	1354
sl@0	1355	g_assert (instance->n_values == 3);
sl@0	1356
sl@0	1357	g_value_init (&val, type);
sl@0	1358	g_value_set_boxed_take_ownership (&val, instance);
sl@0	1359
sl@0	1360	g_value_init (&memval, G_TYPE_STRING);
sl@0	1361	g_value_set_static_string (&memval, "foo");
sl@0	1362	dbus_g_type_struct_set_member (&val, 0, &memval);
sl@0	1363	g_value_unset (&memval);
sl@0	1364
sl@0	1365	g_value_init (&memval, G_TYPE_UINT);
sl@0	1366	g_value_set_uint (&memval, 42);
sl@0	1367	dbus_g_type_struct_set_member (&val, 1, &memval);
sl@0	1368	g_value_unset (&memval);
sl@0	1369
sl@0	1370	g_value_init (&memval, DBUS_TYPE_G_OBJECT_PATH);
sl@0	1371	g_value_set_static_boxed (&memval, "/bar/moo/foo/baz");
sl@0	1372	dbus_g_type_struct_set_member (&val, 2, &memval);
sl@0	1373	g_value_unset (&memval);
sl@0	1374
sl@0	1375	g_assert (instance->n_values == 3);
sl@0	1376
sl@0	1377	g_value_init (&memval, G_TYPE_STRING);
sl@0	1378	dbus_g_type_struct_get_member (&val, 0, &memval);
sl@0	1379	g_assert (0 == strcmp (g_value_get_string (&memval), "foo"));
sl@0	1380	g_value_unset (&memval);
sl@0	1381
sl@0	1382	g_value_init (&memval, G_TYPE_UINT);
sl@0	1383	dbus_g_type_struct_get_member (&val, 1, &memval);
sl@0	1384	g_assert (g_value_get_uint (&memval) == 42);
sl@0	1385	g_value_unset (&memval);
sl@0	1386
sl@0	1387	g_value_init (&memval, DBUS_TYPE_G_OBJECT_PATH);
sl@0	1388	dbus_g_type_struct_get_member (&val, 2, &memval);
sl@0	1389	g_assert (0 == strcmp ((gchar*) g_value_get_boxed (&memval),
sl@0	1390	"/bar/moo/foo/baz"));
sl@0	1391	g_value_unset (&memval);
sl@0	1392
sl@0	1393	g_value_unset (&val);
sl@0	1394	}
sl@0	1395
sl@0	1396	type = dbus_g_type_get_struct ("GValueArray", G_TYPE_STRING, G_TYPE_UINT, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
sl@0	1397	g_assert (dbus_g_type_is_struct (type));
sl@0	1398	g_assert (dbus_g_type_get_struct_size (type) == 3);
sl@0	1399	g_assert (dbus_g_type_get_struct_member_type (type, 0) == G_TYPE_STRING);
sl@0	1400	g_assert (dbus_g_type_get_struct_member_type (type, 1) == G_TYPE_UINT);
sl@0	1401	g_assert (dbus_g_type_get_struct_member_type (type, 2) == DBUS_TYPE_G_OBJECT_PATH);
sl@0	1402	{
sl@0	1403	GValueArray *instance;
sl@0	1404	GValue val = {0, };
sl@0	1405
sl@0	1406	instance = dbus_g_type_specialized_construct (type);
sl@0	1407
sl@0	1408	g_assert (instance->n_values == 3);
sl@0	1409
sl@0	1410	g_value_init (&val, type);
sl@0	1411	g_value_set_boxed_take_ownership (&val, instance);
sl@0	1412
sl@0	1413	dbus_g_type_struct_set (&val,
sl@0	1414	0,"foo",
sl@0	1415	1, 42,
sl@0	1416	2, "/bar/moo/foo/baz",
sl@0	1417	G_MAXUINT);
sl@0	1418
sl@0	1419	g_assert (instance->n_values == 3);
sl@0	1420
sl@0	1421	{
sl@0	1422	gchar *string;
sl@0	1423	guint intval;
sl@0	1424	gchar *path;
sl@0	1425
sl@0	1426	dbus_g_type_struct_get (&val,
sl@0	1427	0, &string,
sl@0	1428	1, &intval,
sl@0	1429	2, &path,
sl@0	1430	G_MAXUINT);
sl@0	1431
sl@0	1432	g_assert (0 == strcmp (string, "foo"));
sl@0	1433	g_assert (intval == 42);
sl@0	1434	g_assert (0 == strcmp (path, "/bar/moo/foo/baz"));
sl@0	1435	}
sl@0	1436
sl@0	1437	g_value_unset (&val);
sl@0	1438	}
sl@0	1439
sl@0	1440
sl@0	1441	return TRUE;
sl@0	1442	}
sl@0	1443
sl@0	1444
sl@0	1445
sl@0	1446	#endif /* DBUS_BUILD_TESTS */

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--