/* GObject - GLib Type, Object, Parameter and Signal Library
- * Copyright (C) 1997, 1998, 1999, 2000 Tim Janik and Red Hat, Inc.
+ * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*/
-#include "gvalue.h"
+/*
+ * FIXME: MT-safety
+ */
-/* --- defines --- */
-#define G_PARAM_SPEC_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_PARAM, GParamSpecClass))
+#include "config.h"
+#include <string.h>
-/* --- typedefs & structures --- */
-typedef struct
-{
- GType value_type1;
- GType value_type2;
- GValueExchange func;
- GType first_type;
-} ExchangeEntry;
+#include "gvalue.h"
+#include "gvaluecollector.h"
+#include "gbsearcharray.h"
+#include "gobjectalias.h"
-/* --- variables --- */
-static GHashTable *param_exchange_ht = NULL;
+/**
+ * SECTION:generic_values
+ * @short_description: A polymorphic type that can hold values of any
+ * other type
+ * @see_also: The fundamental types which all support #GValue
+ * operations and thus can be used as a type initializer for
+ * g_value_init() are defined by a separate interface. See the <link
+ * linkend="gobject-Standard-Parameter-and-Value-Types">Standard
+ * Values API</link> for details.
+ * @title: Generic values
+ *
+ * The #GValue structure is basically a variable container that consists
+ * of a type identifier and a specific value of that type.
+ * The type identifier within a #GValue structure always determines the
+ * type of the associated value.
+ * To create a undefined #GValue structure, simply create a zero-filled
+ * #GValue structure. To initialize the #GValue, use the g_value_init()
+ * function. A #GValue cannot be used until it is initialized.
+ * The basic type operations (such as freeing and copying) are determined
+ * by the #GTypeValueTable associated with the type ID stored in the #GValue.
+ * Other #GValue operations (such as converting values between types) are
+ * provided by this interface.
+ *
+ * The code in the example program below demonstrates #GValue's
+ * features.
+ *
+ * |[
+ * #include <glib-object.h>
+ *
+ * static void
+ * int2string (const GValue *src_value,
+ * GValue *dest_value)
+ * {
+ * if (g_value_get_int (src_value) == 42)
+ * g_value_set_static_string (dest_value, "An important number");
+ * else
+ * g_value_set_static_string (dest_value, "What's that?");
+ * }
+ *
+ * int
+ * main (int argc,
+ * char *argv[])
+ * {
+ * /* GValues must start zero-filled */
+ * GValue a = {0};
+ * GValue b = {0};
+ * const gchar *message;
+ *
+ * g_type_init ();
+ *
+ * /* The GValue starts empty */
+ * g_assert (!G_VALUE_HOLDS_STRING (&a));
+ *
+ * /* Put a string in it */
+ * g_value_init (&a, G_TYPE_STRING);
+ * g_assert (G_VALUE_HOLDS_STRING (&a));
+ * g_value_set_static_string (&a, "Hello, world!");
+ * g_printf ("%s\n", g_value_get_string (&a));
+ *
+ * /* Reset it to its pristine state */
+ * g_value_unset (&a);
+ *
+ * /* It can then be reused for another type */
+ * g_value_init (&a, G_TYPE_INT);
+ * g_value_set_int (&a, 42);
+ *
+ * /* Attempt to transform it into a GValue of type STRING */
+ * g_value_init (&b, G_TYPE_STRING);
+ *
+ * /* An INT is transformable to a STRING */
+ * g_assert (g_value_type_transformable (G_TYPE_INT, G_TYPE_STRING));
+ *
+ * g_value_transform (&a, &b);
+ * g_printf ("%s\n", g_value_get_string (&b));
+ *
+ * /* Attempt to transform it again using a custom transform function */
+ * g_value_register_transform_func (G_TYPE_INT, G_TYPE_STRING, int2string);
+ * g_value_transform (&a, &b);
+ * g_printf ("%s\n", g_value_get_string (&b));
+ * return 0;
+ * }
+ * ]|
+ */
-/* --- functions --- */
-void
-g_value_init (GValue *value,
- GType g_type)
-{
- GParamSpecClass *pclass;
+/* --- typedefs & structures --- */
+typedef struct {
+ GType src_type;
+ GType dest_type;
+ GValueTransform func;
+} TransformEntry;
- g_return_if_fail (value != NULL);
- g_return_if_fail (G_VALUE_TYPE (value) == 0);
- g_type = g_type_next_base (g_type, G_TYPE_PARAM);
- g_return_if_fail (G_TYPE_IS_VALUE (g_type));
- memset (value, 0, sizeof (*value));
- value->g_type = g_type;
+/* --- prototypes --- */
+static gint transform_entries_cmp (gconstpointer bsearch_node1,
+ gconstpointer bsearch_node2);
- pclass = g_type_class_ref (G_VALUE_TYPE (value));
- pclass->param_init (value, NULL);
- g_type_class_unref (pclass);
-}
-void
-g_value_init_default (GValue *value,
- GParamSpec *pspec)
-{
- g_return_if_fail (value != NULL);
- g_return_if_fail (G_VALUE_TYPE (value) == 0);
- g_return_if_fail (G_IS_PARAM_SPEC (pspec));
-
- memset (value, 0, sizeof (*value));
- value->g_type = g_type_next_base (G_PARAM_SPEC_TYPE (pspec), G_TYPE_PARAM);
+/* --- variables --- */
+static GBSearchArray *transform_array = NULL;
+static GBSearchConfig transform_bconfig = {
+ sizeof (TransformEntry),
+ transform_entries_cmp,
+ G_BSEARCH_ARRAY_ALIGN_POWER2,
+};
- G_PARAM_SPEC_GET_CLASS (pspec)->param_init (value, pspec);
-}
-gboolean
-g_value_validate (GValue *value,
- GParamSpec *pspec)
+/* --- functions --- */
+void
+g_value_c_init (void)
{
- g_return_val_if_fail (G_IS_VALUE (value), FALSE);
- g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
- g_return_val_if_fail (g_type_is_a (G_PARAM_SPEC_TYPE (pspec), G_VALUE_TYPE (value)), FALSE);
-
- if (G_PARAM_SPEC_GET_CLASS (pspec)->param_validate)
- {
- GValue oval = *value;
-
- if (G_PARAM_SPEC_GET_CLASS (pspec)->param_validate (value, pspec) ||
- memcmp (&oval.data, &value->data, sizeof (oval.data)))
- return TRUE;
- }
- return FALSE;
+ transform_array = g_bsearch_array_create (&transform_bconfig);
}
-gboolean
-g_value_defaults (const GValue *value,
- GParamSpec *pspec)
+static inline void /* keep this function in sync with gvaluecollector.h and gboxed.c */
+value_meminit (GValue *value,
+ GType value_type)
{
- GValue dflt_value = { 0, };
- gboolean defaults;
-
- g_return_val_if_fail (G_IS_VALUE (value), FALSE);
- g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
- g_return_val_if_fail (g_type_is_a (G_PARAM_SPEC_TYPE (pspec), G_VALUE_TYPE (value)), FALSE);
-
- dflt_value.g_type = g_type_next_base (G_PARAM_SPEC_TYPE (pspec), G_TYPE_PARAM);
- G_PARAM_SPEC_GET_CLASS (pspec)->param_init (&dflt_value, pspec);
- defaults = g_values_cmp (value, &dflt_value, pspec) == 0;
- g_value_unset (&dflt_value);
-
- return defaults;
+ value->g_type = value_type;
+ memset (value->data, 0, sizeof (value->data));
}
-void
-g_value_set_default (GValue *value,
- GParamSpec *pspec)
+/**
+ * g_value_init:
+ * @value: A zero-filled (uninitialized) #GValue structure.
+ * @g_type: Type the #GValue should hold values of.
+ *
+ * Initializes @value with the default value of @type.
+ *
+ * Returns: the #GValue structure that has been passed in
+ */
+GValue*
+g_value_init (GValue *value,
+ GType g_type)
{
- GValue tmp_value = { 0, };
-
- g_return_if_fail (G_IS_VALUE (value));
- g_return_if_fail (G_IS_PARAM_SPEC (pspec));
- g_return_if_fail (g_type_is_a (G_PARAM_SPEC_TYPE (pspec), G_VALUE_TYPE (value)));
-
- /* retrive default value */
- tmp_value.g_type = g_type_next_base (G_PARAM_SPEC_TYPE (pspec), G_TYPE_PARAM);
- G_PARAM_SPEC_GET_CLASS (pspec)->param_init (&tmp_value, pspec);
-
- /* set default value */
- g_values_exchange (&tmp_value, value);
+ /* g_return_val_if_fail (G_TYPE_IS_VALUE (g_type), NULL); be more elaborate below */
+ g_return_val_if_fail (value != NULL, NULL);
+ /* g_return_val_if_fail (G_VALUE_TYPE (value) == 0, NULL); be more elaborate below */
- g_value_unset (&tmp_value);
-}
-
-gint
-g_values_cmp (const GValue *value1,
- const GValue *value2,
- GParamSpec *pspec)
-{
- GParamSpecClass *pclass;
- gint cmp;
-
- /* param_values_cmp() effectively does: value1 - value2
- * so the return values are:
- * -1) value1 < value2
- * 0) value1 == value2
- * 1) value1 > value2
- */
- g_return_val_if_fail (G_IS_VALUE (value1), 0);
- g_return_val_if_fail (G_IS_VALUE (value2), 0);
- g_return_val_if_fail (G_VALUE_TYPE (value1) == G_VALUE_TYPE (value2), 0);
- if (pspec)
+ if (G_TYPE_IS_VALUE (g_type) && G_VALUE_TYPE (value) == 0)
{
- g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), 0);
- g_return_val_if_fail (g_type_is_a (G_PARAM_SPEC_TYPE (pspec), G_VALUE_TYPE (value1)), FALSE);
- }
-
- pclass = g_type_class_ref (G_VALUE_TYPE (value1));
- cmp = pclass->param_values_cmp (value1, value2, pspec);
- g_type_class_unref (pclass);
+ GTypeValueTable *value_table = g_type_value_table_peek (g_type);
- return CLAMP (cmp, -1, 1);
+ /* setup and init */
+ value_meminit (value, g_type);
+ value_table->value_init (value);
+ }
+ else if (G_VALUE_TYPE (value))
+ g_warning ("%s: cannot initialize GValue with type `%s', the value has already been initialized as `%s'",
+ G_STRLOC,
+ g_type_name (g_type),
+ g_type_name (G_VALUE_TYPE (value)));
+ else /* !G_TYPE_IS_VALUE (g_type) */
+ g_warning ("%s: cannot initialize GValue with type `%s', %s",
+ G_STRLOC,
+ g_type_name (g_type),
+ g_type_value_table_peek (g_type) ?
+ "this type is abstract with regards to GValue use, use a more specific (derived) type" :
+ "this type has no GTypeValueTable implementation");
+ return value;
}
+/**
+ * g_value_copy:
+ * @src_value: An initialized #GValue structure.
+ * @dest_value: An initialized #GValue structure of the same type as @src_value.
+ *
+ * Copies the value of @src_value into @dest_value.
+ */
void
g_value_copy (const GValue *src_value,
GValue *dest_value)
{
g_return_if_fail (G_IS_VALUE (src_value));
g_return_if_fail (G_IS_VALUE (dest_value));
- g_return_if_fail (G_VALUE_TYPE (src_value) == G_VALUE_TYPE (dest_value));
-
+ g_return_if_fail (g_value_type_compatible (G_VALUE_TYPE (src_value), G_VALUE_TYPE (dest_value)));
+
if (src_value != dest_value)
{
- GParamSpecClass *pclass = g_type_class_ref (G_VALUE_TYPE (src_value));
-
- /* make sure dest_value's value is free()d and zero initialized */
- g_value_reset (dest_value);
-
- if (pclass->param_copy_value)
- pclass->param_copy_value (src_value, dest_value);
- else
- memcpy (&dest_value->data, &src_value->data, sizeof (src_value->data));
- g_type_class_unref (pclass);
+ GType dest_type = G_VALUE_TYPE (dest_value);
+ GTypeValueTable *value_table = g_type_value_table_peek (dest_type);
+
+ /* make sure dest_value's value is free()d */
+ if (value_table->value_free)
+ value_table->value_free (dest_value);
+
+ /* setup and copy */
+ value_meminit (dest_value, dest_type);
+ value_table->value_copy (src_value, dest_value);
}
}
-void
-g_value_unset (GValue *value)
+/**
+ * g_value_reset:
+ * @value: An initialized #GValue structure.
+ *
+ * Clears the current value in @value and resets it to the default value
+ * (as if the value had just been initialized).
+ *
+ * Returns: the #GValue structure that has been passed in
+ */
+GValue*
+g_value_reset (GValue *value)
{
- GParamSpecClass *pclass;
+ GTypeValueTable *value_table;
+ GType g_type;
+
+ g_return_val_if_fail (G_IS_VALUE (value), NULL);
+
+ g_type = G_VALUE_TYPE (value);
+ value_table = g_type_value_table_peek (g_type);
- g_return_if_fail (G_IS_VALUE (value));
+ /* make sure value's value is free()d */
+ if (value_table->value_free)
+ value_table->value_free (value);
- pclass = g_type_class_ref (G_VALUE_TYPE (value));
- if (pclass->param_free_value)
- pclass->param_free_value (value);
- memset (value, 0, sizeof (*value));
- g_type_class_unref (pclass);
+ /* setup and init */
+ value_meminit (value, g_type);
+ value_table->value_init (value);
+
+ return value;
}
+/**
+ * g_value_unset:
+ * @value: An initialized #GValue structure.
+ *
+ * Clears the current value in @value and "unsets" the type,
+ * this releases all resources associated with this GValue.
+ * An unset value is the same as an uninitialized (zero-filled)
+ * #GValue structure.
+ */
void
-g_value_reset (GValue *value)
+g_value_unset (GValue *value)
{
- GParamSpecClass *pclass;
- GType g_type;
-
+ GTypeValueTable *value_table;
+
g_return_if_fail (G_IS_VALUE (value));
- g_type = G_VALUE_TYPE (value);
- pclass = g_type_class_ref (g_type);
+ value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
- if (pclass->param_free_value)
- pclass->param_free_value (value);
+ if (value_table->value_free)
+ value_table->value_free (value);
memset (value, 0, sizeof (*value));
-
- value->g_type = g_type;
- pclass->param_init (value, NULL);
-
- g_type_class_unref (pclass);
}
-static gint
-exchange_entries_equal (gconstpointer v1,
- gconstpointer v2)
+/**
+ * g_value_fits_pointer:
+ * @value: An initialized #GValue structure.
+ *
+ * Determines if @value will fit inside the size of a pointer value.
+ * This is an internal function introduced mainly for C marshallers.
+ *
+ * Returns: %TRUE if @value will fit inside a pointer value.
+ */
+gboolean
+g_value_fits_pointer (const GValue *value)
{
- const ExchangeEntry *entry1 = v1;
- const ExchangeEntry *entry2 = v2;
+ GTypeValueTable *value_table;
- return (entry1->value_type1 == entry2->value_type1 &&
- entry1->value_type2 == entry2->value_type2);
-}
+ g_return_val_if_fail (G_IS_VALUE (value), FALSE);
-static guint
-exchange_entry_hash (gconstpointer key)
-{
- const ExchangeEntry *entry = key;
+ value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
- return entry->value_type1 ^ entry->value_type2;
+ return value_table->value_peek_pointer != NULL;
}
-static void
-value_exchange_memcpy (GValue *value1,
- GValue *value2)
+/**
+ * g_value_peek_pointer:
+ * @value: An initialized #GValue structure.
+ *
+ * Return the value contents as pointer. This function asserts that
+ * g_value_fits_pointer() returned %TRUE for the passed in value.
+ * This is an internal function introduced mainly for C marshallers.
+ *
+ * Returns: %TRUE if @value will fit inside a pointer value.
+ */
+gpointer
+g_value_peek_pointer (const GValue *value)
{
- GValue tmp_value;
+ GTypeValueTable *value_table;
- memcpy (&tmp_value.data, &value1->data, sizeof (value1->data));
- memcpy (&value1->data, &value2->data, sizeof (value1->data));
- memcpy (&value2->data, &tmp_value.data, sizeof (value2->data));
+ g_return_val_if_fail (G_IS_VALUE (value), NULL);
+
+ value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
+ if (!value_table->value_peek_pointer)
+ {
+ g_return_val_if_fail (g_value_fits_pointer (value) == TRUE, NULL);
+ return NULL;
+ }
+
+ return value_table->value_peek_pointer (value);
}
-static inline GValueExchange
-exchange_func_lookup (GType value_type1,
- GType value_type2,
- gboolean *need_swap)
+/**
+ * g_value_set_instance:
+ * @value: An initialized #GValue structure.
+ * @instance: the instance
+ *
+ * Sets @value from an instantiatable type via the
+ * value_table's collect_value() function.
+ */
+void
+g_value_set_instance (GValue *value,
+ gpointer instance)
{
- if (value_type1 == value_type2)
- return value_exchange_memcpy;
- else
+ GType g_type;
+ GTypeValueTable *value_table;
+ GTypeCValue cvalue;
+ gchar *error_msg;
+
+ g_return_if_fail (G_IS_VALUE (value));
+ if (instance)
{
- ExchangeEntry entry, *ret;
-
- entry.value_type1 = MIN (value_type1, value_type2);
- entry.value_type2 = MAX (value_type1, value_type2);
+ g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
+ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (instance), G_VALUE_TYPE (value)));
+ }
+
+ g_type = G_VALUE_TYPE (value);
+ value_table = g_type_value_table_peek (g_type);
+
+ g_return_if_fail (strcmp (value_table->collect_format, "p") == 0);
+
+ memset (&cvalue, 0, sizeof (cvalue));
+ cvalue.v_pointer = instance;
+
+ /* make sure value's value is free()d */
+ if (value_table->value_free)
+ value_table->value_free (value);
+
+ /* setup and collect */
+ value_meminit (value, g_type);
+ error_msg = value_table->collect_value (value, 1, &cvalue, 0);
+ if (error_msg)
+ {
+ g_warning ("%s: %s", G_STRLOC, error_msg);
+ g_free (error_msg);
- ret = g_hash_table_lookup (param_exchange_ht, &entry);
- if (ret)
- {
- if (need_swap)
- *need_swap = ret->first_type == value_type1;
+ /* we purposely leak the value here, it might not be
+ * in a sane state if an error condition occoured
+ */
+ value_meminit (value, g_type);
+ value_table->value_init (value);
+ }
+}
- return ret->func;
+static GValueTransform
+transform_func_lookup (GType src_type,
+ GType dest_type)
+{
+ TransformEntry entry;
+
+ entry.src_type = src_type;
+ do
+ {
+ entry.dest_type = dest_type;
+ do
+ {
+ TransformEntry *e;
+
+ e = g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry);
+ if (e)
+ {
+ /* need to check that there hasn't been a change in value handling */
+ if (g_type_value_table_peek (entry.dest_type) == g_type_value_table_peek (dest_type) &&
+ g_type_value_table_peek (entry.src_type) == g_type_value_table_peek (src_type))
+ return e->func;
+ }
+ entry.dest_type = g_type_parent (entry.dest_type);
}
+ while (entry.dest_type);
+
+ entry.src_type = g_type_parent (entry.src_type);
}
+ while (entry.src_type);
+
return NULL;
}
-void
-g_value_register_exchange_func (GType value_type1,
- GType value_type2,
- GValueExchange func)
+static gint
+transform_entries_cmp (gconstpointer bsearch_node1,
+ gconstpointer bsearch_node2)
{
- GType type1, type2;
-
- g_return_if_fail (G_TYPE_IS_VALUE (value_type1));
- g_return_if_fail (G_TYPE_IS_VALUE (value_type2));
- g_return_if_fail (func != NULL);
-
- type1 = g_type_next_base (value_type1, G_TYPE_PARAM);
- type2 = g_type_next_base (value_type2, G_TYPE_PARAM);
+ const TransformEntry *e1 = bsearch_node1;
+ const TransformEntry *e2 = bsearch_node2;
+ gint cmp = G_BSEARCH_ARRAY_CMP (e1->src_type, e2->src_type);
- if (param_exchange_ht && exchange_func_lookup (type1, type2, NULL))
- g_warning (G_STRLOC ": cannot re-register param value exchange function "
- "for `%s' and `%s'",
- g_type_name (type1),
- g_type_name (type2));
+ if (cmp)
+ return cmp;
else
- {
- ExchangeEntry *entry = g_new (ExchangeEntry, 1);
-
- if (!param_exchange_ht)
- param_exchange_ht = g_hash_table_new (exchange_entry_hash, exchange_entries_equal);
- entry->value_type1 = MIN (type1, type2);
- entry->value_type2 = MAX (type1, type2);
- entry->func = func;
- entry->first_type = type1;
- g_hash_table_insert (param_exchange_ht, entry, entry);
- }
+ return G_BSEARCH_ARRAY_CMP (e1->dest_type, e2->dest_type);
}
-gboolean
-g_value_types_exchangable (GType value_type1,
- GType value_type2)
+/**
+ * g_value_register_transform_func:
+ * @src_type: Source type.
+ * @dest_type: Target type.
+ * @transform_func: a function which transforms values of type @src_type
+ * into value of type @dest_type
+ *
+ * Registers a value transformation function for use in g_value_transform().
+ * A previously registered transformation function for @src_type and @dest_type
+ * will be replaced.
+ */
+void
+g_value_register_transform_func (GType src_type,
+ GType dest_type,
+ GValueTransform transform_func)
{
- GType type1, type2;
+ TransformEntry entry;
+
+ /* these checks won't pass for dynamic types.
+ * g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (src_type));
+ * g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (dest_type));
+ */
+ g_return_if_fail (transform_func != NULL);
- g_return_val_if_fail (G_TYPE_IS_VALUE (value_type1), FALSE);
- g_return_val_if_fail (G_TYPE_IS_VALUE (value_type2), FALSE);
+ entry.src_type = src_type;
+ entry.dest_type = dest_type;
- type1 = g_type_next_base (value_type1, G_TYPE_PARAM);
- type2 = g_type_next_base (value_type2, G_TYPE_PARAM);
+#if 0 /* let transform function replacement be a valid operation */
+ if (g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry))
+ g_warning ("reregistering value transformation function (%p) for `%s' to `%s'",
+ transform_func,
+ g_type_name (src_type),
+ g_type_name (dest_type));
+#endif
- return exchange_func_lookup (type1, type2, NULL) != NULL;
+ entry.func = transform_func;
+ transform_array = g_bsearch_array_replace (transform_array, &transform_bconfig, &entry);
}
+/**
+ * g_value_type_transformable:
+ * @src_type: Source type.
+ * @dest_type: Target type.
+ *
+ * Check whether g_value_transform() is able to transform values
+ * of type @src_type into values of type @dest_type.
+ *
+ * Returns: %TRUE if the transformation is possible, %FALSE otherwise.
+ */
gboolean
-g_values_exchange (GValue *value1,
- GValue *value2)
+g_value_type_transformable (GType src_type,
+ GType dest_type)
{
- g_return_val_if_fail (G_IS_VALUE (value1), FALSE);
- g_return_val_if_fail (G_IS_VALUE (value2), FALSE);
+ g_return_val_if_fail (G_TYPE_IS_VALUE (src_type), FALSE);
+ g_return_val_if_fail (G_TYPE_IS_VALUE (dest_type), FALSE);
- if (value1 != value2)
- {
- GType type1 = g_type_next_base (G_VALUE_TYPE (value1), G_TYPE_PARAM);
- GType type2 = g_type_next_base (G_VALUE_TYPE (value2), G_TYPE_PARAM);
- gboolean need_swap;
- GValueExchange value_exchange = exchange_func_lookup (type1,
- type2,
- &need_swap);
- if (value_exchange)
- {
- if (need_swap)
- value_exchange (value2, value1);
- else
- value_exchange (value1, value2);
- }
+ return (g_value_type_compatible (src_type, dest_type) ||
+ transform_func_lookup (src_type, dest_type) != NULL);
+}
- return value_exchange != NULL;
- }
+/**
+ * g_value_type_compatible:
+ * @src_type: source type to be copied.
+ * @dest_type: destination type for copying.
+ *
+ * Returns whether a #GValue of type @src_type can be copied into
+ * a #GValue of type @dest_type.
+ *
+ * Returns: %TRUE if g_value_copy() is possible with @src_type and @dest_type.
+ */
+gboolean
+g_value_type_compatible (GType src_type,
+ GType dest_type)
+{
+ g_return_val_if_fail (G_TYPE_IS_VALUE (src_type), FALSE);
+ g_return_val_if_fail (G_TYPE_IS_VALUE (dest_type), FALSE);
- return TRUE;
+ return (g_type_is_a (src_type, dest_type) &&
+ g_type_value_table_peek (dest_type) == g_type_value_table_peek (src_type));
}
+/**
+ * g_value_transform:
+ * @src_value: Source value.
+ * @dest_value: Target value.
+ *
+ * Tries to cast the contents of @src_value into a type appropriate
+ * to store in @dest_value, e.g. to transform a %G_TYPE_INT value
+ * into a %G_TYPE_FLOAT value. Performing transformations between
+ * value types might incur precision lossage. Especially
+ * transformations into strings might reveal seemingly arbitrary
+ * results and shouldn't be relied upon for production code (such
+ * as rcfile value or object property serialization).
+ *
+ * Returns: Whether a transformation rule was found and could be applied.
+ * Upon failing transformations, @dest_value is left untouched.
+ */
gboolean
-g_value_convert (const GValue *src_value,
- GValue *dest_value)
+g_value_transform (const GValue *src_value,
+ GValue *dest_value)
{
- gboolean success = TRUE;
+ GType dest_type;
g_return_val_if_fail (G_IS_VALUE (src_value), FALSE);
g_return_val_if_fail (G_IS_VALUE (dest_value), FALSE);
- if (src_value != dest_value)
+ dest_type = G_VALUE_TYPE (dest_value);
+ if (g_value_type_compatible (G_VALUE_TYPE (src_value), dest_type))
{
- GValue tmp_value = { 0, };
-
- g_value_init (&tmp_value, G_VALUE_TYPE (src_value));
- g_value_copy (src_value, &tmp_value);
+ g_value_copy (src_value, dest_value);
- success = g_values_exchange (&tmp_value, dest_value);
- g_value_unset (&tmp_value);
+ return TRUE;
}
+ else
+ {
+ GValueTransform transform = transform_func_lookup (G_VALUE_TYPE (src_value), dest_type);
- return success;
+ if (transform)
+ {
+ g_value_unset (dest_value);
+
+ /* setup and transform */
+ value_meminit (dest_value, dest_type);
+ transform (src_value, dest_value);
+
+ return TRUE;
+ }
+ }
+ return FALSE;
}
+
+#define __G_VALUE_C__
+#include "gobjectaliasdef.c"