LCOV - code coverage report
Current view: top level - home/dup/local/include - jansson.h (source / functions) Hit Total Coverage
Test: coverage-client.info Lines: 4 4 100.0 %
Date: 2016-02-03 22:31:46 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2009-2014 Petri Lehtinen <petri@digip.org>
       3             :  *
       4             :  * Jansson is free software; you can redistribute it and/or modify
       5             :  * it under the terms of the MIT license. See LICENSE for details.
       6             :  */
       7             : 
       8             : #ifndef JANSSON_H
       9             : #define JANSSON_H
      10             : 
      11             : #include <stdio.h>
      12             : #include <stdlib.h>  /* for size_t */
      13             : #include <stdarg.h>
      14             : 
      15             : #include "jansson_config.h"
      16             : 
      17             : #ifdef __cplusplus
      18             : extern "C" {
      19             : #endif
      20             : 
      21             : /* version */
      22             : 
      23             : #define JANSSON_MAJOR_VERSION  2
      24             : #define JANSSON_MINOR_VERSION  7
      25             : #define JANSSON_MICRO_VERSION  0
      26             : 
      27             : /* Micro version is omitted if it's 0 */
      28             : #define JANSSON_VERSION  "2.7"
      29             : 
      30             : /* Version as a 3-byte hex number, e.g. 0x010201 == 1.2.1. Use this
      31             :    for numeric comparisons, e.g. #if JANSSON_VERSION_HEX >= ... */
      32             : #define JANSSON_VERSION_HEX  ((JANSSON_MAJOR_VERSION << 16) |   \
      33             :                               (JANSSON_MINOR_VERSION << 8)  |   \
      34             :                               (JANSSON_MICRO_VERSION << 0))
      35             : 
      36             : 
      37             : /* types */
      38             : 
      39             : typedef enum {
      40             :     JSON_OBJECT,
      41             :     JSON_ARRAY,
      42             :     JSON_STRING,
      43             :     JSON_INTEGER,
      44             :     JSON_REAL,
      45             :     JSON_TRUE,
      46             :     JSON_FALSE,
      47             :     JSON_NULL
      48             : } json_type;
      49             : 
      50             : typedef struct json_t {
      51             :     json_type type;
      52             :     size_t refcount;
      53             : } json_t;
      54             : 
      55             : #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
      56             : #if JSON_INTEGER_IS_LONG_LONG
      57             : #ifdef _WIN32
      58             : #define JSON_INTEGER_FORMAT "I64d"
      59             : #else
      60             : #define JSON_INTEGER_FORMAT "lld"
      61             : #endif
      62             : typedef long long json_int_t;
      63             : #else
      64             : #define JSON_INTEGER_FORMAT "ld"
      65             : typedef long json_int_t;
      66             : #endif /* JSON_INTEGER_IS_LONG_LONG */
      67             : #endif
      68             : 
      69             : #define json_typeof(json)      ((json)->type)
      70             : #define json_is_object(json)   ((json) && json_typeof(json) == JSON_OBJECT)
      71             : #define json_is_array(json)    ((json) && json_typeof(json) == JSON_ARRAY)
      72             : #define json_is_string(json)   ((json) && json_typeof(json) == JSON_STRING)
      73             : #define json_is_integer(json)  ((json) && json_typeof(json) == JSON_INTEGER)
      74             : #define json_is_real(json)     ((json) && json_typeof(json) == JSON_REAL)
      75             : #define json_is_number(json)   (json_is_integer(json) || json_is_real(json))
      76             : #define json_is_true(json)     ((json) && json_typeof(json) == JSON_TRUE)
      77             : #define json_is_false(json)    ((json) && json_typeof(json) == JSON_FALSE)
      78             : #define json_boolean_value     json_is_true
      79             : #define json_is_boolean(json)  (json_is_true(json) || json_is_false(json))
      80             : #define json_is_null(json)     ((json) && json_typeof(json) == JSON_NULL)
      81             : 
      82             : /* construction, destruction, reference counting */
      83             : 
      84             : json_t *json_object(void);
      85             : json_t *json_array(void);
      86             : json_t *json_string(const char *value);
      87             : json_t *json_stringn(const char *value, size_t len);
      88             : json_t *json_string_nocheck(const char *value);
      89             : json_t *json_stringn_nocheck(const char *value, size_t len);
      90             : json_t *json_integer(json_int_t value);
      91             : json_t *json_real(double value);
      92             : json_t *json_true(void);
      93             : json_t *json_false(void);
      94             : #define json_boolean(val)      ((val) ? json_true() : json_false())
      95             : json_t *json_null(void);
      96             : 
      97             : static JSON_INLINE
      98             : json_t *json_incref(json_t *json)
      99             : {
     100             :     if(json && json->refcount != (size_t)-1)
     101             :         ++json->refcount;
     102             :     return json;
     103             : }
     104             : 
     105             : /* do not call json_delete directly */
     106             : void json_delete(json_t *json);
     107             : 
     108             : static JSON_INLINE
     109       93948 : void json_decref(json_t *json)
     110             : {
     111       93948 :     if(json && json->refcount != (size_t)-1 && --json->refcount == 0)
     112       93948 :         json_delete(json);
     113       93948 : }
     114             : 
     115             : 
     116             : /* error reporting */
     117             : 
     118             : #define JSON_ERROR_TEXT_LENGTH    160
     119             : #define JSON_ERROR_SOURCE_LENGTH   80
     120             : 
     121             : typedef struct {
     122             :     int line;
     123             :     int column;
     124             :     int position;
     125             :     char source[JSON_ERROR_SOURCE_LENGTH];
     126             :     char text[JSON_ERROR_TEXT_LENGTH];
     127             : } json_error_t;
     128             : 
     129             : 
     130             : /* getters, setters, manipulation */
     131             : 
     132             : void json_object_seed(size_t seed);
     133             : size_t json_object_size(const json_t *object);
     134             : json_t *json_object_get(const json_t *object, const char *key);
     135             : int json_object_set_new(json_t *object, const char *key, json_t *value);
     136             : int json_object_set_new_nocheck(json_t *object, const char *key, json_t *value);
     137             : int json_object_del(json_t *object, const char *key);
     138             : int json_object_clear(json_t *object);
     139             : int json_object_update(json_t *object, json_t *other);
     140             : int json_object_update_existing(json_t *object, json_t *other);
     141             : int json_object_update_missing(json_t *object, json_t *other);
     142             : void *json_object_iter(json_t *object);
     143             : void *json_object_iter_at(json_t *object, const char *key);
     144             : void *json_object_key_to_iter(const char *key);
     145             : void *json_object_iter_next(json_t *object, void *iter);
     146             : const char *json_object_iter_key(void *iter);
     147             : json_t *json_object_iter_value(void *iter);
     148             : int json_object_iter_set_new(json_t *object, void *iter, json_t *value);
     149             : 
     150             : #define json_object_foreach(object, key, value) \
     151             :     for(key = json_object_iter_key(json_object_iter(object)); \
     152             :         key && (value = json_object_iter_value(json_object_key_to_iter(key))); \
     153             :         key = json_object_iter_key(json_object_iter_next(object, json_object_key_to_iter(key))))
     154             : 
     155             : #define json_object_foreach_safe(object, n, key, value)     \
     156             :     for(key = json_object_iter_key(json_object_iter(object)), \
     157             :             n = json_object_iter_next(object, json_object_key_to_iter(key)); \
     158             :         key && (value = json_object_iter_value(json_object_key_to_iter(key))); \
     159             :         key = json_object_iter_key(n), \
     160             :             n = json_object_iter_next(object, json_object_key_to_iter(key)))
     161             : 
     162             : #define json_array_foreach(array, index, value) \
     163             :         for(index = 0; \
     164             :                 index < json_array_size(array) && (value = json_array_get(array, index)); \
     165             :                 index++)
     166             : 
     167             : static JSON_INLINE
     168             : int json_object_set(json_t *object, const char *key, json_t *value)
     169             : {
     170             :     return json_object_set_new(object, key, json_incref(value));
     171             : }
     172             : 
     173             : static JSON_INLINE
     174             : int json_object_set_nocheck(json_t *object, const char *key, json_t *value)
     175             : {
     176             :     return json_object_set_new_nocheck(object, key, json_incref(value));
     177             : }
     178             : 
     179             : static JSON_INLINE
     180             : int json_object_iter_set(json_t *object, void *iter, json_t *value)
     181             : {
     182             :     return json_object_iter_set_new(object, iter, json_incref(value));
     183             : }
     184             : 
     185             : size_t json_array_size(const json_t *array);
     186             : json_t *json_array_get(const json_t *array, size_t index);
     187             : int json_array_set_new(json_t *array, size_t index, json_t *value);
     188             : int json_array_append_new(json_t *array, json_t *value);
     189             : int json_array_insert_new(json_t *array, size_t index, json_t *value);
     190             : int json_array_remove(json_t *array, size_t index);
     191             : int json_array_clear(json_t *array);
     192             : int json_array_extend(json_t *array, json_t *other);
     193             : 
     194             : static JSON_INLINE
     195             : int json_array_set(json_t *array, size_t ind, json_t *value)
     196             : {
     197             :     return json_array_set_new(array, ind, json_incref(value));
     198             : }
     199             : 
     200             : static JSON_INLINE
     201             : int json_array_append(json_t *array, json_t *value)
     202             : {
     203             :     return json_array_append_new(array, json_incref(value));
     204             : }
     205             : 
     206             : static JSON_INLINE
     207             : int json_array_insert(json_t *array, size_t ind, json_t *value)
     208             : {
     209             :     return json_array_insert_new(array, ind, json_incref(value));
     210             : }
     211             : 
     212             : const char *json_string_value(const json_t *string);
     213             : size_t json_string_length(const json_t *string);
     214             : json_int_t json_integer_value(const json_t *integer);
     215             : double json_real_value(const json_t *real);
     216             : double json_number_value(const json_t *json);
     217             : 
     218             : int json_string_set(json_t *string, const char *value);
     219             : int json_string_setn(json_t *string, const char *value, size_t len);
     220             : int json_string_set_nocheck(json_t *string, const char *value);
     221             : int json_string_setn_nocheck(json_t *string, const char *value, size_t len);
     222             : int json_integer_set(json_t *integer, json_int_t value);
     223             : int json_real_set(json_t *real, double value);
     224             : 
     225             : /* pack, unpack */
     226             : 
     227             : json_t *json_pack(const char *fmt, ...);
     228             : json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...);
     229             : json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap);
     230             : 
     231             : #define JSON_VALIDATE_ONLY  0x1
     232             : #define JSON_STRICT         0x2
     233             : 
     234             : int json_unpack(json_t *root, const char *fmt, ...);
     235             : int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...);
     236             : int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, va_list ap);
     237             : 
     238             : 
     239             : /* equality */
     240             : 
     241             : int json_equal(json_t *value1, json_t *value2);
     242             : 
     243             : 
     244             : /* copying */
     245             : 
     246             : json_t *json_copy(json_t *value);
     247             : json_t *json_deep_copy(const json_t *value);
     248             : 
     249             : 
     250             : /* decoding */
     251             : 
     252             : #define JSON_REJECT_DUPLICATES  0x1
     253             : #define JSON_DISABLE_EOF_CHECK  0x2
     254             : #define JSON_DECODE_ANY         0x4
     255             : #define JSON_DECODE_INT_AS_REAL 0x8
     256             : #define JSON_ALLOW_NUL          0x10
     257             : 
     258             : typedef size_t (*json_load_callback_t)(void *buffer, size_t buflen, void *data);
     259             : 
     260             : json_t *json_loads(const char *input, size_t flags, json_error_t *error);
     261             : json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error);
     262             : json_t *json_loadf(FILE *input, size_t flags, json_error_t *error);
     263             : json_t *json_load_file(const char *path, size_t flags, json_error_t *error);
     264             : json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags, json_error_t *error);
     265             : 
     266             : 
     267             : /* encoding */
     268             : 
     269             : #define JSON_MAX_INDENT         0x1F
     270             : #define JSON_INDENT(n)          ((n) & JSON_MAX_INDENT)
     271             : #define JSON_COMPACT            0x20
     272             : #define JSON_ENSURE_ASCII       0x40
     273             : #define JSON_SORT_KEYS          0x80
     274             : #define JSON_PRESERVE_ORDER     0x100
     275             : #define JSON_ENCODE_ANY         0x200
     276             : #define JSON_ESCAPE_SLASH       0x400
     277             : #define JSON_REAL_PRECISION(n)  (((n) & 0x1F) << 11)
     278             : 
     279             : typedef int (*json_dump_callback_t)(const char *buffer, size_t size, void *data);
     280             : 
     281             : char *json_dumps(const json_t *json, size_t flags);
     282             : int json_dumpf(const json_t *json, FILE *output, size_t flags);
     283             : int json_dump_file(const json_t *json, const char *path, size_t flags);
     284             : int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags);
     285             : 
     286             : /* custom memory allocation */
     287             : 
     288             : typedef void *(*json_malloc_t)(size_t);
     289             : typedef void (*json_free_t)(void *);
     290             : 
     291             : void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn);
     292             : void json_get_alloc_funcs(json_malloc_t *malloc_fn, json_free_t *free_fn);
     293             : 
     294             : #ifdef __cplusplus
     295             : }
     296             : #endif
     297             : 
     298             : #endif

Generated by: LCOV version 1.11