/* GObject - GLib Type, Object, Parameter and Signal Library

  * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.

  * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

  *

  * This library is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Lesser General Public

  * License as published by the Free Software Foundation; either

  * version 2 of the License, or (at your option) any later version.

  *

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

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

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

  * Lesser General Public License for more details.

  *

  * You should have received a copy of the GNU Lesser General

  * Public License along with this library; if not, write to the

  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,

  * Boston, MA 02111-1307, USA.

  */

 /*

  * FIXME: MT-safety

  */

 #include "config.h"

 #include <string.h>

 #include "gvalue.h"

 #include "gvaluecollector.h"

 #include "gbsearcharray.h"

 #include "gobjectalias.h"

 #ifdef __SYMBIAN32__

 #include "gobject_wsd.h"

 #endif /* __SYMBIAN32__ */

 /**

  * 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;

  * }

  * ]|

  */

 /* --- typedefs & structures --- */

 typedef struct {

   GType src_type;

   GType dest_type;

   GValueTransform func;

 } TransformEntry;

 /* --- prototypes --- */

 static gint	transform_entries_cmp	(gconstpointer bsearch_node1,

 					 gconstpointer bsearch_node2);

 /* --- variables --- */

 #if EMULATOR

 PLS(transform_array,gvalue,GBSearchArray *) 

 PLS(transform_bconfig,gvalue,GBSearchConfig )

 #define transform_array (*FUNCTION_NAME(transform_array,gvalue)())

 #define transform_bconfig  (*FUNCTION_NAME(transform_bconfig ,gvalue)())

 const GBSearchConfig temp_transform_bconfig = {

   sizeof (TransformEntry),

   transform_entries_cmp,

   0,

 };

 #else

 static GBSearchArray *transform_array = NULL;

 static GBSearchConfig transform_bconfig = {

   sizeof (TransformEntry),

   transform_entries_cmp,

   0,

 };

 #endif /* EMULATOR */

 /* --- functions --- */

 void

 g_value_c_init (void)

 {

   transform_array = g_bsearch_array_create (&transform_bconfig);

 }

 static inline void		/* keep this function in sync with gvaluecollector.h and gboxed.c */

 value_meminit (GValue *value,

 	       GType   value_type)

 {

   value->g_type = value_type;

   memset (value->data, 0, sizeof (value->data));

 }

 /**

  * 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

  */

 EXPORT_C GValue*

 g_value_init (GValue *value,

 	      GType   g_type)

 {

   /* 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 */

   if (G_TYPE_IS_VALUE (g_type) && G_VALUE_TYPE (value) == 0)

     {

       GTypeValueTable *value_table = g_type_value_table_peek (g_type);

       /* 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.

  */

 EXPORT_C 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_compatible (G_VALUE_TYPE (src_value), G_VALUE_TYPE (dest_value)));

   if (src_value != dest_value)

     {

       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);

     }

 }

 /**

  * 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

  */

 EXPORT_C GValue*

 g_value_reset (GValue *value)

 {

   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);

   /* make sure value's value is free()d */

   if (value_table->value_free)

     value_table->value_free (value);

   /* 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.

  */

 EXPORT_C void

 g_value_unset (GValue *value)

 {

   GTypeValueTable *value_table;

   g_return_if_fail (G_IS_VALUE (value));

   value_table = g_type_value_table_peek (G_VALUE_TYPE (value));

   if (value_table->value_free)

     value_table->value_free (value);

   memset (value, 0, sizeof (*value));

 }

 /**

  * 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.

  */

 EXPORT_C gboolean

 g_value_fits_pointer (const GValue *value)

 {

   GTypeValueTable *value_table;

   g_return_val_if_fail (G_IS_VALUE (value), FALSE);

   value_table = g_type_value_table_peek (G_VALUE_TYPE (value));

   return value_table->value_peek_pointer != NULL;

 }

 /**

  * 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.

  */

 EXPORT_C gpointer

 g_value_peek_pointer (const GValue *value)

 {

   GTypeValueTable *value_table;

   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);

 }

 /**

  * 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.

  */

 EXPORT_C void

 g_value_set_instance (GValue  *value,

 		      gpointer instance)

 {

   GType g_type;

   GTypeValueTable *value_table;

   GTypeCValue cvalue;

   gchar *error_msg;

   g_return_if_fail (G_IS_VALUE (value));

   if (instance)

     {

       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);

       /* 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);

     }

 }

 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;

 }

 static gint

 transform_entries_cmp (gconstpointer bsearch_node1,

 		       gconstpointer bsearch_node2)

 {

   const TransformEntry *e1 = bsearch_node1;

   const TransformEntry *e2 = bsearch_node2;

   gint cmp = G_BSEARCH_ARRAY_CMP (e1->src_type, e2->src_type);

   if (cmp)

     return cmp;

   else

     return G_BSEARCH_ARRAY_CMP (e1->dest_type, e2->dest_type);

 }

 /**

  * 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.

  */

 EXPORT_C void

 g_value_register_transform_func (GType           src_type,

 				 GType           dest_type,

 				 GValueTransform transform_func)

 {

   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);

   entry.src_type = src_type;

   entry.dest_type = dest_type;

 #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

   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.

  */

 EXPORT_C gboolean

 g_value_type_transformable (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 (g_value_type_compatible (src_type, dest_type) ||

 	  transform_func_lookup (src_type, dest_type) != 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.

  */

 EXPORT_C 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 (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.

  */

 EXPORT_C gboolean

 g_value_transform (const GValue *src_value,

 		   GValue       *dest_value)

 {

   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);

   dest_type = G_VALUE_TYPE (dest_value);

   if (g_value_type_compatible (G_VALUE_TYPE (src_value), dest_type))

     {

       g_value_copy (src_value, dest_value);

       return TRUE;

     }

   else

     {

       GValueTransform transform = transform_func_lookup (G_VALUE_TYPE (src_value), dest_type);

       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"