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

/* dbus-gvalue.c GValue to-from DBusMessageIter

 *

 * Copyright (C) 2004 Ximian, Inc.

 * 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

 *

 */

#include "config.h"

#include "dbus-gtest.h"

#include "dbus-gvalue.h"

#include "dbus-gsignature.h"

#include "dbus-gobject.h"

#include "dbus-gvalue-utils.h"

#include "dbus/dbus-glib.h"

#include <string.h>

#include <glib.h>

#ifndef __SYMBIAN32__

#include <glib/gi18n.h>

#include <libintl.h>

#define _(x) dgettext (GETTEXT_PACKAGE, x)

#define N_(x) x

#else

#define _(x) x

#define N_(x) x

#endif

#include "dbus/dbus-signature.h"

#ifdef __SYMBIAN32__

#include "libdbus_glib_wsd_solution.h"

#endif

static gboolean demarshal_static_variant (DBusGValueMarshalCtx    *context,

					  DBusMessageIter         *iter,

					  GValue                  *value,

					  GError                 **error);

static gboolean marshal_basic                   (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_basic                 (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_strv                    (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_strv                  (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_valuearray              (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_valuearray            (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_variant                 (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_variant               (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_proxy                   (DBusMessageIter           *iter,

						 const GValue             *value);

static gboolean demarshal_proxy                 (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_object_path             (DBusMessageIter           *iter,

						 const GValue             *value);

static gboolean demarshal_object_path           (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_object                  (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_object                (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_map                     (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_map                   (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_collection              (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean marshal_collection_ptrarray     (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean marshal_collection_array        (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_collection            (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean demarshal_collection_ptrarray   (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean demarshal_collection_array      (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

static gboolean marshal_struct                  (DBusMessageIter           *iter,

						 const GValue              *value);

static gboolean demarshal_struct                (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

typedef gboolean (*DBusGValueMarshalFunc)       (DBusMessageIter           *iter,

						 const GValue              *value);

typedef gboolean (*DBusGValueDemarshalFunc)     (DBusGValueMarshalCtx      *context,

						 DBusMessageIter           *iter,

						 GValue                    *value,

						 GError                   **error);

typedef struct {

  DBusGValueMarshalFunc       marshaller;

  DBusGValueDemarshalFunc     demarshaller;

} DBusGTypeMarshalVtable;

typedef struct {

  const char                       *sig;

  const DBusGTypeMarshalVtable     *vtable;

} DBusGTypeMarshalData;

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(quark,dbus_gvalue,GQuark )

#define quark (*GET_DBUS_WSD_VAR_NAME(quark,dbus_gvalue,s)())

#endif

static GQuark

dbus_g_type_metadata_data_quark ()

{

#ifndef EMULATOR

  static GQuark quark;

#endif

  if (!quark)

    quark = g_quark_from_static_string ("DBusGTypeMetaData");

  return quark;

}

static void

set_type_metadata (GType type, const DBusGTypeMarshalData *data)

{

  g_type_set_qdata (type, dbus_g_type_metadata_data_quark (), (gpointer) data);

}

static void

register_basic (int typecode, const DBusGTypeMarshalData *typedata)

{

  set_type_metadata (_dbus_gtype_from_basic_typecode (typecode), typedata);

}

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(types_initialized,dbus_gvalue,gboolean )

#define types_initialized (*GET_DBUS_WSD_VAR_NAME(types_initialized,dbus_gvalue,s)())

#endif

void

_dbus_g_value_types_init (void)

{

#ifndef EMULATOR

   static gboolean types_initialized;

#endif

  static const DBusGTypeMarshalVtable basic_vtable = {

    marshal_basic,

    demarshal_basic

  };

  if (types_initialized)

    return;

  dbus_g_type_specialized_init ();

  _dbus_g_type_specialized_builtins_init ();

  /* Register basic types */

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_BOOLEAN_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_BOOLEAN, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_BYTE_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_BYTE, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_INT16_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_INT16, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_UINT16_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_UINT16, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_UINT32_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_UINT32, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_INT32_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_INT32, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_UINT64_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_UINT64, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_INT64_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_INT64, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_DOUBLE_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_DOUBLE, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_STRING_AS_STRING,

      &basic_vtable,

    };

    register_basic (DBUS_TYPE_STRING, &typedata);

  }

  /* fundamental GTypes that don't map 1:1 with D-BUS types */

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_BYTE_AS_STRING,

      &basic_vtable,

    };

    set_type_metadata (G_TYPE_CHAR, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_INT32_AS_STRING,

      &basic_vtable,

    };

    set_type_metadata (G_TYPE_LONG, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_UINT32_AS_STRING,

      &basic_vtable,

    };

    set_type_metadata (G_TYPE_ULONG, &typedata);

  }

  {

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_DOUBLE_AS_STRING,

      &basic_vtable,

    };

    set_type_metadata (G_TYPE_FLOAT, &typedata);

  }

  /* Register complex types with builtin GType mappings */

  {

    static const DBusGTypeMarshalVtable vtable = {

      marshal_variant,

      demarshal_variant

    };

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_VARIANT_AS_STRING,

      &vtable

    };

    set_type_metadata (G_TYPE_VALUE, &typedata);

  };

  {

    static const DBusGTypeMarshalVtable vtable = {

      marshal_strv,

      demarshal_strv

    };

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,

      &vtable

    };

    set_type_metadata (G_TYPE_STRV, &typedata);

  };

  /* Register some types specific to the D-BUS GLib bindings */

  {

    static const DBusGTypeMarshalVtable vtable = {

      marshal_proxy,

      demarshal_proxy

    };

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_OBJECT_PATH_AS_STRING,

      &vtable

    };

    set_type_metadata (DBUS_TYPE_G_PROXY, &typedata);

  }

  {

    static const DBusGTypeMarshalVtable vtable = {

      marshal_object_path,

      demarshal_object_path

    };

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_OBJECT_PATH_AS_STRING,

      &vtable

    };

    set_type_metadata (DBUS_TYPE_G_OBJECT_PATH, &typedata);

  }

  {

    static const DBusGTypeMarshalVtable vtable = {

      marshal_object,

      demarshal_object

    };

    static const DBusGTypeMarshalData typedata = {

      DBUS_TYPE_OBJECT_PATH_AS_STRING,

      &vtable

    };

    set_type_metadata (G_TYPE_OBJECT, &typedata);

  }

  types_initialized = TRUE;

}

/**

 * Get the GLib type ID for a DBusGObjectPath boxed type.

 *

 * Returns: GLib type

 */

 #if EMULATOR

GET_STATIC_VAR_FROM_TLS(type_id,dbus_gvalue,GType )

#define type_id (*GET_DBUS_WSD_VAR_NAME(type_id,dbus_gvalue,s)())

#endif

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

GType

dbus_g_object_path_get_g_type (void)

{

  #ifndef EMULATOR

  static GType type_id = 0;

#endif

  if (!type_id)

    type_id = g_boxed_type_register_static ("DBusGObjectPath",

					    (GBoxedCopyFunc) g_strdup,

					    (GBoxedFreeFunc) g_free);

  return type_id;

}

char *

_dbus_gtype_to_signature (GType gtype)

{

  char *ret;

  DBusGTypeMarshalData *typedata;

  if (dbus_g_type_is_collection (gtype))

    {

      GType elt_gtype;

      char *subsig;

      elt_gtype = dbus_g_type_get_collection_specialization (gtype);

      subsig = _dbus_gtype_to_signature (elt_gtype);

      ret = g_strconcat (DBUS_TYPE_ARRAY_AS_STRING, subsig, NULL);

      g_free (subsig);

    }

  else if (dbus_g_type_is_map (gtype))

    {

      GType key_gtype;

      GType val_gtype;

      char *key_subsig;

      char *val_subsig;

      key_gtype = dbus_g_type_get_map_key_specialization (gtype);

      val_gtype = dbus_g_type_get_map_value_specialization (gtype);

      key_subsig = _dbus_gtype_to_signature (key_gtype);

      val_subsig = _dbus_gtype_to_signature (val_gtype);

      ret = g_strconcat (DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING, key_subsig, val_subsig, DBUS_DICT_ENTRY_END_CHAR_AS_STRING, NULL);

      g_free (key_subsig);

      g_free (val_subsig);

    }

  else if (dbus_g_type_is_struct (gtype))

    {

      guint i, size;

      GString *sig;

      size = dbus_g_type_get_struct_size (gtype);

      sig = g_string_sized_new (size+2); /*some sensible starting size*/

      g_string_assign (sig, DBUS_STRUCT_BEGIN_CHAR_AS_STRING);

      for (i = 0; i < size; i++)

        {

          gchar *subsig;

          subsig = _dbus_gtype_to_signature (

              dbus_g_type_get_struct_member_type (gtype, i));

          g_string_append (sig, subsig);

          g_free (subsig);

        }

      g_string_append (sig, DBUS_STRUCT_END_CHAR_AS_STRING);

      ret = g_string_free (sig, FALSE);

    }

  else

    {

      typedata = g_type_get_qdata (gtype, dbus_g_type_metadata_data_quark ());

      if (typedata == NULL)

	return NULL;

      ret = g_strdup (typedata->sig);

    }

  return ret;

}

char *

_dbus_gvalue_to_signature (const GValue *val)

{

  GType gtype;

  gtype = G_VALUE_TYPE (val);

  if (g_type_is_a (gtype, G_TYPE_VALUE_ARRAY))

    {

      GString *str;

      guint i;

      GValueArray *array;

      array = g_value_get_boxed (val);

      str = g_string_new (DBUS_STRUCT_BEGIN_CHAR_AS_STRING);

      for (i = 0; i < array->n_values; i++)

	{

	  char *sig;

	  sig = _dbus_gvalue_to_signature (g_value_array_get_nth (array, i));

	  g_string_append (str, sig);

	  g_free (sig);

	}

      g_string_append (str, DBUS_STRUCT_END_CHAR_AS_STRING);

      return g_string_free (str, FALSE);

    }

  else

    return _dbus_gtype_to_signature (gtype);

}

static gboolean

demarshal_basic (DBusGValueMarshalCtx      *context,

		 DBusMessageIter           *iter,

		 GValue                    *value,

		 GError                   **error)

{

  int current_type;

  current_type = dbus_message_iter_get_arg_type (iter);

  g_assert (dbus_type_is_basic (current_type));

  switch (current_type)

    {

    case DBUS_TYPE_BOOLEAN:

      {

	dbus_bool_t bool;

	dbus_message_iter_get_basic (iter, &bool);

	g_value_set_boolean (value, bool);

	return TRUE;

      }

    case DBUS_TYPE_BYTE:

      {

	unsigned char byte;

	dbus_message_iter_get_basic (iter, &byte);

	g_value_set_uchar (value, byte);

	return TRUE;

      }

    case DBUS_TYPE_INT32:

      {

	dbus_int32_t intval;

	dbus_message_iter_get_basic (iter, &intval);

	g_value_set_int (value, intval);

	return TRUE;

      }

    case DBUS_TYPE_UINT32:

      {

	dbus_uint32_t intval;

	dbus_message_iter_get_basic (iter, &intval);

	g_value_set_uint (value, intval);

	return TRUE;