+.. _apiref:
+
*************
API Reference
*************
and false for values of other types and for *NULL*.
+.. _apiref-reference-count:
+
Reference Count
---------------
to release the reference.
Normally, all functions accepting a JSON value as an argument will
-nmanage the reference, i.e. increase and decrease the reference count
+manage the reference, i.e. increase and decrease the reference count
as needed. However, some functions **steal** the reference, i.e. they
have the same result as if the user called :cfunc:`json_decref()` on
the argument right after calling the function. These are usually
argument.
+Circular References
+-------------------
+
+A circular reference is created when an object or an array is,
+directly or indirectly, inserted inside itself. The direct case is
+simple::
+
+ json_t *obj = json_object();
+ json_object_set(obj, "foo", obj);
+
+Jansson will refuse to do this, and :cfunc:`json_object_set()` (and
+all the other such functions for objects and arrays) will return with
+an error status. The indirect case is the dangerous one::
+
+ json_t *arr1 = json_array(), *arr2 = json_array();
+ json_array_append(arr1, arr2);
+ json_array_append(arr2, arr1);
+
+In this example, the array ``arr2`` is contained in the array
+``arr1``, and vice versa. Jansson cannot check for this kind of
+indirect circular references without a performance hit, so it's up to
+the user to avoid them.
+
+If a circular reference is created, the memory consumed by the values
+cannot be freed by :cfunc:`json_decref()`. The reference counts never
+drops to zero because the values are keeping the circular reference to
+themselves. Moreover, trying to encode the values with any of the
+encoding functions will fail. The encoder detects circular references
+and returns an error status.
+
+
True, False and Null
====================
Returns a new JSON string, or *NULL* on error. *value* must be a
valid UTF-8 encoded Unicode string.
-.. cfunction:: const char *json_string_value(const json_t *json)
+.. cfunction:: const char *json_string_value(const json_t *string)
+
+ Returns the associated value of *string* as a null terminated UTF-8
+ encoded string, or *NULL* if *string* is not a JSON string.
+
+.. cfunction:: int json_string_set(const json_t *string, const char *value)
+
+ Sets the associated value of *string* to *value*. *value* must be a
+ valid UTF-8 encoded Unicode string. Returns 0 on success and -1 on
+ error.
- Returns the associated value of the JSON string *json* as a null
- terminated UTF-8 encoded string, or *NULL* if *json* is not a JSON
- string.
+ .. versionadded:: 1.1
Number
Returns a new JSON integer, or *NULL* on error.
-.. cfunction:: int json_integer_value(const json_t *json)
+.. cfunction:: int json_integer_value(const json_t *integer)
+
+ Returns the associated value of *integer*, or 0 if *json* is not a
+ JSON integer.
+
+.. cfunction:: int json_integer_set(const json_t *integer, int value)
- Returns the associated value the JSON integer *json*. If *json* is
- *NULL* or not a JSON integer, 0 is returned.
+ Sets the associated value of *integer* to *value*. Returns 0 on
+ success and -1 if *integer* is not a JSON integer.
+
+ .. versionadded:: 1.1
.. cfunction:: json_t *json_real(double value)
Returns a new JSON real, or *NULL* on error.
-.. cfunction:: double json_real_value(const json_t *json)
+.. cfunction:: double json_real_value(const json_t *real)
+
+ Returns the associated value of *real*, or 0.0 if *real* is not a
+ JSON real.
- Returns the associated value of the JSON real *json*. If *json* is
- *NULL* or not a JSON real, 0.0 is returned.
+.. cfunction:: int json_real_set(const json_t *real, double value)
+
+ Sets the associated value of *real* to *value*. Returns 0 on
+ success and -1 if *real* is not a JSON real.
+
+ .. versionadded:: 1.1
In addition to the functions above, there's a common query function
for integers and reals:
values to JSON. Only objects and arrays can be encoded, since they are
the only valid "root" values of a JSON text.
+By default, the output has no newlines, and spaces are used between
+array and object elements for a readable output. This behavior can be
+altered by using the ``JSON_INDENT`` and ``JSON_COMPACT`` flags
+described below. A newline is never appended to the end of the encoded
+JSON data.
+
Each function takes a *flags* parameter that controls some aspects of
how the data is encoded. Its default value is 0. The following macros
can be ORed together to obtain *flags*.
``JSON_INDENT(n)``
- Pretty-print the result, indenting arrays and objects by *n*
- spaces. The valid range for *n* is between 0 and 255, other values
- result in an undefined output. If ``JSON_INDENT`` is not used or
- *n* is 0, no pretty-printing is done and the result is a compact
- representation.
+ Pretty-print the result, using newlines between array and object
+ items, and indenting with *n* spaces. The valid range for *n* is
+ between 0 and 255, other values result in an undefined output. If
+ ``JSON_INDENT`` is not used or *n* is 0, no newlines are inserted
+ between array and object items.
+
+``JSON_COMPACT``
+ This flag enables a compact representation, i.e. sets the separator
+ between array and object items to ``","`` and between object keys
+ and values to ``":"``. Without this flag, the corresponding
+ separators are ``", "`` and ``": "`` for more readable output.
+
+ .. versionadded:: 1.2
The following functions perform the actual JSON encoding. The result
is in UTF-8.
Write the JSON representation of *root* to the stream *output*.
*flags* is described above. Returns 0 on success and -1 on error.
+ If an error occurs, something may have already been written to
+ *output*. In this case, the output is undefined and most likely not
+ valid JSON.
.. cfunction:: int json_dump_file(const json_t *json, const char *path, unsigned long flags)