json-glib-1.6.2/json-glib/json-gboxed.c

/* json-gboxed.c - JSON GBoxed integration
 *
 * This file is part of JSON-GLib
 *
 * Copyright (C) 2007  OpenedHand Ltd.
 * Copyright (C) 2009  Intel Corp.
 *
 * 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.1 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.
 *
 * Author:
 *   Emmanuele Bassi  <ebassi@linux.intel.com>
 */

/**
 * SECTION:json-gboxed
 * @short_description: Serialize and deserialize GBoxed types
 *
 * GLib's #GBoxed type is a generic wrapper for arbitrary C structures.
 *
 * JSON-GLib allows serialization and deserialization of a #GBoxed type
 * by registering functions mapping a #JsonNodeType to a specific
 * #GType.
 *
 * When registering a #GBoxed type you should also register the
 * corresponding transformation functions, e.g.:
 *
 * |[<!-- language="C" -->
 *   GType
 *   my_struct_get_type (void)
 *   {
 *     static GType boxed_type = 0;
 *
 *     if (boxed_type == 0)
 *       {
 *         boxed_type =
 *           g_boxed_type_register_static (g_intern_static_string ("MyStruct"),
 *                                         (GBoxedCopyFunc) my_struct_copy,
 *                                         (GBoxedFreeFunc) my_struct_free);
 *
 *         json_boxed_register_serialize_func (boxed_type, JSON_NODE_OBJECT,
 *                                             my_struct_serialize);
 *         json_boxed_register_deserialize_func (boxed_type, JSON_NODE_OBJECT,
 *                                               my_struct_deserialize);
 *       }
 *
 *     return boxed_type;
 *   }
 * ]|
 *
 * The serialization function will be invoked by json_boxed_serialize():
 * it will be passed a pointer to the C structure and it must return a
 * #JsonNode. The deserialization function will be invoked by
 * json_boxed_deserialize(): it will be passed a #JsonNode for the
 * declared type and it must return a newly allocated C structure.
 *
 * It is possible to check whether a #GBoxed type can be deserialized
 * from a specific #JsonNodeType, and whether a #GBoxed can be serialized
 * and to which specific #JsonNodeType.
 */

#include "config.h"

#include <string.h>
#include <stdlib.h>

#include "json-types-private.h"
#include "json-gobject.h"

typedef struct _BoxedTransform  BoxedTransform;

struct _BoxedTransform
{
  GType boxed_type;
  gint node_type;

  JsonBoxedSerializeFunc serialize;
  JsonBoxedDeserializeFunc deserialize;
};

G_LOCK_DEFINE_STATIC (boxed_serialize);
static GSList *boxed_serialize = NULL;

G_LOCK_DEFINE_STATIC (boxed_deserialize);
static GSList *boxed_deserialize = NULL;

static gint
boxed_transforms_cmp (gconstpointer a,
                      gconstpointer b)
{
  const BoxedTransform *ta = a;
  const BoxedTransform *tb = b;

  return tb->boxed_type - ta->boxed_type;
}

static gint
boxed_transforms_find (gconstpointer a,
                       gconstpointer b)
{
  const BoxedTransform *haystack = a;
  const BoxedTransform *needle = b;

  if (needle->node_type != -1)
    return (haystack->boxed_type == needle->boxed_type &&
            haystack->node_type == needle->node_type) ? 0 : 1;
  else
    return (haystack->boxed_type == needle->boxed_type) ? 0 : 1;
}

static BoxedTransform *
lookup_boxed_transform (GSList       *transforms,
                        GType         gboxed_type,
                        JsonNodeType  node_type)
{
  BoxedTransform lookup;
  GSList *t;

  lookup.boxed_type = gboxed_type;
  lookup.node_type = node_type;

  t = g_slist_find_custom (transforms, &lookup, boxed_transforms_find);
  if (t == NULL)
    return NULL;

  return t->data;
}

/**
 * json_boxed_register_serialize_func: (skip)
 * @gboxed_type: a boxed type
 * @node_type: a node type
 * @serialize_func: serialization function for @boxed_type into
 *   a #JsonNode of type @node_type
 *
 * Registers a serialization function for a #GBoxed of type @gboxed_type
 * to a #JsonNode of type @node_type
 *
 * Since: 0.10
 */
void
json_boxed_register_serialize_func (GType                  gboxed_type,
                                    JsonNodeType           node_type,
                                    JsonBoxedSerializeFunc serialize_func)
{
  BoxedTransform *t;

  g_return_if_fail (G_TYPE_IS_BOXED (gboxed_type));
  g_return_if_fail (G_TYPE_IS_ABSTRACT (gboxed_type) == FALSE);

  G_LOCK (boxed_serialize);

  t = lookup_boxed_transform (boxed_serialize, gboxed_type, node_type);
  if (t == NULL)
    {
      t = g_slice_new (BoxedTransform);

      t->boxed_type = gboxed_type;
      t->node_type = node_type;
      t->serialize = serialize_func;

      boxed_serialize = g_slist_insert_sorted (boxed_serialize, t,
                                               boxed_transforms_cmp);
    }
  else
    g_warning ("A serialization function for the boxed type %s into "
               "JSON nodes of type %s already exists",
               g_type_name (gboxed_type),
               json_node_type_get_name (node_type));

  G_UNLOCK (boxed_serialize);
}

