/* json-node.c - JSON object model node

 * 

 * This file is part of JSON-GLib

 * Copyright (C) 2007  OpenedHand Ltd.

 * Copyright (C) 2009  Intel Corp.

 * Copyright (C) 2015  Collabora Ltd.

 *

 * 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.

 *

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

 * License along with this library. If not, see <http://www.gnu.org/licenses/>.

 *

 * Author:

 *   Emmanuele Bassi  <ebassi@linux.intel.com>

 *   Philip Withnall  <philip.withnall@collabora.co.uk>

 */

#include "config.h"

#include <glib.h>

#include "json-types.h"

#include "json-types-private.h"

#include "json-debug.h"

/**

 * SECTION:json-node

 * @short_description: Node in a JSON object model

 *

 * A #JsonNode is a generic container of elements inside a JSON stream.

 * It can contain fundamental types (integers, booleans, floating point

 * numbers, strings) and complex types (arrays and objects).

 *

 * When parsing a JSON data stream you extract the root node and walk

 * the node tree by retrieving the type of data contained inside the

 * node with the %JSON_NODE_TYPE macro. If the node contains a fundamental

 * type you can retrieve a copy of the #GValue holding it with the

 * json_node_get_value() function, and then use the #GValue API to extract

 * the data; if the node contains a complex type you can retrieve the

 * #JsonObject or the #JsonArray using json_node_get_object() or

 * json_node_get_array() respectively, and then retrieve the nodes

 * they contain.

 *

 * A #JsonNode may be marked as immutable using json_node_seal(). This marks the

 * node and all its descendents as read-only, and means that subsequent calls to

 * setter functions (such as json_node_set_array()) on them will abort as a

 * programmer error. By marking a node tree as immutable, it may be referenced

 * in multiple places and its hash value cached for fast lookups, without the

 * possibility of a value deep within the tree changing and affecting hash

 * values. Immutable #JsonNodes may be passed to functions which retain a

 * reference to them without needing to take a copy.

 *

 * #JsonNode supports two types of memory management: alloc/free semantics, and

 * ref/unref semantics. The two may be mixed to a limited extent: nodes may be

 * allocated (which gives them a reference count of 1), referenced zero or more

 * times, unreferenced exactly that number of times (using json_node_unref()),

 * then either unreferenced exactly once more or freed (using json_node_free())

 * to destroy them. json_node_free() must not be used when a node might have a

 * reference count not equal to 1. To this end, json-glib uses json_node_copy()

 * and json_node_unref() internally.

 */

G_DEFINE_BOXED_TYPE (JsonNode, json_node, json_node_copy, json_node_unref);

/**

 * json_node_get_value_type:

 * @node: a #JsonNode

 *

 * Returns the #GType of the payload of the node.

 *

 * Return value: a #GType for the payload.

 *

 * Since: 0.4

 */

GType

json_node_get_value_type (JsonNode *node)

{

  g_return_val_if_fail (node != NULL, G_TYPE_INVALID);

  switch (node->type)

    {

    case JSON_NODE_OBJECT:

      return JSON_TYPE_OBJECT;

    case JSON_NODE_ARRAY:

      return JSON_TYPE_ARRAY;

    case JSON_NODE_NULL:

      return G_TYPE_INVALID;

    case JSON_NODE_VALUE:

      if (node->data.value)

        return JSON_VALUE_TYPE (node->data.value);

      else

        return G_TYPE_INVALID;

    default:

      g_assert_not_reached ();

      return G_TYPE_INVALID;

    }

}

/**

 * json_node_alloc: (constructor)

 *

 * Allocates a new #JsonNode. Use json_node_init() and its variants

 * to initialize the returned value.

 *

 * Return value: (transfer full): the newly allocated #JsonNode. Use

 *   json_node_free() to free the resources allocated by this function

 *

 * Since: 0.16

 */

JsonNode *

json_node_alloc (void)

{

  JsonNode *node = NULL;

  node = g_slice_new0 (JsonNode);

  node->ref_count = 1;

  node->allocated = TRUE;

  return node;

}

static void

json_node_unset (JsonNode *node)

