MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/ofdbus/dbus-glib/dbus/dbus-gvalue-utils.c
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /* -*- mode: C; c-file-style: "gnu" -*- */

     2 /* dbus-gvalue-utils.c: Non-DBus-specific functions related to GType/GValue 

     3  *

     4  * Copyright (C) 2005 Red Hat, Inc.

     5  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     6  * Licensed under the Academic Free License version 2.1

     7  * 

     8  * This program is free software; you can redistribute it and/or modify

     9  * it under the terms of the GNU General Public License as published by

    10  * the Free Software Foundation; either version 2 of the License, or

    11  * (at your option) any later version.

    12  *

    13  * This program is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16  * GNU General Public License for more details.

    17  * 

    18  * You should have received a copy of the GNU General Public License

    19  * along with this program; if not, write to the Free Software

    20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    21  *

    22  */

    23 

    24 #ifndef __SYMBIAN32__

    25 #include <config.h>

    26 #else

    27 #include "config.h"

    28 #endif //__SYMBIAN32__

    29 #include "dbus/dbus-glib.h"

    30 #include "dbus-gvalue-utils.h"

    31 #include "dbus-gtest.h"

    32 #include <glib.h>

    33 #include <string.h>

    34 #include <gobject/gvaluecollector.h>

    35 

    36 

    37 static guint

    38 fixed_type_get_size (GType type)

    39 {

    40   switch (type)

    41     {

    42     case G_TYPE_CHAR:

    43     case G_TYPE_UCHAR:

    44       return sizeof (gchar);

    45     case G_TYPE_BOOLEAN:

    46       return sizeof (gboolean);

    47     case G_TYPE_LONG:

    48     case G_TYPE_ULONG:

    49       return sizeof (glong);

    50     case G_TYPE_INT:

    51     case G_TYPE_UINT:

    52       return sizeof (gint);

    53     case G_TYPE_INT64:

    54     case G_TYPE_UINT64:

    55       return sizeof (gint64);

    56     case G_TYPE_FLOAT:

    57       return sizeof (gfloat);

    58     case G_TYPE_DOUBLE:

    59       return sizeof (gdouble);

    60     default:

    61       return 0;

    62     }

    63 }

    64 

    65 gboolean

    66 _dbus_g_type_is_fixed (GType type)

    67 {

    68   return fixed_type_get_size (type) > 0;

    69 }

    70 

    71 guint

    72 _dbus_g_type_fixed_get_size (GType type)

    73 {

    74   g_assert (_dbus_g_type_is_fixed (type));

    75   return fixed_type_get_size (type);

    76 }

    77 

    78 gboolean

    79 _dbus_gvalue_store (GValue          *value,

    80 		   gpointer        storage)

    81 {

    82   /* FIXME - can we use the GValue lcopy_value method

    83    * to do this in a cleaner way?

    84    */

    85   switch (g_type_fundamental (G_VALUE_TYPE (value)))

    86     {

    87     case G_TYPE_CHAR:

    88       *((gchar *) storage) = g_value_get_char (value);

    89       return TRUE;

    90     case G_TYPE_UCHAR:

    91       *((guchar *) storage) = g_value_get_uchar (value);

    92       return TRUE;

    93     case G_TYPE_BOOLEAN:

    94       *((gboolean *) storage) = g_value_get_boolean (value);

    95       return TRUE;

    96     case G_TYPE_LONG:

    97       *((glong *) storage) = g_value_get_long (value);

    98       return TRUE;

    99     case G_TYPE_ULONG:

   100       *((gulong *) storage) = g_value_get_ulong (value);

   101       return TRUE;

   102     case G_TYPE_INT:

   103       *((gint *) storage) = g_value_get_int (value);

   104       return TRUE;

   105     case G_TYPE_UINT:

   106       *((guint *) storage) = g_value_get_uint (value);

   107       return TRUE;

   108     case G_TYPE_INT64:

   109       *((gint64 *) storage) = g_value_get_int64 (value);

   110       return TRUE;

   111     case G_TYPE_UINT64:

   112       *((guint64 *) storage) = g_value_get_uint64 (value);

   113       return TRUE;

   114     case G_TYPE_DOUBLE:

   115       *((gdouble *) storage) = g_value_get_double (value);

   116       return TRUE;

   117     case G_TYPE_STRING:

   118       *((gchar **) storage) = (char*) g_value_get_string (value);

   119       return TRUE;

   120     case G_TYPE_OBJECT:

   121       *((gpointer *) storage) = g_value_get_object (value);

   122       return TRUE;

   123     case G_TYPE_BOXED:

   124       *((gpointer *) storage) = g_value_get_boxed (value);

   125       return TRUE;

   126     default:

   127       return FALSE;

   128     }

   129 }

   130 

   131 gboolean

   132 _dbus_gvalue_set_from_pointer (GValue          *value,

   133 			      gconstpointer    storage)

   134 {

   135   /* FIXME - is there a better way to do this? */

   136   switch (g_type_fundamental (G_VALUE_TYPE (value)))

   137     {

   138     case G_TYPE_CHAR:

   139       g_value_set_char (value, *((gchar *) storage));

   140       return TRUE;

   141     case G_TYPE_UCHAR:

   142       g_value_set_uchar (value, *((guchar *) storage));

   143       return TRUE;

   144     case G_TYPE_BOOLEAN:

   145       g_value_set_boolean (value, *((gboolean *) storage));

   146       return TRUE;

   147     case G_TYPE_LONG:

   148       g_value_set_long (value, *((glong *) storage));

   149       return TRUE;

   150     case G_TYPE_ULONG:

   151       g_value_set_ulong (value, *((gulong *) storage));

   152       return TRUE;

   153     case G_TYPE_INT:

   154       g_value_set_int (value, *((gint *) storage));

   155       return TRUE;

   156     case G_TYPE_UINT:

   157       g_value_set_uint (value, *((guint *) storage));

   158       return TRUE;

   159     case G_TYPE_INT64:

   160       g_value_set_int64 (value, *((gint64 *) storage));

   161       return TRUE;

   162     case G_TYPE_UINT64:

   163       g_value_set_uint64 (value, *((guint64 *) storage));

   164       return TRUE;

   165     case G_TYPE_DOUBLE:

   166       g_value_set_double (value, *((gdouble *) storage));

   167       return TRUE;

   168     case G_TYPE_STRING:

   169       g_value_set_string (value, *((gchar **) storage));

   170       return TRUE;

   171     case G_TYPE_OBJECT:

   172       g_value_set_object (value, *((gpointer *) storage));

   173       return TRUE;

   174     case G_TYPE_BOXED:

   175       g_value_set_boxed (value, *((gpointer *) storage));

   176       return TRUE;

   177     default:

   178       return FALSE;

   179     }

   180 }

   181 

   182 gboolean

   183 _dbus_gvalue_take (GValue          *value,

   184 		  GTypeCValue     *cvalue)

   185 {

   186   GType g_type;

   187   GTypeValueTable *value_table;

   188   char *error_msg;

   189 

   190   g_type = G_VALUE_TYPE (value);

   191   value_table = g_type_value_table_peek (g_type);

   192 

   193   error_msg = value_table->collect_value (value, 1, cvalue, G_VALUE_NOCOPY_CONTENTS);

   194   if (error_msg)

   195     {

   196       g_warning ("%s: %s", G_STRLOC, error_msg);

   197       g_free (error_msg);

   198       return FALSE;

   199     }

   200   /* Clear the NOCOPY_CONTENTS flag; we want to take ownership

   201    * of the value.

   202    */

   203   value->data[1].v_uint &= ~(G_VALUE_NOCOPY_CONTENTS);

   204   return TRUE;

   205 }

   206 

   207 gboolean

   208 _dbus_gtype_can_signal_error (GType gtype)

   209 {

   210   switch (gtype)

   211     {

   212     case G_TYPE_BOOLEAN:

   213     case G_TYPE_INT:

   214     case G_TYPE_UINT:

   215     case G_TYPE_STRING:

   216     case G_TYPE_BOXED:

   217     case G_TYPE_OBJECT:

   218       return TRUE;

   219     default:

   220       return FALSE;

   221     }

   222 }

   223 

   224 gboolean

   225 _dbus_gvalue_signals_error (const GValue *value)

   226 {

   227   /* Hardcoded rules for return value semantics for certain

   228    * types.  Perhaps in the future we'd want an annotation

   229    * specifying which return values are errors, but in

   230    * reality people will probably just use boolean and

   231    * boxed, and there the semantics are pretty standard.

   232    */

   233   switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)))

   234     {

   235     case G_TYPE_BOOLEAN:

   236       return (g_value_get_boolean (value) == FALSE);

   237       break;

   238     case G_TYPE_INT:

   239       return (g_value_get_int (value) < 0);

   240       break;

   241     case G_TYPE_UINT:

   242       return (g_value_get_uint (value) == 0);

   243       break;

   244     case G_TYPE_STRING:

   245       return (g_value_get_string (value) == NULL);

   246       break;

   247     case G_TYPE_BOXED:

   248       return (g_value_get_boxed (value) == NULL);

   249       break;

   250     case G_TYPE_OBJECT:

   251       return (g_value_get_object (value) == NULL);

   252       break;

   253     default:

   254       g_assert_not_reached ();

   255     }

   256 }

   257 

   258 

   259 static gboolean

   260 hash_func_from_gtype (GType gtype, GHashFunc *func)

   261 {

   262   switch (gtype)

   263     {

   264     case G_TYPE_CHAR:

   265     case G_TYPE_UCHAR:

   266     case G_TYPE_BOOLEAN:

   267     case G_TYPE_INT:

   268     case G_TYPE_UINT:

   269       *func = NULL;

   270       return TRUE;

   271     case G_TYPE_STRING:

   272       *func = g_str_hash;

   273       return TRUE;

   274     default:

   275       return FALSE;

   276     }

   277 }

   278 

   279 static void

   280 unset_and_free_g_value (gpointer val)

   281 {

   282   GValue *value = val;

   283 

   284   g_value_unset (value);

   285   g_free (value);

   286 }

   287 

   288 static gboolean

   289 hash_free_from_gtype (GType gtype, GDestroyNotify *func)

   290 {

   291   switch (gtype)

   292     {

   293     case G_TYPE_CHAR:

   294     case G_TYPE_UCHAR:

   295     case G_TYPE_BOOLEAN:

   296     case G_TYPE_INT:

   297     case G_TYPE_UINT:

   298       *func = NULL;

   299       return TRUE;

   300     case G_TYPE_DOUBLE:

   301     case G_TYPE_STRING:

   302       *func = g_free;

   303       return TRUE;

   304     default:

   305       if (gtype == G_TYPE_VALUE)

   306 	{

   307 	  *func = unset_and_free_g_value;

   308 	  return TRUE;

   309 	}

   310       else if (gtype == G_TYPE_VALUE_ARRAY)

   311         {

   312           *func = (GDestroyNotify) g_value_array_free;

   313           return TRUE;

   314         }

   315       else if (dbus_g_type_is_collection (gtype))

   316         {

   317           const DBusGTypeSpecializedCollectionVtable* vtable;

   318           vtable = dbus_g_type_collection_peek_vtable (gtype);

   319           if (vtable->base_vtable.simple_free_func)

   320             {

   321               *func = vtable->base_vtable.simple_free_func;

   322               return TRUE;

   323             }

   324         }

   325       else if (dbus_g_type_is_map (gtype))

   326         {

   327           const DBusGTypeSpecializedMapVtable* vtable;

   328           vtable = dbus_g_type_map_peek_vtable (gtype);

   329           if (vtable->base_vtable.simple_free_func)

   330             {

   331               *func = vtable->base_vtable.simple_free_func;

   332               return TRUE;

   333             }

   334         }

   335       else if (dbus_g_type_is_struct (gtype))

   336         {

   337           const DBusGTypeSpecializedStructVtable *vtable;

   338           vtable = dbus_g_type_struct_peek_vtable (gtype);

   339           if (vtable->base_vtable.simple_free_func)

   340             {

   341               *func = vtable->base_vtable.simple_free_func;

   342               return TRUE;

   343             }

   344         }

   345       return FALSE;

   346     }

   347 }

   348 

   349 gboolean

   350 _dbus_gtype_is_valid_hash_key (GType type)

   351 {

   352   GHashFunc func;

   353   return hash_func_from_gtype (type, &func);

   354 }

   355 

   356 gboolean

   357 _dbus_gtype_is_valid_hash_value (GType type)

   358 {

   359   GDestroyNotify func;

   360   return hash_free_from_gtype (type, &func);

   361 }

   362 

   363 GHashFunc

   364 _dbus_g_hash_func_from_gtype (GType gtype)

   365 {

   366   GHashFunc func;

   367   gboolean ret;

   368   ret = hash_func_from_gtype (gtype, &func);

   369   g_assert (ret != FALSE);

   370   return func;

   371 }

   372 

   373 GEqualFunc

   374 _dbus_g_hash_equal_from_gtype (GType gtype)

   375 {

   376   g_assert (_dbus_gtype_is_valid_hash_key (gtype));

   377 

   378   switch (gtype)

   379     {

   380     case G_TYPE_CHAR:

   381     case G_TYPE_UCHAR:

   382     case G_TYPE_BOOLEAN:

   383     case G_TYPE_INT:

   384     case G_TYPE_UINT:

   385       return NULL;

   386     case G_TYPE_STRING:

   387       return g_str_equal;

   388     default:

   389       g_assert_not_reached ();

   390       return NULL;

   391     }

   392 }

   393 

   394 GDestroyNotify

   395 _dbus_g_hash_free_from_gtype (GType gtype)

   396 {

   397   GDestroyNotify func;

   398   gboolean ret;

   399   ret = hash_free_from_gtype (gtype, &func);

   400   g_assert (ret != FALSE);

   401   return func;

   402 }

   403 

   404 static void gvalue_take_ptrarray_value (GValue *value, gpointer instance);

   405 

   406 static void

   407 gvalue_take_hash_value (GValue *value, gpointer instance)

   408 {

   409   switch (g_type_fundamental (G_VALUE_TYPE (value)))

   410     {

   411     case G_TYPE_CHAR:

   412       g_value_set_char (value, (gchar) GPOINTER_TO_INT (instance));

   413       break;

   414     case G_TYPE_UCHAR:

   415       g_value_set_uchar (value, (guchar) GPOINTER_TO_UINT (instance));

   416       break;

   417     case G_TYPE_BOOLEAN:

   418       g_value_set_boolean (value, (gboolean) GPOINTER_TO_UINT (instance));

   419       break;

   420     case G_TYPE_INT:

   421       g_value_set_int (value, GPOINTER_TO_INT (instance));

   422       break;

   423     case G_TYPE_UINT:

   424       g_value_set_uint (value, GPOINTER_TO_UINT (instance));

   425       break;

   426     case G_TYPE_DOUBLE:

   427       g_value_set_double (value, *(gdouble *) instance);

   428       break;

   429     default:

   430       gvalue_take_ptrarray_value (value, instance);

   431       break;

   432     }

   433 }

   434 

   435 static gpointer ptrarray_value_from_gvalue (const GValue *value);

   436 

   437 static gpointer

   438 hash_value_from_gvalue (GValue *value)

   439 {

   440   switch (g_type_fundamental (G_VALUE_TYPE (value)))

   441     {

   442     case G_TYPE_CHAR:

   443       return GINT_TO_POINTER ((int) g_value_get_char (value));

   444       break;

   445     case G_TYPE_UCHAR:

   446       return GUINT_TO_POINTER ((guint) g_value_get_uchar (value));

   447       break;

   448     case G_TYPE_BOOLEAN:

   449       return GUINT_TO_POINTER ((guint) g_value_get_boolean (value));

   450       break;

   451     case G_TYPE_INT:

   452       return GINT_TO_POINTER (g_value_get_int (value));

   453       break;

   454     case G_TYPE_UINT:

   455       return GUINT_TO_POINTER (g_value_get_uint (value));

   456       break;

   457     case G_TYPE_DOUBLE:

   458       {

   459         gdouble *p = (gdouble *) g_malloc0 (sizeof (gdouble));

   460         *p = g_value_get_double (value);

   461         return (gpointer) p;

   462       }

   463       break;

   464     default:

   465       return ptrarray_value_from_gvalue (value);

   466       break;

   467     }

   468 }

   469 

   470 struct DBusGHashTableValueForeachData

   471 {

   472   DBusGTypeSpecializedMapIterator func;

   473   GType key_type;

   474   GType value_type;

   475   gpointer data;

   476 };

   477 

   478 static void

   479 hashtable_foreach_with_values (gpointer key, gpointer value, gpointer user_data)

   480 {

   481   GValue key_val = {0, };

   482   GValue value_val = {0, };

   483   struct DBusGHashTableValueForeachData *data = user_data;

   484   

   485   g_value_init (&key_val, data->key_type);

   486   g_value_init (&value_val, data->value_type);

   487   gvalue_take_hash_value (&key_val, key);

   488   gvalue_take_hash_value (&value_val, value);

   489 

   490   data->func (&key_val, &value_val, data->data);

   491 }

   492 

   493 

   494 static void

   495 hashtable_iterator (GType                           hash_type,

   496 		    gpointer                        instance,

   497 		    DBusGTypeSpecializedMapIterator iterator,

   498 		    gpointer                        user_data)

   499 {

   500   struct DBusGHashTableValueForeachData data;

   501   GType key_gtype;

   502   GType value_gtype;

   503 

   504   key_gtype = dbus_g_type_get_map_key_specialization (hash_type);

   505   value_gtype = dbus_g_type_get_map_value_specialization (hash_type);

   506 

   507   data.func = iterator;

   508   data.key_type = key_gtype;

   509   data.value_type = value_gtype;

   510   data.data = user_data;

   511 

   512   g_hash_table_foreach (instance, hashtable_foreach_with_values, &data);

   513 }

   514 

   515 void

   516 _dbus_g_hash_table_insert_steal_values (GHashTable *table,

   517 				       GValue     *key_val,

   518 				       GValue     *value_val)

   519 {

   520   gpointer key, val;

   521   

   522   key = hash_value_from_gvalue (key_val);

   523   val = hash_value_from_gvalue (value_val);

   524 

   525   g_hash_table_insert (table, key, val);

   526 }

   527 

   528 static void

   529 hashtable_append (DBusGTypeSpecializedAppendContext *ctx,

   530 		  GValue                            *key,

   531 		  GValue                            *val)

   532 {

   533   GHashTable *table;

   534 

   535   table = g_value_get_boxed (ctx->val);

   536   _dbus_g_hash_table_insert_steal_values (table, key, val);

   537 }

   538 

   539 static gpointer

   540 hashtable_constructor (GType type)

   541 {

   542   GHashTable *ret;

   543   GType key_gtype;

   544   GType value_gtype;

   545 

   546   key_gtype = dbus_g_type_get_map_key_specialization (type);

   547   value_gtype = dbus_g_type_get_map_value_specialization (type);

   548 

   549   ret = g_hash_table_new_full (_dbus_g_hash_func_from_gtype (key_gtype),

   550 			       _dbus_g_hash_equal_from_gtype (key_gtype),

   551 			       _dbus_g_hash_free_from_gtype (key_gtype),

   552 			       _dbus_g_hash_free_from_gtype (value_gtype));

   553   return ret;

   554 }

   555 

   556 static void

   557 hashtable_insert_values (GHashTable       *table,

   558 			 const GValue     *key_val,

   559 			 const GValue     *value_val)

   560 {

   561   GValue key_copy = {0, };

   562   GValue value_copy = {0, };

   563 

   564   g_value_init (&key_copy, G_VALUE_TYPE (key_val));

   565   g_value_copy (key_val, &key_copy);

   566   g_value_init (&value_copy, G_VALUE_TYPE (value_val));

   567   g_value_copy (value_val, &value_copy);

   568   

   569   _dbus_g_hash_table_insert_steal_values (table, &key_copy, &value_copy);

   570 }

   571 

   572 static void

   573 hashtable_foreach_copy (const GValue *key, const GValue *val, gpointer data)

   574 {

   575   hashtable_insert_values ((GHashTable *) data, key, val);

   576 }

   577 

   578 static gpointer

   579 hashtable_copy (GType type, gpointer src)

   580 {

   581   GHashTable *ghash;

   582   GHashTable *ret;

   583   GValue hashval = {0,};

   584 

   585   ghash = src;

   586 

   587   ret = hashtable_constructor (type);

   588 

   589   g_value_init (&hashval, type);

   590   g_value_set_static_boxed (&hashval, ghash); 

   591   dbus_g_type_map_value_iterate (&hashval, hashtable_foreach_copy, ret);

   592   return ret;

   593 }

   594 

   595 static void

   596 hashtable_simple_free (gpointer val)

   597 {

   598   g_hash_table_destroy (val);

   599 }

   600 

   601 static gpointer

   602 valuearray_constructor (GType type)

   603 {

   604   GValueArray *ret;

   605   guint size = dbus_g_type_get_struct_size (type);

   606   guint i;

   607   ret = g_value_array_new (size);

   608   for (i=0; i < size; i++)

   609     {

   610       GValue val = {0,};

   611       g_value_init (&val, dbus_g_type_get_struct_member_type (type, i));

   612       g_value_array_append(ret, &val);

   613     }

   614   return (gpointer)ret;

   615 }

   616 

   617 static gpointer

   618 valuearray_copy (GType type, gpointer src)

   619 {

   620   return g_value_array_copy ((GValueArray*) src);

   621 }

   622 

   623 static void

   624 valuearray_simple_free (gpointer val)

   625 {

   626   g_value_array_free (val);

   627 }

   628 

   629 static gboolean

   630 valuearray_get_member (GType type, gpointer instance,

   631                        guint member, GValue *ret)

   632 {

   633   GValueArray *va = (GValueArray*) instance;

   634   const GValue *val;

   635   if (member < dbus_g_type_get_struct_size (type))

   636     {

   637       val = g_value_array_get_nth (va, member);

   638       g_value_copy (val, ret);

   639       return TRUE;

   640     }

   641   else

   642     return FALSE;

   643 }

   644 

   645 static gboolean

   646 valuearray_set_member (GType type, gpointer instance,

   647                        guint member, const GValue *member_type)

   648 {

   649   GValueArray *va = (GValueArray*) instance;

   650   GValue *vp;

   651   if (member < dbus_g_type_get_struct_size (type))

   652     {

   653       vp = g_value_array_get_nth (va, member);

   654       g_value_copy (member_type, vp);

   655       return TRUE;

   656     }

   657   else

   658     return FALSE;

   659 }

   660 

   661 

   662 static gpointer

   663 array_constructor (GType type)

   664 {

   665   GArray *array;

   666   guint elt_size;

   667   GType elt_type;

   668   gboolean zero_terminated;

   669   gboolean clear;

   670 

   671   elt_type = dbus_g_type_get_collection_specialization (type);

   672   g_assert (elt_type != G_TYPE_INVALID);

   673 

   674   elt_size = _dbus_g_type_fixed_get_size (elt_type);

   675 

   676   /* These are "safe" defaults */ 

   677   zero_terminated = TRUE; /* ((struct _DBusGRealArray*) garray)->zero_terminated; */

   678   clear = TRUE; /* ((struct _DBusGRealArray*) garray)->clear; */

   679 

   680   array = g_array_new (zero_terminated, clear, elt_size);

   681   return array;

   682 }

   683 

   684 static gpointer

   685 array_copy (GType type, gpointer src)

   686 {

   687   GArray *garray;

   688   GArray *new;

   689 

   690   garray = src;

   691 

   692   new = array_constructor (type);

   693   g_array_append_vals (new, garray->data, garray->len);

   694 

   695   return new;

   696 }

   697 

   698 static void

   699 array_simple_free (gpointer val)

   700 {

   701   GArray *array;

   702   array = val;

   703   g_array_free (array, TRUE);

   704 }

   705 

   706 static gboolean

   707 array_fixed_accessor (GType type, gpointer instance, gpointer *values, guint *len)

   708 {

   709   GType elt_type;

   710   GArray *array = instance;

   711 

   712   elt_type = dbus_g_type_get_collection_specialization (type);

   713   if (!_dbus_g_type_is_fixed (elt_type))

   714     return FALSE;

   715 

   716   *values = array->data;

   717   *len = array->len;

   718   return TRUE;

   719 }

   720 

   721 static gpointer

   722 ptrarray_constructor (GType type)

   723 {

   724   /* Later we should determine a destructor, need g_ptr_array_destroy */

   725   return g_ptr_array_new ();

   726 }

   727 

   728 static void

   729 gvalue_take_ptrarray_value (GValue *value, gpointer instance)

   730 {

   731   switch (g_type_fundamental (G_VALUE_TYPE (value)))

   732     {

   733     case G_TYPE_STRING:

   734       g_value_take_string (value, instance);

   735       break;

   736     case G_TYPE_BOXED:

   737       g_value_take_boxed (value, instance);

   738       break;

   739     case G_TYPE_OBJECT:

   740       g_value_take_object (value, instance);

   741       break;

   742     default:

   743       g_assert_not_reached ();

   744       break;

   745     }

   746 }

   747 

   748 static gpointer

   749 ptrarray_value_from_gvalue (const GValue *value)

   750 {

   751   GValue tmp = {0, };

   752 

   753   /* if the NOCOPY flag is set, then value was created via set_static and hence

   754    * is not owned by us. in order to preserve the "take" semantics that the API

   755    * has in general (which avoids copying in the common case), we must copy any

   756    * static values so that we can indiscriminately free the entire collection

   757    * later. */

   758   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)

   759     {

   760       g_value_init (&tmp, G_VALUE_TYPE (value));

   761       g_value_copy (value, &tmp);

   762       value = &tmp;

   763     }

   764 

   765   switch (g_type_fundamental (G_VALUE_TYPE (value)))

   766     {

   767     case G_TYPE_STRING:

   768       return (gpointer) g_value_get_string (value);

   769       break;

   770     case G_TYPE_BOXED:

   771       return g_value_get_boxed (value);

   772       break;

   773     case G_TYPE_OBJECT:

   774       return g_value_get_object (value);

   775       break;

   776     default:

   777       g_assert_not_reached ();

   778       return NULL;

   779     }

   780 }

   781 

   782 static void

   783 ptrarray_iterator (GType                                   ptrarray_type,

   784 		   gpointer                                instance,

   785 		   DBusGTypeSpecializedCollectionIterator  iterator,

   786 		   gpointer                                user_data)

   787 {

   788   GPtrArray *ptrarray;

   789   GType elt_gtype;

   790   guint i;

   791 

   792   ptrarray = instance;

   793 

   794   elt_gtype = dbus_g_type_get_collection_specialization (ptrarray_type);

   795 

   796   for (i = 0; i < ptrarray->len; i++)

   797     {

   798       GValue val = {0, };

   799       g_value_init (&val, elt_gtype);

   800       gvalue_take_ptrarray_value (&val, g_ptr_array_index (ptrarray, i));

   801       iterator (&val, user_data);

   802     }

   803 }

   804 

   805 static void

   806 ptrarray_copy_elt (const GValue *val, gpointer user_data)

   807 {

   808   GPtrArray *dest = user_data;

   809   GValue val_copy = {0, };

   810 

   811   g_value_init (&val_copy, G_VALUE_TYPE (val));

   812   g_value_copy (val, &val_copy);

   813 

   814   g_ptr_array_add (dest, ptrarray_value_from_gvalue (&val_copy));

   815 }

   816 

   817 static gpointer

   818 ptrarray_copy (GType type, gpointer src)

   819 {

   820   GPtrArray *new;

   821   GValue array_val = {0, };

   822 

   823   g_value_init (&array_val, type);

   824   g_value_set_static_boxed (&array_val, src);

   825 

   826   new = ptrarray_constructor (type);

   827   dbus_g_type_collection_value_iterate (&array_val, ptrarray_copy_elt, new);

   828 

   829   return new;

   830 }

   831 

   832 static void

   833 ptrarray_append (DBusGTypeSpecializedAppendContext *ctx, GValue *value)

   834 {

   835   GPtrArray *array;

   836 

   837   array = g_value_get_boxed (ctx->val);

   838 

   839   g_ptr_array_add (array, ptrarray_value_from_gvalue (value));

   840 }

   841 

   842 static void

   843 ptrarray_free (GType type, gpointer val)

   844 {

   845   GPtrArray *array;

   846   GValue elt_val = {0, };

   847   GType elt_gtype;

   848   unsigned int i;

   849 

   850   array = val;

   851 

   852   elt_gtype = dbus_g_type_get_collection_specialization (type);

   853 

   854   for (i = 0; i < array->len; i++)

   855     {

   856       g_value_init (&elt_val, elt_gtype);

   857       gvalue_take_ptrarray_value (&elt_val, g_ptr_array_index (array, i));

   858       g_value_unset (&elt_val);

   859     }

   860 

   861   g_ptr_array_free (array, TRUE);

   862 }

   863 

   864 static gpointer

   865 slist_constructor (GType type)

   866 {

   867   return NULL;

   868 }

   869 

   870 static void

   871 slist_iterator (GType                                   list_type,

   872 		gpointer                                instance,

   873 		DBusGTypeSpecializedCollectionIterator  iterator,

   874 		gpointer                                user_data)

   875 {

   876   GSList *slist;

   877   GType elt_gtype;

   878 

   879   slist = instance;

   880 

   881   elt_gtype = dbus_g_type_get_collection_specialization (list_type);

   882 

   883   for (slist = instance; slist != NULL; slist = slist->next)

   884     {

   885       GValue val = {0, };

   886       g_value_init (&val, elt_gtype);

   887       gvalue_take_ptrarray_value (&val, slist->data);

   888       iterator (&val, user_data);

   889     }

   890 }

   891 

   892 static void

   893 slist_copy_elt (const GValue *val, gpointer user_data)

   894 {

   895   GSList **dest = user_data;

   896   GValue val_copy = {0, };

   897 

   898   g_value_init (&val_copy, G_VALUE_TYPE (val));

   899   g_value_copy (val, &val_copy);

   900 

   901   *dest = g_slist_append (*dest, ptrarray_value_from_gvalue (&val_copy));

   902 }

   903 

   904 static gpointer

   905 slist_copy (GType type, gpointer src)

   906 {

   907   GSList *new;

   908   GValue slist_val = {0, };

   909 

   910   g_value_init (&slist_val, type);

   911   g_value_set_static_boxed (&slist_val, src);

   912 

   913   new = slist_constructor (type);

   914   dbus_g_type_collection_value_iterate (&slist_val, slist_copy_elt, &new);

   915 

   916   return new;

   917 }

   918 

   919 static void

   920 slist_append (DBusGTypeSpecializedAppendContext *ctx, GValue *value)

   921 {

   922   GSList *list;

   923 

   924   list = g_value_get_boxed (ctx->val);

   925   list = g_slist_prepend (list, ptrarray_value_from_gvalue (value));

   926   g_value_set_static_boxed (ctx->val, list);

   927 }

   928 

   929 static void

   930 slist_end_append (DBusGTypeSpecializedAppendContext *ctx)

   931 {

   932   GSList *list;

   933 

   934   /* if you append multiple times to the slist, this will reverse the existing

   935    * elements... we need an init_append function */

   936   list = g_value_get_boxed (ctx->val);

   937   list = g_slist_reverse (list);

   938 

   939   g_value_take_boxed (ctx->val, list);

   940 }

   941 

   942 static void

   943 slist_free (GType type, gpointer val)

   944 {

   945   GSList *list;

   946   GType elt_gtype;

   947   list = val;

   948 

   949   elt_gtype = dbus_g_type_get_collection_specialization (type);

   950 

   951   while (list != NULL)

   952     {

   953       GValue elt_val = {0, };

   954       g_value_init (&elt_val, elt_gtype);

   955       gvalue_take_ptrarray_value (&elt_val, list->data);

   956       g_value_unset (&elt_val);

   957       list = g_slist_next(list);

   958     }

   959   list=val;

   960   g_slist_free (list);

   961 }

   962 

   963 void

   964 _dbus_g_type_specialized_builtins_init (void)

   965 {

   966   /* types with a simple_free function can be freed at run-time without

   967    * the destroy function needing to know the type, so they can be

   968    * stored in hash tables */

   969 

   970   static const DBusGTypeSpecializedCollectionVtable array_vtable = {

   971     {

   972       array_constructor,

   973       NULL,

   974       array_copy,

   975       array_simple_free,

   976       NULL,

   977       NULL,

   978     },

   979     array_fixed_accessor,

   980     NULL,

   981     NULL,

   982     NULL

   983   };

   984 

   985 

   986   static const DBusGTypeSpecializedCollectionVtable ptrarray_vtable = {

   987     {

   988       ptrarray_constructor,

   989       ptrarray_free,

   990       ptrarray_copy,

   991       NULL,

   992       NULL,

   993       NULL,

   994     },

   995     NULL,

   996     ptrarray_iterator,

   997     ptrarray_append,

   998     NULL,

   999   };

  1000 

  1001 

  1002   static const DBusGTypeSpecializedCollectionVtable slist_vtable = {

  1003     {

  1004       slist_constructor,

  1005       slist_free,

  1006       slist_copy,

  1007       NULL,

  1008       NULL,

  1009       NULL,

  1010     },

  1011     NULL,

  1012     slist_iterator,

  1013     slist_append,

  1014     slist_end_append,

  1015   };

  1016 

  1017   static const DBusGTypeSpecializedMapVtable hashtable_vtable = {

  1018     {

  1019       hashtable_constructor,

  1020       NULL,

  1021       hashtable_copy,

  1022       hashtable_simple_free,

  1023       NULL,

  1024       NULL

  1025     },

  1026     hashtable_iterator,

  1027     hashtable_append

  1028   };

  1029 

  1030   static const DBusGTypeSpecializedStructVtable valuearray_vtable = {

  1031     {

  1032       valuearray_constructor,

  1033       NULL,

  1034       valuearray_copy,

  1035       valuearray_simple_free,

  1036       NULL,

  1037       NULL

  1038     },

  1039     valuearray_get_member,

  1040     valuearray_set_member

  1041   };

  1042 

  1043   dbus_g_type_register_collection ("GSList", &slist_vtable, 0);

  1044   dbus_g_type_register_collection ("GArray", &array_vtable, 0);

  1045   dbus_g_type_register_collection ("GPtrArray", &ptrarray_vtable, 0);

  1046   dbus_g_type_register_map ("GHashTable", &hashtable_vtable, 0);

  1047   dbus_g_type_register_struct ("GValueArray", &valuearray_vtable, 0);

  1048 }

  1049 

  1050 #ifdef DBUS_BUILD_TESTS

  1051 

  1052 typedef struct

  1053 {

  1054   gboolean seen_foo;

  1055   gboolean seen_baz;

  1056 } TestSpecializedHashData;

  1057 

  1058 static void

  1059 test_specialized_hash (const GValue *key, const GValue *val, gpointer user_data)

  1060 {

  1061   TestSpecializedHashData *data = user_data;

  1062 

  1063   g_assert (G_VALUE_HOLDS_STRING (key));

  1064   g_assert (G_VALUE_HOLDS_STRING (val));

  1065 

  1066   if (!strcmp (g_value_get_string (key), "foo"))

  1067     {

  1068       data->seen_foo = TRUE;

  1069       g_assert (!strcmp (g_value_get_string (val), "bar"));

  1070     }

  1071   else if (!strcmp (g_value_get_string (key), "baz"))

  1072     {

  1073       data->seen_baz = TRUE;

  1074       g_assert (!strcmp (g_value_get_string (val), "moo"));

  1075     }

  1076   else

  1077     {

  1078       g_assert_not_reached ();

  1079     }

  1080 }

  1081 

  1082 static void

  1083 test_specialized_hash_2 (const GValue *key, const GValue *val, gpointer user_data)

  1084 {

  1085   TestSpecializedHashData *data = user_data;

  1086   const GValue *realval;

  1087 

  1088   g_assert (G_VALUE_HOLDS_STRING (key));

  1089   g_assert (G_VALUE_TYPE (val) == G_TYPE_VALUE);

  1090 

  1091   realval = g_value_get_boxed (val);

  1092 

  1093   if (!strcmp (g_value_get_string (key), "foo"))

  1094     {

  1095       data->seen_foo = TRUE;

  1096       g_assert (G_VALUE_HOLDS_UINT (realval));

  1097       g_assert (g_value_get_uint (realval) == 20);

  1098     }

  1099   else if (!strcmp (g_value_get_string (key), "baz"))

  1100     {

  1101       data->seen_baz = TRUE;

  1102       g_assert (G_VALUE_HOLDS_STRING (realval));

  1103       g_assert (!strcmp ("bar", g_value_get_string (realval)));

  1104     }

  1105   else

  1106     {

  1107       g_assert_not_reached ();

  1108     }

  1109 }

  1110 

  1111  	#ifdef __SYMBIAN32__

  1112 	EXPORT_C

  1113 	#endif

  1114 gboolean

  1115 _dbus_gvalue_utils_test (const char *datadir)

  1116 {

  1117   GType type;

  1118 

  1119   dbus_g_type_specialized_init ();

  1120  _dbus_g_type_specialized_builtins_init ();

  1121 

  1122   type = dbus_g_type_get_collection ("GArray", G_TYPE_UINT);

  1123   g_assert (dbus_g_type_is_collection (type));

  1124   g_assert (dbus_g_type_get_collection_specialization (type) == G_TYPE_UINT);

  1125   {

  1126     GArray *instance;

  1127 

  1128     instance = dbus_g_type_specialized_construct (type);

  1129 

  1130     g_assert (instance->len == 0);

  1131 

  1132     g_array_free (instance, TRUE);

  1133   }

  1134 

  1135   type = dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING);

  1136   g_assert (dbus_g_type_is_map (type));

  1137   g_assert (dbus_g_type_get_map_key_specialization (type) == G_TYPE_STRING);

  1138   g_assert (dbus_g_type_get_map_value_specialization (type) == G_TYPE_STRING);

  1139   {

  1140     GHashTable *instance;

  1141     GValue val = { 0, };

  1142     TestSpecializedHashData hashdata;

  1143 

  1144     instance = dbus_g_type_specialized_construct (type);

  1145 

  1146     g_assert (g_hash_table_size (instance) == 0);

  1147     g_hash_table_insert (instance, g_strdup ("foo"), g_strdup ("bar"));

  1148     g_hash_table_insert (instance, g_strdup ("baz"), g_strdup ("moo"));

  1149     g_assert (g_hash_table_size (instance) == 2);

  1150 

  1151     g_value_init (&val, type);

  1152     g_value_set_boxed_take_ownership (&val, instance);

  1153     hashdata.seen_foo = FALSE;

  1154     hashdata.seen_baz = FALSE;

  1155     dbus_g_type_map_value_iterate (&val,

  1156 				   test_specialized_hash, 

  1157 				   &hashdata);

  1158     

  1159     g_assert (hashdata.seen_foo);

  1160     g_assert (hashdata.seen_baz);

  1161 

  1162     g_value_unset (&val);

  1163   }

  1164 

  1165   type = dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE);

  1166   g_assert (dbus_g_type_is_map (type));

  1167   g_assert (dbus_g_type_get_map_key_specialization (type) == G_TYPE_STRING);

  1168   g_assert (dbus_g_type_get_map_value_specialization (type) == G_TYPE_VALUE);

  1169   {

  1170     GHashTable *instance;

  1171     GValue val = { 0, };

  1172     TestSpecializedHashData hashdata;

  1173     DBusGTypeSpecializedAppendContext ctx;

  1174     GValue *eltval;

  1175 

  1176     instance = dbus_g_type_specialized_construct (type);

  1177     g_value_init (&val, type);

  1178     g_value_set_boxed_take_ownership (&val, instance);

  1179 

  1180     dbus_g_type_specialized_init_append (&val, &ctx);

  1181 

  1182     {

  1183       GValue keyval = { 0, };

  1184       GValue valval = { 0, };

  1185       g_value_init (&keyval, G_TYPE_STRING);

  1186       g_value_set_string (&keyval, "foo"); 

  1187 

  1188       g_value_init (&valval, G_TYPE_VALUE);

  1189       eltval = g_new0 (GValue, 1);

  1190       g_value_init (eltval, G_TYPE_UINT);

  1191       g_value_set_uint (eltval, 20);

  1192       g_value_set_boxed_take_ownership (&valval, eltval);

  1193       dbus_g_type_specialized_map_append (&ctx, &keyval, &valval);

  1194     }

  1195 

  1196     {

  1197       GValue keyval = { 0, };

  1198       GValue valval = { 0, };

  1199       g_value_init (&keyval, G_TYPE_STRING);

  1200       g_value_set_string (&keyval, "baz"); 

  1201       g_value_init (&valval, G_TYPE_VALUE);

  1202       eltval = g_new0 (GValue, 1);

  1203       g_value_init (eltval, G_TYPE_STRING);

  1204       g_value_set_string (eltval, "bar");

  1205       g_value_set_boxed_take_ownership (&valval, eltval);

  1206       dbus_g_type_specialized_map_append (&ctx, &keyval, &valval);

  1207     }

  1208 

  1209     hashdata.seen_foo = FALSE;

  1210     hashdata.seen_baz = FALSE;

  1211     dbus_g_type_map_value_iterate (&val,

  1212 				   test_specialized_hash_2, 

  1213 				   &hashdata);

  1214     

  1215     g_assert (hashdata.seen_foo);

  1216     g_assert (hashdata.seen_baz);

  1217 

  1218     g_value_unset (&val);

  1219   }

  1220 

  1221   type = dbus_g_type_get_collection ("GSList", G_TYPE_OBJECT);

  1222   g_assert (dbus_g_type_is_collection (type));

  1223   g_assert (dbus_g_type_get_collection_specialization (type) == G_TYPE_OBJECT);

  1224   {

  1225     GSList *instance, *tmp, *copy;

  1226     GValue val = {0, };

  1227     GValue copyval = {0, };

  1228     DBusGTypeSpecializedAppendContext ctx;

  1229     GObject *objects[3];

  1230     int i;

  1231 

  1232     instance = dbus_g_type_specialized_construct (type);

  1233     g_assert (instance == NULL);

  1234 

  1235     g_value_init (&val, type);

  1236     g_value_take_boxed (&val, instance);

  1237 

  1238     dbus_g_type_specialized_init_append (&val, &ctx);

  1239 

  1240     for (i = 0; i < 3; i++)

  1241       {

  1242         GValue eltval = { 0, };

  1243         GObject *obj = g_object_new (G_TYPE_OBJECT, NULL);

  1244 

  1245         g_assert (obj != NULL);

  1246         objects[i] = obj;

  1247         g_object_add_weak_pointer (obj, (gpointer) (objects + i));

  1248 

  1249         g_value_init (&eltval, G_TYPE_OBJECT);

  1250         g_value_take_object (&eltval, obj);

  1251         dbus_g_type_specialized_collection_append (&ctx, &eltval);

  1252       }

  1253 

  1254     dbus_g_type_specialized_collection_end_append (&ctx);

  1255 

  1256     instance = g_value_get_boxed (&val);

  1257     g_assert (g_slist_length (instance) == 3);

  1258 

  1259     for (tmp = instance; tmp; tmp = tmp->next)

  1260       {

  1261         GObject *obj = tmp->data;

  1262         g_assert (G_IS_OBJECT (obj));

  1263         g_assert (obj->ref_count == 1);

  1264       }

  1265 

  1266     g_value_init (&copyval, type);

  1267     g_value_copy (&val, &copyval);

  1268 

  1269     copy = g_value_get_boxed (&copyval);

  1270     g_assert (g_slist_length (copy) == 3);

  1271 

  1272     for (tmp = copy; tmp; tmp = tmp->next)

  1273       {

  1274         GObject *obj = tmp->data;

  1275         g_assert (G_IS_OBJECT (obj));

  1276         g_assert (obj->ref_count == 2);

  1277       }

  1278 

  1279     g_value_unset (&copyval);

  1280 

  1281     for (i = 0; i < 3; i++)

  1282       {

  1283         g_assert (objects[i] != NULL);

  1284       }

  1285 

  1286     for (tmp = instance; tmp; tmp = tmp->next)

  1287       {

  1288         GObject *obj = tmp->data;

  1289         g_assert (G_IS_OBJECT (obj));

  1290         g_assert (obj->ref_count == 1);

  1291       }

  1292 

  1293     g_value_unset (&val);

  1294 

  1295     for (i = 0; i < 3; i++)

  1296       {

  1297         g_assert (objects[i] == NULL);

  1298       }

  1299   }

  1300 

  1301   type = dbus_g_type_get_collection ("GPtrArray", G_TYPE_STRING);

  1302   g_assert (dbus_g_type_is_collection (type));

  1303   g_assert (dbus_g_type_get_collection_specialization (type) == G_TYPE_STRING);

  1304   {

  1305     GPtrArray *instance;

  1306     DBusGTypeSpecializedAppendContext ctx;

  1307     GValue val = {0, };

  1308     GValue eltval = {0, };

  1309 

  1310     instance = dbus_g_type_specialized_construct (type);

  1311 

  1312     g_assert (instance->len == 0);

  1313 

  1314     g_value_init (&val, type);

  1315     g_value_set_boxed_take_ownership (&val, instance);

  1316 

  1317     dbus_g_type_specialized_init_append (&val, &ctx);

  1318 

  1319     g_value_init (&eltval, G_TYPE_STRING);

  1320     g_value_set_static_string (&eltval, "foo");

  1321     dbus_g_type_specialized_collection_append (&ctx, &eltval);

  1322 

  1323     g_value_reset (&eltval);

  1324     g_value_set_static_string (&eltval, "bar");

  1325     dbus_g_type_specialized_collection_append (&ctx, &eltval);

  1326 

  1327     g_value_reset (&eltval);

  1328     g_value_set_static_string (&eltval, "baz");

  1329     dbus_g_type_specialized_collection_append (&ctx, &eltval);

  1330 

  1331     dbus_g_type_specialized_collection_end_append (&ctx);

  1332 

  1333     g_assert (instance->len == 3);

  1334 

  1335     g_assert (!strcmp ("foo", g_ptr_array_index (instance, 0)));

  1336     g_assert (!strcmp ("bar", g_ptr_array_index (instance, 1)));

  1337     g_assert (!strcmp ("baz", g_ptr_array_index (instance, 2)));

  1338 

  1339     g_value_unset (&val);

  1340   }

  1341 

  1342   type = dbus_g_type_get_struct ("GValueArray", G_TYPE_STRING, G_TYPE_UINT, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);

  1343   g_assert (dbus_g_type_is_struct (type));

  1344   g_assert (dbus_g_type_get_struct_size (type) == 3);

  1345   g_assert (dbus_g_type_get_struct_member_type (type, 0) == G_TYPE_STRING);

  1346   g_assert (dbus_g_type_get_struct_member_type (type, 1) == G_TYPE_UINT);

  1347   g_assert (dbus_g_type_get_struct_member_type (type, 2) == DBUS_TYPE_G_OBJECT_PATH);

  1348   {

  1349     GValueArray *instance;

  1350     GValue val = {0, };

  1351     GValue memval = {0, };

  1352 

  1353     instance = dbus_g_type_specialized_construct (type);

  1354 

  1355     g_assert (instance->n_values == 3);

  1356 

  1357     g_value_init (&val, type);

  1358     g_value_set_boxed_take_ownership (&val, instance);

  1359 

  1360     g_value_init (&memval, G_TYPE_STRING);

  1361     g_value_set_static_string (&memval, "foo");

  1362     dbus_g_type_struct_set_member (&val, 0, &memval);

  1363     g_value_unset (&memval);

  1364 

  1365     g_value_init (&memval, G_TYPE_UINT);

  1366     g_value_set_uint (&memval, 42);

  1367     dbus_g_type_struct_set_member (&val, 1, &memval);

  1368     g_value_unset (&memval);

  1369 

  1370     g_value_init (&memval, DBUS_TYPE_G_OBJECT_PATH);

  1371     g_value_set_static_boxed (&memval, "/bar/moo/foo/baz");

  1372     dbus_g_type_struct_set_member (&val, 2, &memval);

  1373     g_value_unset (&memval);

  1374 

  1375     g_assert (instance->n_values == 3);

  1376 

  1377     g_value_init (&memval, G_TYPE_STRING);

  1378     dbus_g_type_struct_get_member (&val, 0, &memval);

  1379     g_assert (0 == strcmp (g_value_get_string (&memval), "foo"));

  1380     g_value_unset (&memval);

  1381 

  1382     g_value_init (&memval, G_TYPE_UINT);

  1383     dbus_g_type_struct_get_member (&val, 1, &memval);

  1384     g_assert (g_value_get_uint (&memval) == 42);

  1385     g_value_unset (&memval);

  1386 

  1387     g_value_init (&memval, DBUS_TYPE_G_OBJECT_PATH);

  1388     dbus_g_type_struct_get_member (&val, 2, &memval);

  1389     g_assert (0 == strcmp ((gchar*) g_value_get_boxed (&memval),

  1390                            "/bar/moo/foo/baz"));

  1391     g_value_unset (&memval);

  1392 

  1393     g_value_unset (&val);

  1394   }

  1395 

  1396   type = dbus_g_type_get_struct ("GValueArray", G_TYPE_STRING, G_TYPE_UINT, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);

  1397   g_assert (dbus_g_type_is_struct (type));

  1398   g_assert (dbus_g_type_get_struct_size (type) == 3);

  1399   g_assert (dbus_g_type_get_struct_member_type (type, 0) == G_TYPE_STRING);

  1400   g_assert (dbus_g_type_get_struct_member_type (type, 1) == G_TYPE_UINT);

  1401   g_assert (dbus_g_type_get_struct_member_type (type, 2) == DBUS_TYPE_G_OBJECT_PATH);

  1402   {

  1403     GValueArray *instance;

  1404     GValue val = {0, };

  1405 

  1406     instance = dbus_g_type_specialized_construct (type);

  1407 

  1408     g_assert (instance->n_values == 3);

  1409 

  1410     g_value_init (&val, type);

  1411     g_value_set_boxed_take_ownership (&val, instance);

  1412 

  1413     dbus_g_type_struct_set (&val,

  1414                             0,"foo",

  1415                             1, 42,

  1416                             2, "/bar/moo/foo/baz",

  1417                             G_MAXUINT);

  1418 

  1419     g_assert (instance->n_values == 3);

  1420 

  1421     {

  1422       gchar *string;

  1423       guint intval;

  1424       gchar *path;

  1425 

  1426       dbus_g_type_struct_get (&val,

  1427                               0, &string,

  1428                               1, &intval,

  1429                               2, &path,

  1430                               G_MAXUINT);

  1431 

  1432       g_assert (0 == strcmp (string, "foo"));

  1433       g_assert (intval == 42);

  1434       g_assert (0 == strcmp (path, "/bar/moo/foo/baz"));

  1435     }

  1436 

  1437     g_value_unset (&val);

  1438   }

  1439 

  1440 

  1441   return TRUE;

  1442 }

  1443 

  1444 

  1445 

  1446 #endif /* DBUS_BUILD_TESTS */
Symaptic