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