{

  /* Note: Don't use JSON_NODE_IS_VALID here because this may legitimately be

   * called with (node->ref_count == 0) from json_node_unref(). */

  g_assert (node != NULL);

  switch (node->type)

    {

    case JSON_NODE_OBJECT:

      if (node->data.object)

        json_object_unref (node->data.object);

      break;

    case JSON_NODE_ARRAY:

      if (node->data.array)

        json_array_unref (node->data.array);

      break;

    case JSON_NODE_VALUE:

      if (node->data.value)

        json_value_unref (node->data.value);

      break;

    case JSON_NODE_NULL:

      break;

    }

}

/**

 * json_node_init:

 * @node: the #JsonNode to initialize

 * @type: the type of JSON node to initialize @node to

 *

 * Initializes a @node to a specific @type.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init (JsonNode *node,

                JsonNodeType type)

{

  g_return_val_if_fail (type >= JSON_NODE_OBJECT &&

                        type <= JSON_NODE_NULL, NULL);

  g_return_val_if_fail (node->ref_count == 1, NULL);

  json_node_unset (node);

  node->type = type;

  return node;

}

/**

 * json_node_init_object:

 * @node: the #JsonNode to initialize

 * @object: (allow-none): the #JsonObject to initialize @node with, or %NULL

 *

 * Initializes @node to %JSON_NODE_OBJECT and sets @object into it.

 *

 * This function will take a reference on @object.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init_object (JsonNode   *node,

                       JsonObject *object)

{

  g_return_val_if_fail (node != NULL, NULL);

  json_node_init (node, JSON_NODE_OBJECT);

  json_node_set_object (node, object);

  return node;

}

/**

 * json_node_init_array:

 * @node: the #JsonNode to initialize

 * @array: (allow-none): the #JsonArray to initialize @node with, or %NULL

 *

 * Initializes @node to %JSON_NODE_ARRAY and sets @array into it.

 *

 * This function will take a reference on @array.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init_array (JsonNode  *node,

                      JsonArray *array)

{

  g_return_val_if_fail (node != NULL, NULL);

  json_node_init (node, JSON_NODE_ARRAY);

  json_node_set_array (node, array);

  return node;

}

/**

 * json_node_init_int:

 * @node: the #JsonNode to initialize

 * @value: an integer

 *

 * Initializes @node to %JSON_NODE_VALUE and sets @value into it.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init_int (JsonNode *node,

                    gint64    value)

{

  g_return_val_if_fail (node != NULL, NULL);

  json_node_init (node, JSON_NODE_VALUE);

  json_node_set_int (node, value);

  return node;

}

/**

 * json_node_init_double:

 * @node: the #JsonNode to initialize

 * @value: a floating point value

 *

 * Initializes @node to %JSON_NODE_VALUE and sets @value into it.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init_double (JsonNode *node,

                       gdouble   value)

{

  g_return_val_if_fail (node != NULL, NULL);

  json_node_init (node, JSON_NODE_VALUE);

  json_node_set_double (node, value);

  return node;

}

/**

 * json_node_init_boolean:

 * @node: the #JsonNode to initialize

 * @value: a boolean value

 *

 * Initializes @node to %JSON_NODE_VALUE and sets @value into it.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init_boolean (JsonNode *node,

                        gboolean  value)

{

  g_return_val_if_fail (node != NULL, NULL);

  json_node_init (node, JSON_NODE_VALUE);

  json_node_set_boolean (node, value);

  return node;

}

/**

 * json_node_init_string:

 * @node: the #JsonNode to initialize

 * @value: (allow-none): a string value

 *

 * Initializes @node to %JSON_NODE_VALUE and sets @value into it.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init_string (JsonNode   *node,

                       const char *value)

{

  g_return_val_if_fail (node != NULL, NULL);

  json_node_init (node, JSON_NODE_VALUE);

  json_node_set_string (node, value);

  return node;

}

/**

 * json_node_init_null:

 * @node: the #JsonNode to initialize

 *

 * Initializes @node to %JSON_NODE_NULL.

 *

 * If the node has already been initialized once, it will be reset to

 * the given type, and any data contained will be cleared.

 *

 * Return value: (transfer none): the initialized #JsonNode

 *

 * Since: 0.16

 */

JsonNode *

json_node_init_null (JsonNode *node)

{

  g_return_val_if_fail (node != NULL, NULL);

  return json_node_init (node, JSON_NODE_NULL);

}