/**
 * json_boxed_register_deserialize_func: (skip)
 * @gboxed_type: a boxed type
 * @node_type: a node type
 * @deserialize_func: deserialization function for @boxed_type from
 *   a #JsonNode of type @node_type
 *
 * Registers a deserialization function for a #GBoxed of type @gboxed_type
 * from a #JsonNode of type @node_type
 *
 * Since: 0.10
 */
void
json_boxed_register_deserialize_func (GType                    gboxed_type,
                                      JsonNodeType             node_type,
                                      JsonBoxedDeserializeFunc deserialize_func)
{
  BoxedTransform *t;

  g_return_if_fail (G_TYPE_IS_BOXED (gboxed_type));
  g_return_if_fail (G_TYPE_IS_ABSTRACT (gboxed_type) == FALSE);

  G_LOCK (boxed_deserialize);

  t = lookup_boxed_transform (boxed_deserialize, gboxed_type, node_type);
  if (t == NULL)
    {
      t = g_slice_new (BoxedTransform);

      t->boxed_type = gboxed_type;
      t->node_type = node_type;
      t->deserialize = deserialize_func;

      boxed_deserialize = g_slist_insert_sorted (boxed_deserialize, t,
                                                 boxed_transforms_cmp);
    }
  else
    g_warning ("A deserialization function for the boxed type %s from "
               "JSON nodes of type %s already exists",
               g_type_name (gboxed_type),
               json_node_type_get_name (node_type));

  G_UNLOCK (boxed_deserialize);
}

/**
 * json_boxed_can_serialize:
 * @gboxed_type: a boxed type
 * @node_type: (out): the #JsonNode type to which the boxed type can be
 *   serialized into
 *
 * Checks whether it is possible to serialize a #GBoxed of
 * type @gboxed_type into a #JsonNode. The type of the
 * #JsonNode is placed inside @node_type if the function
 * returns %TRUE and it's undefined otherwise.
 *
 * Return value: %TRUE if the type can be serialized,
 *   and %FALSE otherwise.
 *
 * Since: 0.10
 */
gboolean
json_boxed_can_serialize (GType         gboxed_type,
                          JsonNodeType *node_type)
{
  BoxedTransform *t;

  g_return_val_if_fail (G_TYPE_IS_BOXED (gboxed_type), FALSE);
  g_return_val_if_fail (G_TYPE_IS_ABSTRACT (gboxed_type) == FALSE, FALSE);

  t = lookup_boxed_transform (boxed_serialize, gboxed_type, -1);
  if (t != NULL)
    {
      if (node_type)
        *node_type = t->node_type;

      return TRUE;
    }

  return FALSE;
}

/**
 * json_boxed_can_deserialize:
 * @gboxed_type: a boxed type
 * @node_type: a #JsonNode type
 *
 * Checks whether it is possible to deserialize a #GBoxed of
 * type @gboxed_type from a #JsonNode of type @node_type
 *
 * Return value: %TRUE if the type can be deserialized, %FALSE otherwise
 *
 * Since: 0.10
 */
gboolean
json_boxed_can_deserialize (GType        gboxed_type,
                            JsonNodeType node_type)
{
  BoxedTransform *t;

  g_return_val_if_fail (G_TYPE_IS_BOXED (gboxed_type), FALSE);
  g_return_val_if_fail (G_TYPE_IS_ABSTRACT (gboxed_type) == FALSE, FALSE);

  t = lookup_boxed_transform (boxed_deserialize, gboxed_type, node_type);
  if (t != NULL)
    return TRUE;

  return FALSE;
}

/**
 * json_boxed_serialize:
 * @gboxed_type: a boxed type
 * @boxed: a pointer to a #GBoxed of type @gboxed_type
 *
 * Serializes @boxed, a pointer to a #GBoxed of type @gboxed_type,
 * into a #JsonNode
 *
 * Return value: (nullable) (transfer full): a #JsonNode with the serialization of
 *   the boxed type, or %NULL if serialization either failed or was not possible
 *
 * Since: 0.10
 */
JsonNode *
json_boxed_serialize (GType         gboxed_type,
                      gconstpointer boxed)
{
  BoxedTransform *t;

  g_return_val_if_fail (G_TYPE_IS_BOXED (gboxed_type), NULL);
  g_return_val_if_fail (G_TYPE_IS_ABSTRACT (gboxed_type) == FALSE, NULL);
  g_return_val_if_fail (boxed != NULL, NULL);

  t = lookup_boxed_transform (boxed_serialize, gboxed_type, -1);
  if (t != NULL && t->serialize != NULL)
    return t->serialize (boxed);

  return NULL;
}

/**
 * json_boxed_deserialize:
 * @gboxed_type: a boxed type
 * @node: a #JsonNode
 *
 * Deserializes @node into a #GBoxed of @gboxed_type
 *
 * Return value: (transfer full): the newly allocated #GBoxed. Use
 *   g_boxed_free() to release the resources allocated by this
 *   function
 *
 * Since: 0.10
 */
gpointer
json_boxed_deserialize (GType     gboxed_type,
                        JsonNode *node)
{
  JsonNodeType node_type;
  BoxedTransform *t;

  g_return_val_if_fail (G_TYPE_IS_BOXED (gboxed_type), NULL);
  g_return_val_if_fail (G_TYPE_IS_ABSTRACT (gboxed_type) == FALSE, NULL);
  g_return_val_if_fail (node != NULL, NULL);

  node_type = json_node_get_node_type (node);

  t = lookup_boxed_transform (boxed_deserialize, gboxed_type, node_type);
  if (t != NULL && t->deserialize != NULL)
    return t->deserialize (node);

  return NULL;
}