/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
+ * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>
*
* Jansson is free software; you can redistribute it and/or modify
* it under the terms of the MIT license. See LICENSE for details.
#include "utf.h"
#include "util.h"
-#define container_of(ptr_, type_, member_) \
- ((type_ *)((char *)ptr_ - (size_t)&((type_ *)0)->member_))
-
-typedef struct {
- json_t json;
- hashtable_t hashtable;
-} json_object_t;
-
-typedef struct {
- json_t json;
- unsigned int size;
- unsigned int entries;
- json_t **table;
-} json_array_t;
-
-typedef struct {
- json_t json;
- char *value;
-} json_string_t;
-
-typedef struct {
- json_t json;
- double value;
-} json_real_t;
-
-typedef struct {
- json_t json;
- int value;
-} json_integer_t;
-
-#define json_to_object(json_) container_of(json_, json_object_t, json)
-#define json_to_array(json_) container_of(json_, json_array_t, json)
-#define json_to_string(json_) container_of(json_, json_string_t, json)
-#define json_to_real(json_) container_of(json_, json_real_t, json)
-#define json_to_integer(json_) container_of(json_, json_integer_t, json)
static inline void json_init(json_t *json, json_type type)
{
free(object);
return NULL;
}
+
+ object->visited = 0;
+
return &object->json;
}
if(!key || !value)
return -1;
- if(!json_is_object(json))
+ if(!json_is_object(json) || json == value)
{
json_decref(value);
return -1;
return 0;
}
-int json_object_set_nocheck(json_t *json, const char *key, json_t *value)
-{
- return json_object_set_new_nocheck(json, key, json_incref(value));
-}
-
int json_object_set_new(json_t *json, const char *key, json_t *value)
{
if(!key || !utf8_check_string(key, -1))
key = json_object_iter_key(iter);
value = json_object_iter_value(iter);
- if(json_object_set(object, key, value))
+ if(json_object_set_nocheck(object, key, value))
return -1;
iter = json_object_iter_next(other, iter);
return (json_t *)hashtable_iter_value(iter);
}
+static int json_object_equal(json_t *object1, json_t *object2)
+{
+ void *iter;
+
+ if(json_object_size(object1) != json_object_size(object2))
+ return 0;
+
+ iter = json_object_iter(object1);
+ while(iter)
+ {
+ const char *key;
+ json_t *value1, *value2;
+
+ key = json_object_iter_key(iter);
+ value1 = json_object_iter_value(iter);
+ value2 = json_object_get(object2, key);
+
+ if(!json_equal(value1, value2))
+ return 0;
+
+ iter = json_object_iter_next(object1, iter);
+ }
+
+ return 1;
+}
+
+static json_t *json_object_copy(json_t *object)
+{
+ json_t *result;
+ void *iter;
+
+ result = json_object();
+ if(!result)
+ return NULL;
+
+ iter = json_object_iter(object);
+ while(iter)
+ {
+ const char *key;
+ json_t *value;
+
+ key = json_object_iter_key(iter);
+ value = json_object_iter_value(iter);
+ json_object_set_nocheck(result, key, value);
+
+ iter = json_object_iter_next(object, iter);
+ }
+
+ return result;
+}
+
+static json_t *json_object_deep_copy(json_t *object)
+{
+ json_t *result;
+ void *iter;
+
+ result = json_object();
+ if(!result)
+ return NULL;
+
+ iter = json_object_iter(object);
+ while(iter)
+ {
+ const char *key;
+ json_t *value;
+
+ key = json_object_iter_key(iter);
+ value = json_object_iter_value(iter);
+ json_object_set_new_nocheck(result, key, json_deep_copy(value));
+
+ iter = json_object_iter_next(object, iter);
+ }
+
+ return result;
+}
+
/*** array ***/
{
json_array_t *array = malloc(sizeof(json_array_t));
if(!array)
- return NULL;
+ return NULL;
json_init(&array->json, JSON_ARRAY);
array->entries = 0;
return NULL;
}
+ array->visited = 0;
+
return &array->json;
}
if(!value)
return -1;
- if(!json_is_array(json))
+ if(!json_is_array(json) || json == value)
{
json_decref(value);
return -1;
if(!value)
return -1;
- if(!json_is_array(json))
+ if(!json_is_array(json) || json == value)
{
json_decref(value);
return -1;
if(!value)
return -1;
- if(!json_is_array(json)) {
+ if(!json_is_array(json) || json == value) {
json_decref(value);
return -1;
}
return 0;
}
+static int json_array_equal(json_t *array1, json_t *array2)
+{
+ unsigned int i, size;
+
+ size = json_array_size(array1);
+ if(size != json_array_size(array2))
+ return 0;
+
+ for(i = 0; i < size; i++)
+ {
+ json_t *value1, *value2;
+
+ value1 = json_array_get(array1, i);
+ value2 = json_array_get(array2, i);
+
+ if(!json_equal(value1, value2))
+ return 0;
+ }
+
+ return 1;
+}
+
+static json_t *json_array_copy(json_t *array)
+{
+ json_t *result;
+ unsigned int i;
+
+ result = json_array();
+ if(!result)
+ return NULL;
+
+ for(i = 0; i < json_array_size(array); i++)
+ json_array_append(result, json_array_get(array, i));
+
+ return result;
+}
+
+static json_t *json_array_deep_copy(json_t *array)
+{
+ json_t *result;
+ unsigned int i;
+
+ result = json_array();
+ if(!result)
+ return NULL;
+
+ for(i = 0; i < json_array_size(array); i++)
+ json_array_append_new(result, json_deep_copy(json_array_get(array, i)));
+
+ return result;
+}
/*** string ***/
string = malloc(sizeof(json_string_t));
if(!string)
- return NULL;
+ return NULL;
json_init(&string->json, JSON_STRING);
string->value = strdup(value);
return json_to_string(json)->value;
}
-int json_string_set(const json_t *json, const char *value)
+int json_string_set_nocheck(json_t *json, const char *value)
{
char *dup;
json_string_t *string;
- if(!json_is_string(json) || !value || !utf8_check_string(value, -1))
- return -1;
-
dup = strdup(value);
if(!dup)
return -1;
return 0;
}
+int json_string_set(json_t *json, const char *value)
+{
+ if(!value || !utf8_check_string(value, -1))
+ return -1;
+
+ return json_string_set_nocheck(json, value);
+}
+
static void json_delete_string(json_string_t *string)
{
free(string->value);
free(string);
}
+static int json_string_equal(json_t *string1, json_t *string2)
+{
+ return strcmp(json_string_value(string1), json_string_value(string2)) == 0;
+}
+
+static json_t *json_string_copy(json_t *string)
+{
+ return json_string_nocheck(json_string_value(string));
+}
+
/*** integer ***/
{
json_integer_t *integer = malloc(sizeof(json_integer_t));
if(!integer)
- return NULL;
+ return NULL;
json_init(&integer->json, JSON_INTEGER);
integer->value = value;
return json_to_integer(json)->value;
}
-int json_integer_set(const json_t *json, int value)
+int json_integer_set(json_t *json, int value)
{
if(!json_is_integer(json))
return -1;
free(integer);
}
+static int json_integer_equal(json_t *integer1, json_t *integer2)
+{
+ return json_integer_value(integer1) == json_integer_value(integer2);
+}
+
+static json_t *json_integer_copy(json_t *integer)
+{
+ return json_integer(json_integer_value(integer));
+}
+
/*** real ***/
{
json_real_t *real = malloc(sizeof(json_real_t));
if(!real)
- return NULL;
+ return NULL;
json_init(&real->json, JSON_REAL);
real->value = value;
return json_to_real(json)->value;
}
-int json_real_set(const json_t *json, double value)
+int json_real_set(json_t *json, double value)
{
if(!json_is_real(json))
return 0;
free(real);
}
+static int json_real_equal(json_t *real1, json_t *real2)
+{
+ return json_real_value(real1) == json_real_value(real2);
+}
+
+static json_t *json_real_copy(json_t *real)
+{
+ return json_real(json_real_value(real));
+}
+
/*** number ***/
/* json_delete is not called for true, false or null */
}
+
+
+/*** equality ***/
+
+int json_equal(json_t *json1, json_t *json2)
+{
+ if(!json1 || !json2)
+ return 0;
+
+ if(json_typeof(json1) != json_typeof(json2))
+ return 0;
+
+ /* this covers true, false and null as they are singletons */
+ if(json1 == json2)
+ return 1;
+
+ if(json_is_object(json1))
+ return json_object_equal(json1, json2);
+
+ if(json_is_array(json1))
+ return json_array_equal(json1, json2);
+
+ if(json_is_string(json1))
+ return json_string_equal(json1, json2);
+
+ if(json_is_integer(json1))
+ return json_integer_equal(json1, json2);
+
+ if(json_is_real(json1))
+ return json_real_equal(json1, json2);
+
+ return 0;
+}
+
+
+/*** copying ***/
+
+json_t *json_copy(json_t *json)
+{
+ if(!json)
+ return NULL;
+
+ if(json_is_object(json))
+ return json_object_copy(json);
+
+ if(json_is_array(json))
+ return json_array_copy(json);
+
+ if(json_is_string(json))
+ return json_string_copy(json);
+
+ if(json_is_integer(json))
+ return json_integer_copy(json);
+
+ if(json_is_real(json))
+ return json_real_copy(json);
+
+ if(json_is_true(json) || json_is_false(json) || json_is_null(json))
+ return json;
+
+ return NULL;
+}
+
+json_t *json_deep_copy(json_t *json)
+{
+ if(!json)
+ return NULL;
+
+ if(json_is_object(json))
+ return json_object_deep_copy(json);
+
+ if(json_is_array(json))
+ return json_array_deep_copy(json);
+
+ /* for the rest of the types, deep copying doesn't differ from
+ shallow copying */
+
+ if(json_is_string(json))
+ return json_string_copy(json);
+
+ if(json_is_integer(json))
+ return json_integer_copy(json);
+
+ if(json_is_real(json))
+ return json_real_copy(json);
+
+ if(json_is_true(json) || json_is_false(json) || json_is_null(json))
+ return json;
+
+ return NULL;
+}