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

/* dbus-gtype-specialized.c: Non-DBus-specific functions for specialized GTypes

 *

 * Copyright (C) 2005 Red Hat, Inc.

 * Copyright (C) 2007 Codethink Ltd.

 * 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 "dbus-gtype-specialized.h"

#include <glib.h>

#include <string.h>

#include <gobject/gvaluecollector.h>

#ifdef __SYMBIAN32__

#ifndef DBUS_GTOOL_STATIC_LIBRARY_BUILD

#include "libdbus_glib_wsd_solution.h"

#endif

#endif

/**

 * SECTION:dbus-gtype-specialized

 * @short_description: Specialized GTypes

 * @stability: Unstable

 *

 * Specialized gtypes are basically a way to allow the definition of

 * recursive GTypes. It allows the definition of 'containers' which is

 * basically a user defined structure capabale of holding other data and a 

 * set of functions defining how to access that structure. Containers come in

 * 3 flavors: collections, maps and structs. 

 *

 * A collection is a container that holds an ordered set of items, all

 * of which must be the same type. 

 *

 * A map is a container that holds a set of key/value pairs. 

 * The keys have one type, and the values another.

 *

 * A struct is a container that holds a fixed number of members, each member 

 * having a predefined type.

 *

 * A specialization is a GType detailing a particular container with

 * particular types (a type specialization).

 *

 * Functions are provided for constructing and manipulating specializations.

 *

 * This documentation needs splitting into two pages, one for defining new

 * containers and using existing containers. I expect most users to only do

 * the latter. I also need to add some examples.

 */

typedef enum {

  DBUS_G_SPECTYPE_COLLECTION,

  DBUS_G_SPECTYPE_MAP,

  DBUS_G_SPECTYPE_STRUCT

} DBusGTypeSpecializedType;

typedef struct {

  DBusGTypeSpecializedType type;

  const DBusGTypeSpecializedVtable     *vtable;

} DBusGTypeSpecializedContainer;

typedef struct {

  guint num_types;

  GType *types;

  const DBusGTypeSpecializedContainer     *klass;

} DBusGTypeSpecializedData;

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(specialized_containers,dbus_gtype_specialized,GHashTable *)

#define specialized_containers (*GET_DBUS_WSD_VAR_NAME(specialized_containers,dbus_gtype_specialized,s)())

#else

static GHashTable /* char * -> data* */ *specialized_containers;

#endif

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(quark,dbus_gtype_specialized,GQuark )

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

#endif

static GQuark

specialized_type_data_quark ()

{

#ifndef EMULATOR

  static GQuark quark;

  #endif

  if (!quark)

    quark = g_quark_from_static_string ("DBusGTypeSpecializedData");

  return quark;

}

	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

void

dbus_g_type_specialized_init (void)

{

  specialized_containers = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

}

static gboolean

specialized_types_is_initialized (void)

{

  return specialized_containers != NULL;

}

static DBusGTypeSpecializedData *

lookup_specialization_data (GType type)

{

  return g_type_get_qdata (type, specialized_type_data_quark ());

}

/* Copied from gboxed.c */

static void

proxy_value_init (GValue *value)

{

  value->data[0].v_pointer = NULL;

}

/* Adapted from gboxed.c */

static void

proxy_value_free (GValue *value)

{

  if (value->data[0].v_pointer && !(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))

    {

      DBusGTypeSpecializedData *data;

      GType type;

      type = G_VALUE_TYPE (value);

      data = lookup_specialization_data (type);

      g_assert (data != NULL);

      if (data->klass->vtable->free_func)

        {

          data->klass->vtable->free_func (type, value->data[0].v_pointer);

        }

      else

        {

          g_assert (data->klass->vtable->simple_free_func != NULL);

          data->klass->vtable->simple_free_func (value->data[0].v_pointer);

        }

    }

}

/* Adapted from gboxed.c */

static void

proxy_value_copy (const GValue *src_value,

		  GValue       *dest_value)

{

  if (src_value->data[0].v_pointer)

    {

      DBusGTypeSpecializedData *data;

      GType type;

      type = G_VALUE_TYPE (src_value);

      data = lookup_specialization_data (type);

      g_assert (data != NULL);

      dest_value->data[0].v_pointer = data->klass->vtable->copy_func (type, src_value->data[0].v_pointer);

    }

  else

    dest_value->data[0].v_pointer = src_value->data[0].v_pointer;

}

/* Copied from gboxed.c */

static gpointer

proxy_value_peek_pointer (const GValue *value)