/**

 * json_node_new: (constructor)

 * @type: a #JsonNodeType

 *

 * Creates a new #JsonNode of @type.

 *

 * This is a convenience function for json_node_alloc() and json_node_init(),

 * and it's the equivalent of:

 *

 * |[

     json_node_init (json_node_alloc (), type);

 * ]|

 *

 * Return value: (transfer full): the newly created #JsonNode

 */

JsonNode *

json_node_new (JsonNodeType type)

{

  g_return_val_if_fail (type >= JSON_NODE_OBJECT &&

                        type <= JSON_NODE_NULL, NULL);

  return json_node_init (json_node_alloc (), type);

}

/**

 * json_node_copy:

 * @node: a #JsonNode

 *

 * Copies @node. If the node contains complex data types, their reference

 * counts are increased, regardless of whether the node is mutable or

 * immutable.

 *

 * The copy will be immutable if, and only if, @node is immutable. However,

 * there should be no need to copy an immutable node.

 *

 * Return value: (transfer full): the copied #JsonNode

 */

JsonNode *

json_node_copy (JsonNode *node)

{

  JsonNode *copy;

  g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL);

  copy = json_node_alloc ();

  copy->type = node->type;

  copy->immutable = node->immutable;

#ifdef JSON_ENABLE_DEBUG

  if (node->immutable)

    {

      JSON_NOTE (NODE, "Copying immutable JsonNode %p of type %s",

                 node,

                 json_node_type_name (node));

    }

#endif

  switch (copy->type)

    {

    case JSON_NODE_OBJECT:

      copy->data.object = json_node_dup_object (node);

      break;

    case JSON_NODE_ARRAY:

      copy->data.array = json_node_dup_array (node);

      break;

    case JSON_NODE_VALUE:

      if (node->data.value)

        copy->data.value = json_value_ref (node->data.value);

      break;

    case JSON_NODE_NULL:

      break;

    default:

      g_assert_not_reached ();

    }

  return copy;

}

/**

 * json_node_ref:

 * @node: a #JsonNode

 *

 * Increment the reference count of @node.

 *

 * Since: 1.2

 * Returns: (transfer full): a pointer to @node

 */

JsonNode *

json_node_ref (JsonNode *node)

{

  g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL);

  g_atomic_int_inc (&node->ref_count);

  return node;

}

/**

 * json_node_unref:

 * @node: (transfer full): a #JsonNode

 *

 * Decrement the reference count of @node. If it reaches zero, the node is

 * freed.

 *

 * Since: 1.2

 */

void

json_node_unref (JsonNode *node)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  if (g_atomic_int_dec_and_test (&node->ref_count))

    {

      json_node_unset (node);

      if (node->allocated)

        g_slice_free (JsonNode, node);

    }

}

/**

 * json_node_set_object:

 * @node: a #JsonNode initialized to %JSON_NODE_OBJECT

 * @object: (nullable): a #JsonObject

 *

 * Sets @objects inside @node. The reference count of @object is increased.

 *

 * If @object is %NULL, the node’s existing object is cleared.

 *

 * It is an error to call this on an immutable node, or on a node which is not

 * an object node.

 */

void

json_node_set_object (JsonNode   *node,

                      JsonObject *object)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  g_return_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_OBJECT);

  g_return_if_fail (!node->immutable);

  if (node->data.object != NULL)

    json_object_unref (node->data.object);

  if (object)

    node->data.object = json_object_ref (object);

  else

    node->data.object = NULL;

}

/**

 * json_node_take_object:

 * @node: a #JsonNode initialized to %JSON_NODE_OBJECT

 * @object: (transfer full): a #JsonObject

 *

 * Sets @object inside @node. The reference count of @object is not increased.

 *

 * It is an error to call this on an immutable node, or on a node which is not

 * an object node.

 */

void

json_node_take_object (JsonNode   *node,

                       JsonObject *object)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  g_return_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_OBJECT);

  g_return_if_fail (!node->immutable);

  if (node->data.object)

    {

      json_object_unref (node->data.object);

      node->data.object = NULL;

    }

  if (object)

    node->data.object = object;

}

/**

 * json_node_get_object:

 * @node: a #JsonNode

 *

 * Retrieves the #JsonObject stored inside a #JsonNode. It is a programmer error

 * to call this on a node which doesn’t hold an object value. Use

 * %JSON_NODE_HOLDS_OBJECT first.

 *

 * Return value: (transfer none) (nullable): the #JsonObject

 */

