/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-gvalue-utils.c: Non-DBus-specific functions related to GType/GValue 

 *

 * Copyright (C) 2005 Red Hat, Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

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

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#ifndef __SYMBIAN32__

#include <config.h>

#else

#include "config.h"

#endif //__SYMBIAN32__

#include "dbus/dbus-glib.h"

#include "dbus-gvalue-utils.h"

#include "dbus-gtest.h"

#include <glib.h>

#include <string.h>

#include <gobject/gvaluecollector.h>

static guint

fixed_type_get_size (GType type)

{

  switch (type)

    {

    case G_TYPE_CHAR:

    case G_TYPE_UCHAR:

      return sizeof (gchar);

    case G_TYPE_BOOLEAN:

      return sizeof (gboolean);

    case G_TYPE_LONG:

    case G_TYPE_ULONG:

      return sizeof (glong);

    case G_TYPE_INT:

    case G_TYPE_UINT:

      return sizeof (gint);

    case G_TYPE_INT64:

    case G_TYPE_UINT64:

      return sizeof (gint64);

    case G_TYPE_FLOAT:

      return sizeof (gfloat);

    case G_TYPE_DOUBLE:

      return sizeof (gdouble);

    default:

      return 0;

    }

}

gboolean

_dbus_g_type_is_fixed (GType type)

{

  return fixed_type_get_size (type) > 0;

}

guint

_dbus_g_type_fixed_get_size (GType type)

{

  g_assert (_dbus_g_type_is_fixed (type));

  return fixed_type_get_size (type);

}

gboolean

_dbus_gvalue_store (GValue          *value,

		   gpointer        storage)

{

  /* FIXME - can we use the GValue lcopy_value method

   * to do this in a cleaner way?

   */

  switch (g_type_fundamental (G_VALUE_TYPE (value)))

    {

    case G_TYPE_CHAR:

      *((gchar *) storage) = g_value_get_char (value);

      return TRUE;

    case G_TYPE_UCHAR:

      *((guchar *) storage) = g_value_get_uchar (value);

      return TRUE;

    case G_TYPE_BOOLEAN:

      *((gboolean *) storage) = g_value_get_boolean (value);

      return TRUE;

    case G_TYPE_LONG:

      *((glong *) storage) = g_value_get_long (value);

      return TRUE;

    case G_TYPE_ULONG:

      *((gulong *) storage) = g_value_get_ulong (value);

      return TRUE;

    case G_TYPE_INT:

      *((gint *) storage) = g_value_get_int (value);

      return TRUE;

    case G_TYPE_UINT:

      *((guint *) storage) = g_value_get_uint (value);

      return TRUE;

    case G_TYPE_INT64:

      *((gint64 *) storage) = g_value_get_int64 (value);

      return TRUE;

    case G_TYPE_UINT64:

      *((guint64 *) storage) = g_value_get_uint64 (value);

      return TRUE;

    case G_TYPE_DOUBLE:

      *((gdouble *) storage) = g_value_get_double (value);

      return TRUE;

    case G_TYPE_STRING:

      *((gchar **) storage) = (char*) g_value_get_string (value);

      return TRUE;

    case G_TYPE_OBJECT:

      *((gpointer *) storage) = g_value_get_object (value);

      return TRUE;

    case G_TYPE_BOXED:

      *((gpointer *) storage) = g_value_get_boxed (value);

      return TRUE;

    default:

      return FALSE;

    }

}

gboolean

_dbus_gvalue_set_from_pointer (GValue          *value,

			      gconstpointer    storage)

{

  /* FIXME - is there a better way to do this? */

  switch (g_type_fundamental (G_VALUE_TYPE (value)))

    {

    case G_TYPE_CHAR:

      g_value_set_char (value, *((gchar *) storage));

      return TRUE;

    case G_TYPE_UCHAR:

      g_value_set_uchar (value, *((guchar *) storage));

      return TRUE;

    case G_TYPE_BOOLEAN:

      g_value_set_boolean (value, *((gboolean *) storage));

      return TRUE;

    case G_TYPE_LONG:

      g_value_set_long (value, *((glong *) storage));

      return TRUE;

    case G_TYPE_ULONG:

      g_value_set_ulong (value, *((gulong *) storage));

      return TRUE;

    case G_TYPE_INT:

      g_value_set_int (value, *((gint *) storage));

      return TRUE;

    case G_TYPE_UINT:

      g_value_set_uint (value, *((guint *) storage));

      return TRUE;

    case G_TYPE_INT64:

      g_value_set_int64 (value, *((gint64 *) storage));

      return TRUE;

    case G_TYPE_UINT64:

      g_value_set_uint64 (value, *((guint64 *) storage));

      return TRUE;

    case G_TYPE_DOUBLE:

      g_value_set_double (value, *((gdouble *) storage));

      return TRUE;

    case G_TYPE_STRING:

      g_value_set_string (value, *((gchar **) storage));

      return TRUE;

    case G_TYPE_OBJECT:

      g_value_set_object (value, *((gpointer *) storage));

      return TRUE;

    case G_TYPE_BOXED:

      g_value_set_boxed (value, *((gpointer *) storage));

      return TRUE;

    default:

      return FALSE;

    }

}