{

  return value->data[0].v_pointer;

}

/* Adapted from gboxed.c */

static gchar*

proxy_collect_value (GValue      *value,

		     guint        n_collect_values,

		     GTypeCValue *collect_values,

		     guint        collect_flags)

{

  DBusGTypeSpecializedData *data;

  GType type;

  type = G_VALUE_TYPE (value);

  data = lookup_specialization_data (type);

  if (!collect_values[0].v_pointer)

    value->data[0].v_pointer = NULL;

  else

    {

      if (collect_flags & G_VALUE_NOCOPY_CONTENTS)

	{

	  value->data[0].v_pointer = collect_values[0].v_pointer;

	  value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;

	}

      else

        {

	  value->data[0].v_pointer = data->klass->vtable->copy_func (type, collect_values[0].v_pointer);

        }

    }

  return NULL;

}

/* Adapted from gboxed.c */

static gchar*

proxy_lcopy_value (const GValue *value,

		   guint         n_collect_values,

		   GTypeCValue  *collect_values,

		   guint         collect_flags)

{

  gpointer *boxed_p = collect_values[0].v_pointer;

  if (!boxed_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  if (!value->data[0].v_pointer)

    *boxed_p = NULL;

  else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)

    *boxed_p = value->data[0].v_pointer;

  else

    {

      DBusGTypeSpecializedData *data;

      GType type;

      type = G_VALUE_TYPE (value);

      data = lookup_specialization_data (type);

      *boxed_p = data->klass->vtable->copy_func (type, value->data[0].v_pointer);

    }

  return NULL;

}

static char *

build_specialization_name (const char *prefix, guint num_types, const GType *types)

{

  GString *fullname;

  guint i;

  fullname = g_string_new (prefix);

  g_string_append_c (fullname, '_');

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

    {

      if (i!=0)

        g_string_append_c (fullname, '+');

      g_string_append (fullname, g_type_name (types[i]));

    }

  g_string_append_c (fullname, '_');

  return g_string_free (fullname, FALSE);

}

static void

register_container (const char                         *name,

		    DBusGTypeSpecializedType            type,

		    const DBusGTypeSpecializedVtable   *vtable)

{

  DBusGTypeSpecializedContainer *klass;

  klass = g_new0 (DBusGTypeSpecializedContainer, 1);

  klass->type = type;

  klass->vtable = vtable;

  g_hash_table_insert (specialized_containers, g_strdup (name), klass);

}