JsonObject *

json_node_get_object (JsonNode *node)

{

  g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL);

  g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_OBJECT, NULL);

  return node->data.object;

}

/**

 * json_node_dup_object:

 * @node: a #JsonNode

 *

 * Retrieves the #JsonObject inside @node. The reference count of

 * the returned object is increased. It is a programmer error

 * to call this on a node which doesn’t hold an object value. Use

 * %JSON_NODE_HOLDS_OBJECT first.

 *

 * Return value: (transfer full) (nullable): the #JsonObject

 */

JsonObject *

json_node_dup_object (JsonNode *node)

{

  g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL);

  g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_OBJECT, NULL);

  if (node->data.object)

    return json_object_ref (node->data.object);

  return NULL;

}

/**

 * json_node_set_array:

 * @node: a #JsonNode initialized to %JSON_NODE_ARRAY

 * @array: a #JsonArray

 *

 * Sets @array inside @node and increases the #JsonArray reference count.

 *

 * It is an error to call this on an immutable node, or on a node which is not

 * an array node.

 */

void

json_node_set_array (JsonNode  *node,

                     JsonArray *array)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  g_return_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_ARRAY);

  g_return_if_fail (!node->immutable);

  if (node->data.array)

    json_array_unref (node->data.array);

  if (array)

    node->data.array = json_array_ref (array);

  else

    node->data.array = NULL;

}

/**

 * json_node_take_array:

 * @node: a #JsonNode initialized to %JSON_NODE_ARRAY

 * @array: (transfer full): a #JsonArray

 *

 * Sets @array into @node without increasing the #JsonArray reference count.

 *

 * It is an error to call this on an immutable node, or a node which is not

 * an array node.

 */

void

json_node_take_array (JsonNode  *node,

                      JsonArray *array)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  g_return_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_ARRAY);

  g_return_if_fail (!node->immutable);

  if (node->data.array)

    {

      json_array_unref (node->data.array);

      node->data.array = NULL;

    }

  if (array)

    node->data.array = array;

}

/**

 * json_node_get_array:

 * @node: a #JsonNode

 *

 * Retrieves the #JsonArray stored inside a #JsonNode. It is a programmer error

 * to call this on a node which doesn’t hold an array value. Use

 * %JSON_NODE_HOLDS_ARRAY first.

 *

 * Return value: (transfer none) (nullable): the #JsonArray

 */

JsonArray *

json_node_get_array (JsonNode *node)

{

  g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL);

  g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_ARRAY, NULL);

  return node->data.array;

}

/**

 * json_node_dup_array:

 * @node: a #JsonNode

 *

 * Retrieves the #JsonArray stored inside a #JsonNode and returns it

 * with its reference count increased by one. It is a programmer error

 * to call this on a node which doesn’t hold an array value. Use

 * %JSON_NODE_HOLDS_ARRAY first.

 *

 * Return value: (transfer full) (nullable): the #JsonArray with its reference

 *   count increased.

 */

JsonArray *

json_node_dup_array (JsonNode *node)

{

  g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL);

  g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_ARRAY, NULL);

  if (node->data.array)

    return json_array_ref (node->data.array);

  return NULL;

}

/**

 * json_node_get_value:

 * @node: a #JsonNode

 * @value: (out caller-allocates): return location for an uninitialized value

 *

 * Retrieves a value from a #JsonNode and copies into @value. When done

 * using it, call g_value_unset() on the #GValue. It is a programmer error

 * to call this on a node which doesn’t hold a scalar value. Use

 * %JSON_NODE_HOLDS_VALUE first.

 */

void

json_node_get_value (JsonNode *node,

                     GValue   *value)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  g_return_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE);

  if (node->data.value)

    {

      g_value_init (value, JSON_VALUE_TYPE (node->data.value));

      switch (JSON_VALUE_TYPE (node->data.value))

        {

        case G_TYPE_INT64:

          g_value_set_int64 (value, json_value_get_int (node->data.value));

          break;

        case G_TYPE_DOUBLE:

          g_value_set_double (value, json_value_get_double (node->data.value));

          break;

        case G_TYPE_BOOLEAN:

          g_value_set_boolean (value, json_value_get_boolean (node->data.value));

          break;

        case G_TYPE_STRING:

          g_value_set_string (value, json_value_get_string (node->data.value));

          break;

        default:

          break;

        }

    }

}