gboolean

_dbus_gvalue_take (GValue          *value,

		  GTypeCValue     *cvalue)

{

  GType g_type;

  GTypeValueTable *value_table;

  char *error_msg;

  g_type = G_VALUE_TYPE (value);

  value_table = g_type_value_table_peek (g_type);

  error_msg = value_table->collect_value (value, 1, cvalue, G_VALUE_NOCOPY_CONTENTS);

  if (error_msg)

    {

      g_warning ("%s: %s", G_STRLOC, error_msg);

      g_free (error_msg);

      return FALSE;

    }

  /* Clear the NOCOPY_CONTENTS flag; we want to take ownership

   * of the value.

   */

  value->data[1].v_uint &= ~(G_VALUE_NOCOPY_CONTENTS);

  return TRUE;

}

gboolean

_dbus_gtype_can_signal_error (GType gtype)

{

  switch (gtype)

    {

    case G_TYPE_BOOLEAN:

    case G_TYPE_INT:

    case G_TYPE_UINT:

    case G_TYPE_STRING:

    case G_TYPE_BOXED:

    case G_TYPE_OBJECT:

      return TRUE;

    default:

      return FALSE;

    }

}

gboolean

_dbus_gvalue_signals_error (const GValue *value)

{

  /* Hardcoded rules for return value semantics for certain

   * types.  Perhaps in the future we'd want an annotation

   * specifying which return values are errors, but in

   * reality people will probably just use boolean and

   * boxed, and there the semantics are pretty standard.

   */

  switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)))

    {

    case G_TYPE_BOOLEAN:

      return (g_value_get_boolean (value) == FALSE);

      break;

    case G_TYPE_INT:

      return (g_value_get_int (value) < 0);

      break;

    case G_TYPE_UINT:

      return (g_value_get_uint (value) == 0);

      break;

    case G_TYPE_STRING:

      return (g_value_get_string (value) == NULL);

      break;

    case G_TYPE_BOXED:

      return (g_value_get_boxed (value) == NULL);

      break;

    case G_TYPE_OBJECT:

      return (g_value_get_object (value) == NULL);

      break;

    default:

      g_assert_not_reached ();

    }

}

static gboolean

hash_func_from_gtype (GType gtype, GHashFunc *func)

{

  switch (gtype)

    {

    case G_TYPE_CHAR:

    case G_TYPE_UCHAR:

    case G_TYPE_BOOLEAN:

    case G_TYPE_INT:

    case G_TYPE_UINT:

      *func = NULL;

      return TRUE;

    case G_TYPE_STRING:

      *func = g_str_hash;

      return TRUE;

    default:

      return FALSE;

    }

}

static void

unset_and_free_g_value (gpointer val)

{

  GValue *value = val;

  g_value_unset (value);

  g_free (value);

}

static gboolean

hash_free_from_gtype (GType gtype, GDestroyNotify *func)

{

  switch (gtype)

    {

    case G_TYPE_CHAR:

    case G_TYPE_UCHAR:

    case G_TYPE_BOOLEAN:

    case G_TYPE_INT:

    case G_TYPE_UINT:

      *func = NULL;

      return TRUE;

    case G_TYPE_DOUBLE:

    case G_TYPE_STRING:

      *func = g_free;

      return TRUE;

    default:

      if (gtype == G_TYPE_VALUE)

	{

	  *func = unset_and_free_g_value;

	  return TRUE;

	}

      else if (gtype == G_TYPE_VALUE_ARRAY)

        {

          *func = (GDestroyNotify) g_value_array_free;

          return TRUE;

        }

      else if (dbus_g_type_is_collection (gtype))

        {

          const DBusGTypeSpecializedCollectionVtable* vtable;

          vtable = dbus_g_type_collection_peek_vtable (gtype);

          if (vtable->base_vtable.simple_free_func)

            {

              *func = vtable->base_vtable.simple_free_func;

              return TRUE;

            }

        }

      else if (dbus_g_type_is_map (gtype))

        {

          const DBusGTypeSpecializedMapVtable* vtable;

          vtable = dbus_g_type_map_peek_vtable (gtype);

          if (vtable->base_vtable.simple_free_func)

            {

              *func = vtable->base_vtable.simple_free_func;

              return TRUE;

            }

        }

      else if (dbus_g_type_is_struct (gtype))

        {

          const DBusGTypeSpecializedStructVtable *vtable;

          vtable = dbus_g_type_struct_peek_vtable (gtype);

          if (vtable->base_vtable.simple_free_func)

            {

              *func = vtable->base_vtable.simple_free_func;

              return TRUE;

            }

        }

      return FALSE;

    }

}

gboolean

_dbus_gtype_is_valid_hash_key (GType type)

{

  GHashFunc func;

  return hash_func_from_gtype (type, &func);

}

gboolean