/**

 * dbus_g_type_register_collection:

 * @name: The name of a new collection container

 * @vtable: the vtable defining the new container

 * @flags: As yet unused.

 *

 * Defines a new collection container.

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

void

dbus_g_type_register_collection (const char                                   *name,

				 const DBusGTypeSpecializedCollectionVtable   *vtable,

				 guint                                         flags)

{

  g_return_if_fail (specialized_types_is_initialized ());

  register_container (name, DBUS_G_SPECTYPE_COLLECTION, (const DBusGTypeSpecializedVtable*) vtable);

}

/**

 * dbus_g_type_register_map:

 * @name: The name of a new map container

 * @vtable: the vtable defining the new container

 * @flags: As yet unused.

 *

 * Defines a new map container.

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

void

dbus_g_type_register_map (const char                            *name,

			  const DBusGTypeSpecializedMapVtable   *vtable,

			  guint                                  flags)

{

  g_return_if_fail (specialized_types_is_initialized ());

  register_container (name, DBUS_G_SPECTYPE_MAP, (const DBusGTypeSpecializedVtable*) vtable);

}

/**

 * dbus_g_type_register_struct:

 * @name: The name of a new struct container

 * @vtable: the vtable defining the new container

 * @flags: As yet unused.

 *

 * Defines a new struct container.

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

void

dbus_g_type_register_struct (const char                             *name,

			     const DBusGTypeSpecializedStructVtable *vtable,

			     guint                                   flags)

{

  g_return_if_fail (specialized_types_is_initialized ());

  register_container (name, DBUS_G_SPECTYPE_STRUCT, (const DBusGTypeSpecializedVtable*) vtable);

}

/**

 * dbus_g_type_map_peek_vtable:

 * @map_type: a gtype of a map specialization

 *

 * Peek the vtable for a given map specialization

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

const DBusGTypeSpecializedMapVtable* dbus_g_type_map_peek_vtable (GType map_type)

{

  DBusGTypeSpecializedData *data;

  g_return_val_if_fail (dbus_g_type_is_map(map_type), NULL);

  data = lookup_specialization_data (map_type);

  g_assert (data != NULL);

  return (DBusGTypeSpecializedMapVtable *)(data->klass->vtable);

}

/**

 * dbus_g_type_collection_peek_vtable:

 * @collection_type: a gtype of a collection specialization

 *

 * Peek the vtable for a given collection specialization

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

const DBusGTypeSpecializedCollectionVtable* dbus_g_type_collection_peek_vtable (GType collection_type)

{

  DBusGTypeSpecializedData *data;

  g_return_val_if_fail (dbus_g_type_is_collection(collection_type), NULL);

  data = lookup_specialization_data (collection_type);

  g_assert (data != NULL);

  return (DBusGTypeSpecializedCollectionVtable *)(data->klass->vtable);

}

/**

 * dbus_g_type_struct_peek_vtable:

 * @collection_type: a gtype of a struct specialization

 *

 * Peek the vtable for a given struct specialization

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

const DBusGTypeSpecializedStructVtable* dbus_g_type_struct_peek_vtable (GType struct_type)

{

  DBusGTypeSpecializedData *data;

  g_return_val_if_fail (dbus_g_type_is_struct (struct_type), NULL);

  data = lookup_specialization_data (struct_type);

  g_assert (data != NULL);

  return (DBusGTypeSpecializedStructVtable *)(data->klass->vtable);

}

static GType

register_specialized_instance (const DBusGTypeSpecializedContainer   *klass,

			       const char                            *name,

			       guint                                  num_types,

			       const GType                           *types)

{

  GType ret;

  static const GTypeValueTable vtable =

    {

      proxy_value_init,

      proxy_value_free,

      proxy_value_copy,

      proxy_value_peek_pointer,

      "p",

      proxy_collect_value,

      "p",

      proxy_lcopy_value,

    };

  static const GTypeInfo derived_info =

    {

      0,		/* class_size */

      NULL,		/* base_init */

      NULL,		/* base_finalize */

      NULL,		/* class_init */

      NULL,		/* class_finalize */

      NULL,		/* class_data */

      0,		/* instance_size */

      0,		/* n_preallocs */

      NULL,		/* instance_init */

      &vtable,		/* value_table */

    };

  ret = g_type_register_static (G_TYPE_BOXED, name, &derived_info, 0);

  /* install proxy functions upon successfull registration */

  if (ret != G_TYPE_INVALID)

    {

      DBusGTypeSpecializedData *data;

      data = g_new0 (DBusGTypeSpecializedData, 1);

      data->num_types = num_types;

      data->types = g_memdup (types, sizeof (GType) * num_types);

      data->klass = klass;

      g_type_set_qdata (ret, specialized_type_data_quark (), data);

    }

  return ret;

}

static GType

lookup_or_register_specialized (const char  *container,

				guint        num_types,

				const GType *types)

{

  GType ret;

  char *name;

  const DBusGTypeSpecializedContainer *klass;

  g_return_val_if_fail (specialized_types_is_initialized (), G_TYPE_INVALID);

  klass = g_hash_table_lookup (specialized_containers, container);

  g_return_val_if_fail (klass != NULL, G_TYPE_INVALID);

  name = build_specialization_name (container, num_types, types);

  ret = g_type_from_name (name);

  if (ret == G_TYPE_INVALID)

    {

      /* Take ownership of name */

      ret = register_specialized_instance (klass, name,

					   num_types,

					   types);

    }

  g_free (name);

  return ret;

}

/**

 * dbus_g_type_get_collection:

 * @container: a string specifying a registered collection type

 * @specialization: #GType of collection elements

 *

 * Gets a #GType for a particular collection instance, 

 * creating the type if not already created.

 *

 * Returns: the #GType of that instance

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

GType

dbus_g_type_get_collection (const char *container,

			    GType specialization)

{

  return lookup_or_register_specialized (container, 1, &specialization);

}

/**

 * dbus_g_type_get_map:

 * @container: a string specifying a registered map type

 * @key_specialization: #GType of keys

 * @value_specialization: #GType of values

 *

 * Gets a #GType for a particular map instance,

 * creating the type if not already created.

 *

 * Returns: the #GType of that instance

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

GType

dbus_g_type_get_map (const char   *container,

		     GType         key_specialization,

		     GType         value_specialization)

{

	GType returnValue = 0;

	#ifdef __SYMBIAN32__

	  GType types[2];

	  types[0] = key_specialization;

	  types[1] = value_specialization;

	  returnValue = lookup_or_register_specialized (container, 2, types);	

	#else