/**

 * json_node_set_value:

 * @node: a #JsonNode initialized to %JSON_NODE_VALUE

 * @value: the #GValue to set

 *

 * Sets @value inside @node. The passed #GValue is copied into the #JsonNode.

 *

 * It is an error to call this on an immutable node, or on a node which is not

 * a value node.

 */

void

json_node_set_value (JsonNode     *node,

                     const GValue *value)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  g_return_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE);

  g_return_if_fail (G_VALUE_TYPE (value) != G_TYPE_INVALID);

  g_return_if_fail (!node->immutable);

  if (node->data.value == NULL)

    node->data.value = json_value_alloc ();

  switch (G_VALUE_TYPE (value))

    {

    /* auto-promote machine integers to 64 bit integers */

    case G_TYPE_INT64:

    case G_TYPE_INT:

      json_value_init (node->data.value, JSON_VALUE_INT);

      if (G_VALUE_TYPE (value) == G_TYPE_INT64)

        json_value_set_int (node->data.value, g_value_get_int64 (value));

      else

        json_value_set_int (node->data.value, g_value_get_int (value));

      break;

    case G_TYPE_BOOLEAN:

      json_value_init (node->data.value, JSON_VALUE_BOOLEAN);

      json_value_set_boolean (node->data.value, g_value_get_boolean (value));

      break;

    /* auto-promote single-precision floats to double precision floats */

    case G_TYPE_DOUBLE:

    case G_TYPE_FLOAT:

      json_value_init (node->data.value, JSON_VALUE_DOUBLE);

      if (G_VALUE_TYPE (value) == G_TYPE_DOUBLE)

        json_value_set_double (node->data.value, g_value_get_double (value));

      else

        json_value_set_double (node->data.value, g_value_get_float (value));

      break;

    case G_TYPE_STRING:

      json_value_init (node->data.value, JSON_VALUE_STRING);

      json_value_set_string (node->data.value, g_value_get_string (value));

      break;

    default:

      g_message ("Invalid value of type '%s'",

                 g_type_name (G_VALUE_TYPE (value)));

      return;

    }

}

/**

 * json_node_free:

 * @node: a #JsonNode

 *

 * Frees the resources allocated by @node.

 */

void

json_node_free (JsonNode *node)

{

  g_return_if_fail (node == NULL || JSON_NODE_IS_VALID (node));

  g_return_if_fail (node == NULL || node->allocated);

  if (G_LIKELY (node))

    {

      if (node->ref_count > 1)

        g_warning ("Freeing a JsonNode %p owned by other code.", node);

      json_node_unset (node);

      g_slice_free (JsonNode, node);

    }

}

/**

 * json_node_seal:

 * @node: a #JsonNode

 *

 * Seals the #JsonNode, making it immutable to further changes. In order to be

 * sealed, the @node must have a type and value set. The value will be

 * recursively sealed — if the node holds an object, that #JsonObject will be

 * sealed, etc.

 *

 * If the @node is already immutable, this is a no-op.

 *

 * Since: 1.2

 */

void

json_node_seal (JsonNode *node)

{

  g_return_if_fail (JSON_NODE_IS_VALID (node));

  if (node->immutable)

    return;

  switch (node->type)

    {

    case JSON_NODE_OBJECT:

      g_return_if_fail (node->data.object != NULL);

      json_object_seal (node->data.object);

      break;

    case JSON_NODE_ARRAY:

      g_return_if_fail (node->data.array != NULL);

      json_array_seal (node->data.array);

      break;

    case JSON_NODE_NULL:

      break;

    case JSON_NODE_VALUE:

      g_return_if_fail (node->data.value != NULL);

      json_value_seal (node->data.value);

      break;

    default:

      g_assert_not_reached ();

    }

  node->immutable = TRUE;

}

/**

 * json_node_is_immutable:

 * @node: a #JsonNode

 *

 * Check whether the given @node has been marked as immutable by calling

 * json_node_seal() on it.

 *

 * Since: 1.2

 * Returns: %TRUE if the @node is immutable

 */

gboolean

json_node_is_immutable (JsonNode *node)

{

  g_return_val_if_fail (JSON_NODE_IS_VALID (node), FALSE);

  return node->immutable;