_dbus_gtype_is_valid_hash_value (GType type)

{

  GDestroyNotify func;

  return hash_free_from_gtype (type, &func);

}

GHashFunc

_dbus_g_hash_func_from_gtype (GType gtype)

{

  GHashFunc func;

  gboolean ret;

  ret = hash_func_from_gtype (gtype, &func);

  g_assert (ret != FALSE);

  return func;

}

GEqualFunc

_dbus_g_hash_equal_from_gtype (GType gtype)

{

  g_assert (_dbus_gtype_is_valid_hash_key (gtype));

  switch (gtype)

    {

    case G_TYPE_CHAR:

    case G_TYPE_UCHAR:

    case G_TYPE_BOOLEAN:

    case G_TYPE_INT:

    case G_TYPE_UINT:

      return NULL;

    case G_TYPE_STRING:

      return g_str_equal;

    default:

      g_assert_not_reached ();

      return NULL;

    }

}

GDestroyNotify

_dbus_g_hash_free_from_gtype (GType gtype)

{

  GDestroyNotify func;

  gboolean ret;

  ret = hash_free_from_gtype (gtype, &func);

  g_assert (ret != FALSE);

  return func;

}

static void gvalue_take_ptrarray_value (GValue *value, gpointer instance);

static void

gvalue_take_hash_value (GValue *value, gpointer instance)

{

  switch (g_type_fundamental (G_VALUE_TYPE (value)))

    {

    case G_TYPE_CHAR:

      g_value_set_char (value, (gchar) GPOINTER_TO_INT (instance));

      break;

    case G_TYPE_UCHAR:

      g_value_set_uchar (value, (guchar) GPOINTER_TO_UINT (instance));

      break;

    case G_TYPE_BOOLEAN:

      g_value_set_boolean (value, (gboolean) GPOINTER_TO_UINT (instance));

      break;

    case G_TYPE_INT:

      g_value_set_int (value, GPOINTER_TO_INT (instance));

      break;

    case G_TYPE_UINT:

      g_value_set_uint (value, GPOINTER_TO_UINT (instance));

      break;

    case G_TYPE_DOUBLE:

      g_value_set_double (value, *(gdouble *) instance);

      break;

    default:

      gvalue_take_ptrarray_value (value, instance);

      break;

    }

}

static gpointer ptrarray_value_from_gvalue (const GValue *value);

static gpointer

hash_value_from_gvalue (GValue *value)

{

  switch (g_type_fundamental (G_VALUE_TYPE (value)))

    {

    case G_TYPE_CHAR:

      return GINT_TO_POINTER ((int) g_value_get_char (value));

      break;

    case G_TYPE_UCHAR:

      return GUINT_TO_POINTER ((guint) g_value_get_uchar (value));

      break;

    case G_TYPE_BOOLEAN:

      return GUINT_TO_POINTER ((guint) g_value_get_boolean (value));

      break;

    case G_TYPE_INT:

      return GINT_TO_POINTER (g_value_get_int (value));

      break;

    case G_TYPE_UINT:

      return GUINT_TO_POINTER (g_value_get_uint (value));

      break;

    case G_TYPE_DOUBLE:

      {

        gdouble *p = (gdouble *) g_malloc0 (sizeof (gdouble));

        *p = g_value_get_double (value);

        return (gpointer) p;

      }

      break;

    default:

      return ptrarray_value_from_gvalue (value);

      break;

    }

}

struct DBusGHashTableValueForeachData

{

  DBusGTypeSpecializedMapIterator func;

  GType key_type;

  GType value_type;

  gpointer data;

};

static void

hashtable_foreach_with_values (gpointer key, gpointer value, gpointer user_data)

{

  GValue key_val = {0, };

  GValue value_val = {0, };

  struct DBusGHashTableValueForeachData *data = user_data;

  g_value_init (&key_val, data->key_type);

  g_value_init (&value_val, data->value_type);

  gvalue_take_hash_value (&key_val, key);

  gvalue_take_hash_value (&value_val, value);

  data->func (&key_val, &value_val, data->data);

}

static void

hashtable_iterator (GType                           hash_type,

		    gpointer                        instance,

		    DBusGTypeSpecializedMapIterator iterator,

		    gpointer                        user_data)

{

  struct DBusGHashTableValueForeachData data;

  GType key_gtype;

  GType value_gtype;

  key_gtype = dbus_g_type_get_map_key_specialization (hash_type);

  value_gtype = dbus_g_type_get_map_value_specialization (hash_type);

  data.func = iterator;

  data.key_type = key_gtype;

  data.value_type = value_gtype;

  data.data = user_data;

  g_hash_table_foreach (instance, hashtable_foreach_with_values, &data);

}

void

_dbus_g_hash_table_insert_steal_values (GHashTable *table,

				       GValue     *key_val,

				       GValue     *value_val)

{

  gpointer key, val;

  key = hash_value_from_gvalue (key_val);

  val = hash_value_from_gvalue (value_val);

  g_hash_table_insert (table, key, val);

}

static void