doc/apiref.rst

   1 .. _apiref:
   2
   3 *************
   4 API Reference
   5 *************
   6
   7 .. highlight:: c
   8
   9 Preliminaries
  10 =============
  11
  12 All declarations are in :file:`jansson.h`, so it's enough to
  13
  14 ::
  15
  16    #include <jansson.h>
  17
  18 in each source file.
  19
  20 All constants are prefixed with ``JSON_`` (except for those describing
  21 the library version, prefixed with ``JANSSON_``). Other identifiers
  22 are prefixed with ``json_``. Type names are suffixed with ``_t`` and
  23 ``typedef``\ 'd so that the ``struct`` keyword need not be used.
  24
  25
  26 Library Version
  27 ===============
  28
  29 The Jansson version is of the form *A.B.C*, where *A* is the major
  30 version, *B* is the minor version and *C* is the micro version. If the
  31 micro version is zero, it's omitted from the version string, i.e. the
  32 version string is just *A.B*.
  33
  34 When a new release only fixes bugs and doesn't add new features or
  35 functionality, the micro version is incremented. When new features are
  36 added in a backwards compatible way, the minor version is incremented
  37 and the micro version is set to zero. When there are backwards
  38 incompatible changes, the major version is incremented and others are
  39 set to zero.
  40
  41 The following preprocessor constants specify the current version of
  42 the library:
  43
  44 ``JANSSON_VERSION_MAJOR``, ``JANSSON_VERSION_MINOR``, ``JANSSON_VERSION_MICRO``
  45   Integers specifying the major, minor and micro versions,
  46   respectively.
  47
  48 ``JANSSON_VERSION``
  49   A string representation of the current version, e.g. ``"1.2.1"`` or
  50   ``"1.3"``.
  51
  52 ``JANSSON_VERSION_HEX``
  53   A 3-byte hexadecimal representation of the version, e.g.
  54   ``0x010201`` for version 1.2.1 and ``0x010300`` for version 1.3.
  55   This is useful in numeric comparisions, e.g.::
  56
  57       #if JANSSON_VERSION_HEX >= 0x010300
  58       /* Code specific to version 1.3 and above */
  59       #endif
  60
  61
  62 Value Representation
  63 ====================
  64
  65 The JSON specification (:rfc:`4627`) defines the following data types:
  66 *object*, *array*, *string*, *number*, *boolean*, and *null*. JSON
  67 types are used dynamically; arrays and objects can hold any other data
  68 type, including themselves. For this reason, Jansson's type system is
  69 also dynamic in nature. There's one C type to represent all JSON
  70 values, and this structure knows the type of the JSON value it holds.
  71
  72 .. type:: json_t
  73
  74   This data structure is used throughout the library to represent all
  75   JSON values. It always contains the type of the JSON value it holds
  76   and the value's reference count. The rest depends on the type of the
  77   value.
  78
  79 Objects of :type:`json_t` are always used through a pointer. There
  80 are APIs for querying the type, manipulating the reference count, and
  81 for constructing and manipulating values of different types.
  82
  83 Unless noted otherwise, all API functions return an error value if an
  84 error occurs. Depending on the function's signature, the error value
  85 is either *NULL* or -1. Invalid arguments or invalid input are
  86 apparent sources for errors. Memory allocation and I/O operations may
  87 also cause errors.
  88
  89
  90 Type
  91 ----
  92
  93 The type of a JSON value is queried and tested using the following
  94 functions:
  95
  96 .. type:: enum json_type
  97
  98    The type of a JSON value. The following members are defined:
  99
 100    +--------------------+
 101    | ``JSON_OBJECT``    |
 102    +--------------------+
 103    | ``JSON_ARRAY``     |
 104    +--------------------+
 105    | ``JSON_STRING``    |
 106    +--------------------+
 107    | ``JSON_INTEGER``   |
 108    +--------------------+
 109    | ``JSON_REAL``      |
 110    +--------------------+
 111    | ``JSON_TRUE``      |
 112    +--------------------+
 113    | ``JSON_FALSE``     |
 114    +--------------------+
 115    | ``JSON_NULL``      |
 116    +--------------------+
 117
 118    These correspond to JSON object, array, string, number, boolean and
 119    null. A number is represented by either a value of the type
 120    ``JSON_INTEGER`` or of the type ``JSON_REAL``. A true boolean value
 121    is represented by a value of the type ``JSON_TRUE`` and false by a
 122    value of the type ``JSON_FALSE``.
 123
 124 .. function:: int json_typeof(const json_t *json)
 125
 126    Return the type of the JSON value (a :type:`json_type` cast to
 127    :type:`int`). *json* MUST NOT be *NULL*. This function is actually
 128    implemented as a macro for speed.
 129
 130 .. function:: json_is_object(const json_t *json)
 131                json_is_array(const json_t *json)
 132                json_is_string(const json_t *json)
 133                json_is_integer(const json_t *json)
 134                json_is_real(const json_t *json)
 135                json_is_true(const json_t *json)
 136                json_is_false(const json_t *json)
 137                json_is_null(const json_t *json)
 138
 139    These functions (actually macros) return true (non-zero) for values
 140    of the given type, and false (zero) for values of other types and
 141    for *NULL*.
 142
 143 .. function:: json_is_number(const json_t *json)
 144
 145    Returns true for values of types ``JSON_INTEGER`` and
 146    ``JSON_REAL``, and false for other types and for *NULL*.
 147
 148 .. function:: json_is_boolean(const json_t *json)
 149
 150    Returns true for types ``JSON_TRUE`` and ``JSON_FALSE``, and false
 151    for values of other types and for *NULL*.
 152
 153
 154 .. _apiref-reference-count:
 155
 156 Reference Count
 157 ---------------
 158
 159 The reference count is used to track whether a value is still in use
 160 or not. When a value is created, it's reference count is set to 1. If
 161 a reference to a value is kept (e.g. a value is stored somewhere for
 162 later use), its reference count is incremented, and when the value is
 163 no longer needed, the reference count is decremented. When the
 164 reference count drops to zero, there are no references left, and the
 165 value can be destroyed.
 166
 167 The following functions are used to manipulate the reference count.
 168
 169 .. function:: json_t *json_incref(json_t *json)
 170
 171    Increment the reference count of *json* if it's not non-*NULL*.
 172    Returns *json*.
 173
 174 .. function:: void json_decref(json_t *json)
 175
 176    Decrement the reference count of *json*. As soon as a call to
 177    :func:`json_decref()` drops the reference count to zero, the value
 178    is destroyed and it can no longer be used.
 179
 180 Functions creating new JSON values set the reference count to 1. These
 181 functions are said to return a **new reference**. Other functions
 182 returning (existing) JSON values do not normally increase the
 183 reference count. These functions are said to return a **borrowed
 184 reference**. So, if the user will hold a reference to a value returned
 185 as a borrowed reference, he must call :func:`json_incref`. As soon as
 186 the value is no longer needed, :func:`json_decref` should be called
 187 to release the reference.
 188
 189 Normally, all functions accepting a JSON value as an argument will
 190 manage the reference, i.e. increase and decrease the reference count
 191 as needed. However, some functions **steal** the reference, i.e. they
 192 have the same result as if the user called :func:`json_decref()` on
 193 the argument right after calling the function. These functions are
 194 suffixed with ``_new`` or have ``_new_`` somewhere in their name.
 195
 196 For example, the following code creates a new JSON array and appends
 197 an integer to it::
 198
 199   json_t *array, *integer;
 200
 201   array = json_array();
 202   integer = json_integer(42);
 203
 204   json_array_append(array, integer);
 205   json_decref(integer);
 206
 207 Note how the caller has to release the reference to the integer value
 208 by calling :func:`json_decref()`. By using a reference stealing
 209 function :func:`json_array_append_new()` instead of
 210 :func:`json_array_append()`, the code becomes much simpler::
 211
 212   json_t *array = json_array();
 213   json_array_append_new(array, json_integer(42));
 214
 215 In this case, the user doesn't have to explicitly release the
 216 reference to the integer value, as :func:`json_array_append_new()`
 217 steals the reference when appending the value to the array.
 218
 219 In the following sections it is clearly documented whether a function
 220 will return a new or borrowed reference or steal a reference to its
 221 argument.
 222
 223
 224 Circular References
 225 -------------------
 226
 227 A circular reference is created when an object or an array is,
 228 directly or indirectly, inserted inside itself. The direct case is
 229 simple::
 230
 231   json_t *obj = json_object();
 232   json_object_set(obj, "foo", obj);
 233
 234 Jansson will refuse to do this, and :func:`json_object_set()` (and
 235 all the other such functions for objects and arrays) will return with
 236 an error status. The indirect case is the dangerous one::
 237
 238   json_t *arr1 = json_array(), *arr2 = json_array();
 239   json_array_append(arr1, arr2);
 240   json_array_append(arr2, arr1);
 241
 242 In this example, the array ``arr2`` is contained in the array
 243 ``arr1``, and vice versa. Jansson cannot check for this kind of
 244 indirect circular references without a performance hit, so it's up to
 245 the user to avoid them.
 246
 247 If a circular reference is created, the memory consumed by the values
 248 cannot be freed by :func:`json_decref()`. The reference counts never
 249 drops to zero because the values are keeping the references to each
 250 other. Moreover, trying to encode the values with any of the encoding
 251 functions will fail. The encoder detects circular references and
 252 returns an error status.
 253
 254
 255 True, False and Null
 256 ====================
 257
 258 These values are implemented as singletons, so each of these functions
 259 returns the same value each time.
 260
 261 .. function:: json_t *json_true(void)
 262
 263    .. refcounting:: new
 264
 265    Returns the JSON true value.
 266
 267 .. function:: json_t *json_false(void)
 268
 269    .. refcounting:: new
 270
 271    Returns the JSON false value.
 272
 273 .. function:: json_t *json_null(void)
 274
 275    .. refcounting:: new
 276
 277    Returns the JSON null value.
 278
 279
 280 String
 281 ======
 282
 283 Jansson uses UTF-8 as the character encoding. All JSON strings must be
 284 valid UTF-8 (or ASCII, as it's a subset of UTF-8). Normal null
 285 terminated C strings are used, so JSON strings may not contain
 286 embedded null characters. All other Unicode codepoints U+0001 through
 287 U+10FFFF are allowed.
 288
 289 .. function:: json_t *json_string(const char *value)
 290
 291    .. refcounting:: new
 292
 293    Returns a new JSON string, or *NULL* on error. *value* must be a
 294    valid UTF-8 encoded Unicode string.
 295
 296 .. function:: json_t *json_string_nocheck(const char *value)
 297
 298    .. refcounting:: new
 299
 300    Like :func:`json_string`, but doesn't check that *value* is valid
 301    UTF-8. Use this function only if you are certain that this really
 302    is the case (e.g. you have already checked it by other means).
 303
 304 .. function:: const char *json_string_value(const json_t *string)
 305
 306    Returns the associated value of *string* as a null terminated UTF-8
 307    encoded string, or *NULL* if *string* is not a JSON string.
 308
 309 .. function:: int json_string_set(const json_t *string, const char *value)
 310
 311    Sets the associated value of *string* to *value*. *value* must be a
 312    valid UTF-8 encoded Unicode string. Returns 0 on success and -1 on
 313    error.
 314
 315 .. function:: int json_string_set_nocheck(const json_t *string, const char *value)
 316
 317    Like :func:`json_string_set`, but doesn't check that *value* is
 318    valid UTF-8. Use this function only if you are certain that this
 319    really is the case (e.g. you have already checked it by other
 320    means).
 321
 322
 323 Number
 324 ======
 325
 326 The JSON specification only contains one numeric type, "number". The C
 327 programming language has distinct types for integer and floating-point
 328 numbers, so for practical reasons Jansson also has distinct types for
 329 the two. They are called "integer" and "real", respectively. For more
 330 information, see :ref:`rfc-conformance`.
 331
 332 .. type:: json_int_t
 333
 334    This is the C type that is used to store JSON integer values. It
 335    represents the widest integer type available on your system. In
 336    practice it's just a typedef of ``long long`` if your compiler
 337    supports it, otherwise ``long``.
 338
 339    Usually, you can safely use plain ``int`` in place of
 340    ``json_int_t``, and the implicit C integer conversion handles the
 341    rest. Only when you know that you need the full 64-bit range, you
 342    should use ``json_int_t`` explicitly.
 343
 344 ``JSON_INTEGER_IS_LONG_LONG``
 345
 346    This is a preprocessor variable that holds the value 1 if
 347    :type:`json_int_t` is ``long long``, and 0 if it's ``long``. It
 348    can be used as follows::
 349
 350        #if JSON_INTEGER_IS_LONG_LONG
 351        /* Code specific for long long */
 352        #else
 353        /* Code specific for long */
 354        #endif
 355
 356 ``JSON_INTEGER_FORMAT``
 357
 358    This is a macro that expands to a :func:`printf()` conversion
 359    specifier that corresponds to :type:`json_int_t`, without the
 360    leading ``%`` sign, i.e. either ``"lld"`` or ``"ld"``. This macro
 361    is required because the actual type of :type:`json_int_t` can be
 362    either ``long`` or ``long long``, and :func:`printf()` reuiqres
 363    different length modifiers for the two.
 364
 365    Example::
 366
 367        json_int_t x = 123123123;
 368        printf("x is %" JSON_INTEGER_FORMAT "\n", x);
 369
 370
 371 .. function:: json_t *json_integer(json_int_t value)
 372
 373    .. refcounting:: new
 374
 375    Returns a new JSON integer, or *NULL* on error.
 376
 377 .. function:: json_int_t json_integer_value(const json_t *integer)
 378
 379    Returns the associated value of *integer*, or 0 if *json* is not a
 380    JSON integer.
 381
 382 .. function:: int json_integer_set(const json_t *integer, json_int_t value)
 383
 384    Sets the associated value of *integer* to *value*. Returns 0 on
 385    success and -1 if *integer* is not a JSON integer.
 386
 387 .. function:: json_t *json_real(double value)
 388
 389    .. refcounting:: new
 390
 391    Returns a new JSON real, or *NULL* on error.
 392
 393 .. function:: double json_real_value(const json_t *real)
 394
 395    Returns the associated value of *real*, or 0.0 if *real* is not a
 396    JSON real.
 397
 398 .. function:: int json_real_set(const json_t *real, double value)
 399
 400    Sets the associated value of *real* to *value*. Returns 0 on
 401    success and -1 if *real* is not a JSON real.
 402
 403 In addition to the functions above, there's a common query function
 404 for integers and reals:
 405
 406 .. function:: double json_number_value(const json_t *json)
 407
 408    Returns the associated value of the JSON integer or JSON real
 409    *json*, cast to double regardless of the actual type. If *json* is
 410    neither JSON real nor JSON integer, 0.0 is returned.
 411
 412
 413 Array
 414 =====
 415
 416 A JSON array is an ordered collection of other JSON values.
 417
 418 .. function:: json_t *json_array(void)
 419
 420    .. refcounting:: new
 421
 422    Returns a new JSON array, or *NULL* on error. Initially, the array
 423    is empty.
 424
 425 .. function:: size_t json_array_size(const json_t *array)
 426
 427    Returns the number of elements in *array*, or 0 if *array* is NULL
 428    or not a JSON array.
 429
 430 .. function:: json_t *json_array_get(const json_t *array, size_t index)
 431
 432    .. refcounting:: borrow
 433
 434    Returns the element in *array* at position *index*. The valid range
 435    for *index* is from 0 to the return value of
 436    :func:`json_array_size()` minus 1. If *array* is not a JSON array,
 437    if *array* is *NULL*, or if *index* is out of range, *NULL* is
 438    returned.
 439
 440 .. function:: int json_array_set(json_t *array, size_t index, json_t *value)
 441
 442    Replaces the element in *array* at position *index* with *value*.
 443    The valid range for *index* is from 0 to the return value of
 444    :func:`json_array_size()` minus 1. Returns 0 on success and -1 on
 445    error.
 446
 447 .. function:: int json_array_set_new(json_t *array, size_t index, json_t *value)
 448
 449    Like :func:`json_array_set()` but steals the reference to *value*.
 450    This is useful when *value* is newly created and not used after
 451    the call.
 452
 453 .. function:: int json_array_append(json_t *array, json_t *value)
 454
 455    Appends *value* to the end of *array*, growing the size of *array*
 456    by 1. Returns 0 on success and -1 on error.
 457
 458 .. function:: int json_array_append_new(json_t *array, json_t *value)
 459
 460    Like :func:`json_array_append()` but steals the reference to
 461    *value*. This is useful when *value* is newly created and not used
 462    after the call.
 463
 464 .. function:: int json_array_insert(json_t *array, size_t index, json_t *value)
 465
 466    Inserts *value* to *array* at position *index*, shifting the
 467    elements at *index* and after it one position towards the end of
 468    the array. Returns 0 on success and -1 on error.
 469
 470 .. function:: int json_array_insert_new(json_t *array, size_t index, json_t *value)
 471
 472    Like :func:`json_array_insert()` but steals the reference to
 473    *value*. This is useful when *value* is newly created and not used
 474    after the call.
 475
 476 .. function:: int json_array_remove(json_t *array, size_t index)
 477
 478    Removes the element in *array* at position *index*, shifting the
 479    elements after *index* one position towards the start of the array.
 480    Returns 0 on success and -1 on error.
 481
 482 .. function:: int json_array_clear(json_t *array)
 483
 484    Removes all elements from *array*. Returns 0 on sucess and -1 on
 485    error.
 486
 487 .. function:: int json_array_extend(json_t *array, json_t *other_array)
 488
 489    Appends all elements in *other_array* to the end of *array*.
 490    Returns 0 on success and -1 on error.
 491
 492
 493 Object
 494 ======
 495
 496 A JSON object is a dictionary of key-value pairs, where the key is a
 497 Unicode string and the value is any JSON value.
 498
 499 .. function:: json_t *json_object(void)
 500
 501    .. refcounting:: new
 502
 503    Returns a new JSON object, or *NULL* on error. Initially, the
 504    object is empty.
 505
 506 .. function:: size_t json_object_size(const json_t *object)
 507
 508    Returns the number of elements in *object*, or 0 if *object* is not
 509    a JSON object.
 510
 511 .. function:: json_t *json_object_get(const json_t *object, const char *key)
 512
 513    .. refcounting:: borrow
 514
 515    Get a value corresponding to *key* from *object*. Returns *NULL* if
 516    *key* is not found and on error.
 517
 518 .. function:: int json_object_set(json_t *object, const char *key, json_t *value)
 519
 520    Set the value of *key* to *value* in *object*. *key* must be a
 521    valid null terminated UTF-8 encoded Unicode string. If there
 522    already is a value for *key*, it is replaced by the new value.
 523    Returns 0 on success and -1 on error.
 524
 525 .. function:: int json_object_set_nocheck(json_t *object, const char *key, json_t *value)
 526
 527    Like :func:`json_object_set`, but doesn't check that *key* is
 528    valid UTF-8. Use this function only if you are certain that this
 529    really is the case (e.g. you have already checked it by other
 530    means).
 531
 532 .. function:: int json_object_set_new(json_t *object, const char *key, json_t *value)
 533
 534    Like :func:`json_object_set()` but steals the reference to
 535    *value*. This is useful when *value* is newly created and not used
 536    after the call.
 537
 538 .. function:: int json_object_set_new_nocheck(json_t *object, const char *key, json_t *value)
 539
 540    Like :func:`json_object_set_new`, but doesn't check that *key* is
 541    valid UTF-8. Use this function only if you are certain that this
 542    really is the case (e.g. you have already checked it by other
 543    means).
 544
 545 .. function:: int json_object_del(json_t *object, const char *key)
 546
 547    Delete *key* from *object* if it exists. Returns 0 on success, or
 548    -1 if *key* was not found.
 549
 550
 551 .. function:: int json_object_clear(json_t *object)
 552
 553    Remove all elements from *object*. Returns 0 on success and -1 if
 554    *object* is not a JSON object.
 555
 556 .. function:: int json_object_update(json_t *object, json_t *other)
 557
 558    Update *object* with the key-value pairs from *other*, overwriting
 559    existing keys. Returns 0 on success or -1 on error.
 560
 561
 562 The following functions implement an iteration protocol for objects:
 563
 564 .. function:: void *json_object_iter(json_t *object)
 565
 566    Returns an opaque iterator which can be used to iterate over all
 567    key-value pairs in *object*, or *NULL* if *object* is empty.
 568
 569 .. function:: void *json_object_iter_at(json_t *object, const char *key)
 570
 571    Like :func:`json_object_iter()`, but returns an iterator to the
 572    key-value pair in *object* whose key is equal to *key*, or NULL if
 573    *key* is not found in *object*. Iterating forward to the end of
 574    *object* only yields all key-value pairs of the object if *key*
 575    happens to be the first key in the underlying hash table.
 576
 577 .. function:: void *json_object_iter_next(json_t *object, void *iter)
 578
 579    Returns an iterator pointing to the next key-value pair in *object*
 580    after *iter*, or *NULL* if the whole object has been iterated
 581    through.
 582
 583 .. function:: const char *json_object_iter_key(void *iter)
 584
 585    Extract the associated key from *iter*.
 586
 587 .. function:: json_t *json_object_iter_value(void *iter)
 588
 589    .. refcounting:: borrow
 590
 591    Extract the associated value from *iter*.
 592
 593 .. function:: int json_object_iter_set(json_t *object, void *iter, json_t *value)
 594
 595    Set the value of the key-value pair in *object*, that is pointed to
 596    by *iter*, to *value*.
 597
 598 .. function:: int json_object_iter_set_new(json_t *object, void *iter, json_t *value)
 599
 600    Like :func:`json_object_iter_set()`, but steals the reference to
 601    *value*. This is useful when *value* is newly created and not used
 602    after the call.
 603
 604 The iteration protocol can be used for example as follows::
 605
 606    /* obj is a JSON object */
 607    const char *key;
 608    json_t *value;
 609    void *iter = json_object_iter(obj);
 610    while(iter)
 611    {
 612        key = json_object_iter_key(iter);
 613        value = json_object_iter_value(iter);
 614        /* use key and value ... */
 615        iter = json_object_iter_next(obj, iter);
 616    }
 617
 618
 619 Encoding
 620 ========
 621
 622 This sections describes the functions that can be used to encode
 623 values to JSON. Only objects and arrays can be encoded, since they are
 624 the only valid "root" values of a JSON text.
 625
 626 By default, the output has no newlines, and spaces are used between
 627 array and object elements for a readable output. This behavior can be
 628 altered by using the ``JSON_INDENT`` and ``JSON_COMPACT`` flags
 629 described below. A newline is never appended to the end of the encoded
 630 JSON data.
 631
 632 Each function takes a *flags* parameter that controls some aspects of
 633 how the data is encoded. Its default value is 0. The following macros
 634 can be ORed together to obtain *flags*.
 635
 636 ``JSON_INDENT(n)``
 637    Pretty-print the result, using newlines between array and object
 638    items, and indenting with *n* spaces. The valid range for *n* is
 639    between 0 and 32, other values result in an undefined output. If
 640    ``JSON_INDENT`` is not used or *n* is 0, no newlines are inserted
 641    between array and object items.
 642
 643 ``JSON_COMPACT``
 644    This flag enables a compact representation, i.e. sets the separator
 645    between array and object items to ``","`` and between object keys
 646    and values to ``":"``. Without this flag, the corresponding
 647    separators are ``", "`` and ``": "`` for more readable output.
 648
 649 ``JSON_ENSURE_ASCII``
 650    If this flag is used, the output is guaranteed to consist only of
 651    ASCII characters. This is achived by escaping all Unicode
 652    characters outside the ASCII range.
 653
 654 ``JSON_SORT_KEYS``
 655    If this flag is used, all the objects in output are sorted by key.
 656    This is useful e.g. if two JSON texts are diffed or visually
 657    compared.
 658
 659 ``JSON_PRESERVE_ORDER``
 660    If this flag is used, object keys in the output are sorted into the
 661    same order in which they were first inserted to the object. For
 662    example, decoding a JSON text and then encoding with this flag
 663    preserves the order of object keys.
 664
 665 The following functions perform the actual JSON encoding. The result
 666 is in UTF-8.
 667
 668 .. function:: char *json_dumps(const json_t *root, size_t flags)
 669
 670    Returns the JSON representation of *root* as a string, or *NULL* on
 671    error. *flags* is described above. The return value must be freed
 672    by the caller using :func:`free()`.
 673
 674 .. function:: int json_dumpf(const json_t *root, FILE *output, size_t flags)
 675
 676    Write the JSON representation of *root* to the stream *output*.
 677    *flags* is described above. Returns 0 on success and -1 on error.
 678    If an error occurs, something may have already been written to
 679    *output*. In this case, the output is undefined and most likely not
 680    valid JSON.
 681
 682 .. function:: int json_dump_file(const json_t *json, const char *path, size_t flags)
 683
 684    Write the JSON representation of *root* to the file *path*. If
 685    *path* already exists, it is overwritten. *flags* is described
 686    above. Returns 0 on success and -1 on error.
 687
 688
 689 Decoding
 690 ========
 691
 692 This sections describes the functions that can be used to decode JSON
 693 text to the Jansson representation of JSON data. The JSON
 694 specification requires that a JSON text is either a serialized array
 695 or object, and this requirement is also enforced with the following
 696 functions. In other words, the top level value in the JSON text being
 697 decoded must be either array or object.
 698
 699 See :ref:`rfc-conformance` for a discussion on Jansson's conformance
 700 to the JSON specification. It explains many design decisions that
 701 affect especially the behavior of the decoder.
 702
 703 .. function:: json_t *json_loads(const char *input, size_t flags, json_error_t *error)
 704
 705    .. refcounting:: new
 706
 707    Decodes the JSON string *input* and returns the array or object it
 708    contains, or *NULL* on error, in which case *error* is filled with
 709    information about the error. See above for discussion on the
 710    *error* parameter. *flags* is currently unused, and should be set
 711    to 0.
 712
 713 .. function:: json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
 714
 715    .. refcounting:: new
 716
 717    Decodes the JSON text in stream *input* and returns the array or
 718    object it contains, or *NULL* on error, in which case *error* is
 719    filled with information about the error. See above for discussion
 720    on the *error* parameter. *flags* is currently unused, and should
 721    be set to 0.
 722
 723 .. function:: json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
 724
 725    .. refcounting:: new
 726
 727    Decodes the JSON text in file *path* and returns the array or
 728    object it contains, or *NULL* on error, in which case *error* is
 729    filled with information about the error. See above for discussion
 730    on the *error* parameter. *flags* is currently unused, and should
 731    be set to 0.
 732
 733 .. type:: json_error_t
 734
 735    This data structure is used to return information on decoding
 736    errors from the decoding functions.
 737
 738    .. member:: const char *text
 739
 740       The error message (in UTF-8), or an empty string if a message is
 741       not available.
 742
 743    .. member:: int line
 744
 745       The line number on which the error occurred, or -1 if this
 746       information is not available.
 747
 748    .. member:: int column
 749
 750       The character column on which the error occurred, or -1 if this
 751       information is not available.
 752
 753    .. member:: const char *source
 754
 755       Source of the error. This is (a part of) the file name when
 756       using :func:`json_load_file()`, or a special identifier in angle
 757       brackets otherwise (e.g. ``<string>``).
 758
 759    The normal use of :type:`json_error_t` is to allocate it on the
 760    stack, and pass a pointer to a decoding function. Example::
 761
 762       int main() {
 763           json_t *json;
 764           json_error_t error;
 765
 766           json = json_load_file("/path/to/file.json", 0, &error);
 767           if(!json) {
 768               /* the error variable contains error information */
 769           }
 770           ...
 771       }
 772
 773    Also note that if the decoding succeeded (``json != NULL`` in the
 774    above example), the contents of ``error`` are unspecified.
 775
 776    All decoding functions also accept *NULL* as the
 777    :type:`json_error_t` pointer, in which case no error information
 778    is returned to the caller.
 779
 780
 781 Equality
 782 ========
 783
 784 Testing for equality of two JSON values cannot, in general, be
 785 achieved using the ``==`` operator. Equality in the terms of the
 786 ``==`` operator states that the two :type:`json_t` pointers point to
 787 exactly the same JSON value. However, two JSON values can be equal not
 788 only if they are exactly the same value, but also if they have equal
 789 "contents":
 790
 791 * Two integer or real values are equal if their contained numeric
 792   values are equal. An integer value is never equal to a real value,
 793   though.
 794
 795 * Two strings are equal if their contained UTF-8 strings are equal,
 796   byte by byte. Unicode comparison algorithms are not implemented.
 797
 798 * Two arrays are equal if they have the same number of elements and
 799   each element in the first array is equal to the corresponding
 800   element in the second array.
 801
 802 * Two objects are equal if they have exactly the same keys and the
 803   value for each key in the first object is equal to the value of the
 804   corresponding key in the second object.
 805
 806 * Two true, false or null values have no "contents", so they are equal
 807   if their types are equal. (Because these values are singletons,
 808   their equality can actually be tested with ``==``.)
 809
 810 The following function can be used to test whether two JSON values are
 811 equal.
 812
 813 .. function:: int json_equal(json_t *value1, json_t *value2)
 814
 815    Returns 1 if *value1* and *value2* are equal, as defined above.
 816    Returns 0 if they are inequal or one or both of the pointers are
 817    *NULL*.
 818
 819
 820 Copying
 821 =======
 822
 823 Because of reference counting, passing JSON values around doesn't
 824 require copying them. But sometimes a fresh copy of a JSON value is
 825 needed. For example, if you need to modify an array, but still want to
 826 use the original afterwards, you should take a copy of it first.
 827
 828 Jansson supports two kinds of copying: shallow and deep. There is a
 829 difference between these methods only for arrays and objects. Shallow
 830 copying only copies the first level value (array or object) and uses
 831 the same child values in the copied value. Deep copying makes a fresh
 832 copy of the child values, too. Moreover, all the child values are deep
 833 copied in a recursive fashion.
 834
 835 .. function:: json_t *json_copy(json_t *value)
 836
 837    .. refcounting:: new
 838
 839    Returns a shallow copy of *value*, or *NULL* on error.
 840
 841 .. function:: json_t *json_deep_copy(json_t *value)
 842
 843    .. refcounting:: new
 844
 845    Returns a deep copy of *value*, or *NULL* on error.