X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=src%2Fvalue.c;h=3788cb154751dc21bb1d010bd7df31dd5f318179;hb=047a1417fb4f09f995eb2671ee52253f7f1e1e76;hp=1982b90077f43f178a9f951280d3d408ad4597d0;hpb=4cd777712b1e4ec17dc9efcced80a90f83ec1915;p=jansson.git diff --git a/src/value.c b/src/value.c index 1982b90..3788cb1 100644 --- a/src/value.c +++ b/src/value.c @@ -1,11 +1,14 @@ /* - * Copyright (c) 2009 Petri Lehtinen + * Copyright (c) 2009, 2010 Petri Lehtinen * * Jansson is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See LICENSE for details. */ #define _GNU_SOURCE + +#include + #include #include @@ -120,11 +123,6 @@ int json_object_set_new_nocheck(json_t *json, const char *key, json_t *value) 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)) @@ -175,7 +173,7 @@ int json_object_update(json_t *object, json_t *other) 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); @@ -222,6 +220,82 @@ json_t *json_object_iter_value(void *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 ***/ @@ -229,7 +303,7 @@ json_t *json_array(void) { json_array_t *array = malloc(sizeof(json_array_t)); if(!array) - return NULL; + return NULL; json_init(&array->json, JSON_ARRAY); array->entries = 0; @@ -468,6 +542,57 @@ int json_array_extend(json_t *json, json_t *other_json) 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 ***/ @@ -480,7 +605,7 @@ json_t *json_string_nocheck(const char *value) string = malloc(sizeof(json_string_t)); if(!string) - return NULL; + return NULL; json_init(&string->json, JSON_STRING); string->value = strdup(value); @@ -508,14 +633,11 @@ const char *json_string_value(const json_t *json) 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; @@ -527,12 +649,30 @@ int json_string_set(const json_t *json, const char *value) 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 ***/ @@ -540,7 +680,7 @@ json_t *json_integer(int value) { json_integer_t *integer = malloc(sizeof(json_integer_t)); if(!integer) - return NULL; + return NULL; json_init(&integer->json, JSON_INTEGER); integer->value = value; @@ -555,7 +695,7 @@ int json_integer_value(const json_t *json) 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; @@ -570,6 +710,16 @@ static void json_delete_integer(json_integer_t *integer) 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 ***/ @@ -577,7 +727,7 @@ json_t *json_real(double value) { json_real_t *real = malloc(sizeof(json_real_t)); if(!real) - return NULL; + return NULL; json_init(&real->json, JSON_REAL); real->value = value; @@ -592,7 +742,7 @@ double json_real_value(const json_t *json) 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; @@ -607,6 +757,16 @@ static void json_delete_real(json_real_t *real) 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 ***/ @@ -627,7 +787,7 @@ json_t *json_true(void) { static json_t the_true = { .type = JSON_TRUE, - .refcount = (unsigned int)1 + .refcount = (unsigned int)-1 }; return &the_true; } @@ -637,7 +797,7 @@ json_t *json_false(void) { static json_t the_false = { .type = JSON_FALSE, - .refcount = (unsigned int)1 + .refcount = (unsigned int)-1 }; return &the_false; } @@ -647,7 +807,7 @@ json_t *json_null(void) { static json_t the_null = { .type = JSON_NULL, - .refcount = (unsigned int)1 + .refcount = (unsigned int)-1 }; return &the_null; } @@ -674,3 +834,94 @@ void json_delete(json_t *json) /* 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; +}