gobject/gvalue.c

   1 /* GObject - GLib Type, Object, Parameter and Signal Library
   2  * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General
  15  * Public License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * FIXME: MT-safety
  22  */
  23
  24 #include <string.h>
  25
  26 #include "gvalue.h"
  27 #include "gvaluecollector.h"
  28 #include "gbsearcharray.h"
  29
  30
  31 /* --- typedefs & structures --- */
  32 typedef struct {
  33   GType src_type;
  34   GType dest_type;
  35   GValueTransform func;
  36 } TransformEntry;
  37
  38
  39 /* --- prototypes --- */
  40 static gint     transform_entries_cmp   (gconstpointer bsearch_node1,
  41                                          gconstpointer bsearch_node2);
  42
  43
  44 /* --- variables --- */
  45 static GBSearchArray *transform_array = NULL;
  46 static GBSearchConfig transform_bconfig = {
  47   sizeof (TransformEntry),
  48   transform_entries_cmp,
  49   0,
  50 };
  51
  52
  53 /* --- functions --- */
  54 void
  55 g_value_c_init (void)   /* sync with gtype.c */
  56 {
  57   transform_array = g_bsearch_array_create (&transform_bconfig);
  58 }
  59
  60 static inline void              /* keep this function in sync with gvaluecollector.h and gboxed.c */
  61 value_meminit (GValue *value,
  62                GType   value_type)
  63 {
  64   value->g_type = value_type;
  65   memset (value->data, 0, sizeof (value->data));
  66 }
  67
  68 GValue*
  69 g_value_init (GValue *value,
  70               GType   g_type)
  71 {
  72   /* g_return_val_if_fail (G_TYPE_IS_VALUE (g_type), NULL);     be more elaborate below */
  73   g_return_val_if_fail (value != NULL, NULL);
  74   /* g_return_val_if_fail (G_VALUE_TYPE (value) == 0, NULL);    be more elaborate below */
  75
  76   if (G_TYPE_IS_VALUE (g_type) && G_VALUE_TYPE (value) == 0)
  77     {
  78       GTypeValueTable *value_table = g_type_value_table_peek (g_type);
  79
  80       /* setup and init */
  81       value_meminit (value, g_type);
  82       value_table->value_init (value);
  83     }
  84   else if (G_VALUE_TYPE (value))
  85     g_warning ("%s: cannot initialize GValue with type `%s', the value has already been initialized as `%s'",
  86                G_STRLOC,
  87                g_type_name (g_type),
  88                g_type_name (G_VALUE_TYPE (value)));
  89   else /* !G_TYPE_IS_VALUE (g_type) */
  90     g_warning ("%s: cannot initialize GValue with type `%s', %s",
  91                G_STRLOC,
  92                g_type_name (g_type),
  93                g_type_value_table_peek (g_type) ?
  94                "this type is abstract with regards to GValue use, use a more specific (derived) type" :
  95                "this type has no GTypeValueTable implementation");
  96   return value;
  97 }
  98
  99 void
 100 g_value_copy (const GValue *src_value,
 101               GValue       *dest_value)
 102 {
 103   g_return_if_fail (G_IS_VALUE (src_value));
 104   g_return_if_fail (G_IS_VALUE (dest_value));
 105   g_return_if_fail (g_value_type_compatible (G_VALUE_TYPE (src_value), G_VALUE_TYPE (dest_value)));
 106
 107   if (src_value != dest_value)
 108     {
 109       GType dest_type = G_VALUE_TYPE (dest_value);
 110       GTypeValueTable *value_table = g_type_value_table_peek (dest_type);
 111
 112       /* make sure dest_value's value is free()d */
 113       if (value_table->value_free)
 114         value_table->value_free (dest_value);
 115
 116       /* setup and copy */
 117       value_meminit (dest_value, dest_type);
 118       value_table->value_copy (src_value, dest_value);
 119     }
 120 }
 121
 122 GValue*
 123 g_value_reset (GValue *value)
 124 {
 125   GTypeValueTable *value_table;
 126   GType g_type;
 127
 128   g_return_val_if_fail (G_IS_VALUE (value), NULL);
 129
 130   g_type = G_VALUE_TYPE (value);
 131   value_table = g_type_value_table_peek (g_type);
 132
 133   /* make sure value's value is free()d */
 134   if (value_table->value_free)
 135     value_table->value_free (value);
 136
 137   /* setup and init */
 138   value_meminit (value, g_type);
 139   value_table->value_init (value);
 140
 141   return value;
 142 }
 143
 144 void
 145 g_value_unset (GValue *value)
 146 {
 147   GTypeValueTable *value_table;
 148
 149   g_return_if_fail (G_IS_VALUE (value));
 150
 151   value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
 152
 153   if (value_table->value_free)
 154     value_table->value_free (value);
 155   memset (value, 0, sizeof (*value));
 156 }
 157
 158 gboolean
 159 g_value_fits_pointer (const GValue *value)
 160 {
 161   GTypeValueTable *value_table;
 162
 163   g_return_val_if_fail (G_IS_VALUE (value), FALSE);
 164
 165   value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
 166
 167   return value_table->value_peek_pointer != NULL;
 168 }
 169
 170 gpointer
 171 g_value_peek_pointer (const GValue *value)
 172 {
 173   GTypeValueTable *value_table;
 174
 175   g_return_val_if_fail (G_IS_VALUE (value), NULL);
 176
 177   value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
 178   if (!value_table->value_peek_pointer)
 179     {
 180       g_assert (g_value_fits_pointer (value) == TRUE);
 181       return NULL;
 182     }
 183
 184   return value_table->value_peek_pointer (value);
 185 }
 186
 187 void
 188 g_value_set_instance (GValue  *value,
 189                       gpointer instance)
 190 {
 191   GType g_type;
 192   GTypeValueTable *value_table;
 193   GTypeCValue cvalue;
 194   gchar *error_msg;
 195
 196   g_return_if_fail (G_IS_VALUE (value));
 197   if (instance)
 198     {
 199       g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
 200       g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (instance), G_VALUE_TYPE (value)));
 201     }
 202
 203   g_type = G_VALUE_TYPE (value);
 204   value_table = g_type_value_table_peek (g_type);
 205
 206   g_return_if_fail (strcmp (value_table->collect_format, "p") == 0);
 207
 208   memset (&cvalue, 0, sizeof (cvalue));
 209   cvalue.v_pointer = instance;
 210
 211   /* make sure value's value is free()d */
 212   if (value_table->value_free)
 213     value_table->value_free (value);
 214
 215   /* setup and collect */
 216   value_meminit (value, g_type);
 217   error_msg = value_table->collect_value (value, 1, &cvalue, 0);
 218   if (error_msg)
 219     {
 220       g_warning ("%s: %s", G_STRLOC, error_msg);
 221       g_free (error_msg);
 222
 223       /* we purposely leak the value here, it might not be
 224        * in a sane state if an error condition occoured
 225        */
 226       value_meminit (value, g_type);
 227       value_table->value_init (value);
 228     }
 229 }
 230
 231 static GValueTransform
 232 transform_func_lookup (GType src_type,
 233                        GType dest_type)
 234 {
 235   TransformEntry entry;
 236
 237   entry.src_type = src_type;
 238   do
 239     {
 240       entry.dest_type = dest_type;
 241       do
 242         {
 243           TransformEntry *e;
 244
 245           e = g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry);
 246           if (e)
 247             {
 248               /* need to check that there hasn't been a change in value handling */
 249               if (g_type_value_table_peek (entry.dest_type) == g_type_value_table_peek (dest_type) &&
 250                   g_type_value_table_peek (entry.src_type) == g_type_value_table_peek (src_type))
 251                 return e->func;
 252             }
 253           entry.dest_type = g_type_parent (entry.dest_type);
 254         }
 255       while (entry.dest_type);
 256
 257       entry.src_type = g_type_parent (entry.src_type);
 258     }
 259   while (entry.src_type);
 260
 261   return NULL;
 262 }
 263
 264 static gint
 265 transform_entries_cmp (gconstpointer bsearch_node1,
 266                        gconstpointer bsearch_node2)
 267 {
 268   const TransformEntry *e1 = bsearch_node1;
 269   const TransformEntry *e2 = bsearch_node2;
 270   gint cmp = G_BSEARCH_ARRAY_CMP (e1->src_type, e2->src_type);
 271
 272   if (cmp)
 273     return cmp;
 274   else
 275     return G_BSEARCH_ARRAY_CMP (e1->dest_type, e2->dest_type);
 276 }
 277
 278 void
 279 g_value_register_transform_func (GType           src_type,
 280                                  GType           dest_type,
 281                                  GValueTransform transform_func)
 282 {
 283   TransformEntry entry;
 284
 285   /* these checks won't pass for dynamic types.
 286    * g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (src_type));
 287    * g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (dest_type));
 288    */
 289   g_return_if_fail (transform_func != NULL);
 290
 291   entry.src_type = src_type;
 292   entry.dest_type = dest_type;
 293
 294 #if 0 /* let transform function replacement be a valid operation */
 295   if (g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry))
 296     g_warning ("reregistering value transformation function (%p) for `%s' to `%s'",
 297                transform_func,
 298                g_type_name (src_type),
 299                g_type_name (dest_type));
 300 #endif
 301
 302   entry.func = transform_func;
 303   transform_array = g_bsearch_array_replace (transform_array, &transform_bconfig, &entry);
 304 }
 305
 306 gboolean
 307 g_value_type_transformable (GType src_type,
 308                             GType dest_type)
 309 {
 310   g_return_val_if_fail (G_TYPE_IS_VALUE (src_type), FALSE);
 311   g_return_val_if_fail (G_TYPE_IS_VALUE (dest_type), FALSE);
 312
 313   return (g_value_type_compatible (src_type, dest_type) ||
 314           transform_func_lookup (src_type, dest_type) != NULL);
 315 }
 316
 317 gboolean
 318 g_value_type_compatible (GType src_type,
 319                          GType dest_type)
 320 {
 321   g_return_val_if_fail (G_TYPE_IS_VALUE (src_type), FALSE);
 322   g_return_val_if_fail (G_TYPE_IS_VALUE (dest_type), FALSE);
 323
 324   return (g_type_is_a (src_type, dest_type) &&
 325           g_type_value_table_peek (dest_type) == g_type_value_table_peek (src_type));
 326 }
 327
 328 gboolean
 329 g_value_transform (const GValue *src_value,
 330                    GValue       *dest_value)
 331 {
 332   GType dest_type;
 333
 334   g_return_val_if_fail (G_IS_VALUE (src_value), FALSE);
 335   g_return_val_if_fail (G_IS_VALUE (dest_value), FALSE);
 336
 337   dest_type = G_VALUE_TYPE (dest_value);
 338   if (g_value_type_compatible (G_VALUE_TYPE (src_value), dest_type))
 339     {
 340       g_value_copy (src_value, dest_value);
 341
 342       return TRUE;
 343     }
 344   else
 345     {
 346       GValueTransform transform = transform_func_lookup (G_VALUE_TYPE (src_value), dest_type);
 347
 348       if (transform)
 349         {
 350           g_value_unset (dest_value);
 351
 352           /* setup and transform */
 353           value_meminit (dest_value, dest_type);
 354           transform (src_value, dest_value);
 355
 356           return TRUE;
 357         }
 358     }
 359   return FALSE;
 360 }