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