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
-convenience functions for adding new references to containers and not
-to worry about the reference count.
+the argument right after calling the function. These functions are
+suffixed with ``_new`` or have ``_new_`` somewhere in their name.
+
+For example, the following code creates a new JSON array and appends
+an integer to it::
+
+ json_t *array, *integer;
+
+ array = json_array();
+ integer = json_integer(42);
+
+ json_array_append(array, integer);
+ json_decref(integer);
+
+Note how the caller has to release the reference to the integer value
+by calling :cfunc:`json_decref()`. By using a reference stealing
+function :cfunc:`json_array_append_new()` instead of
+:cfunc:`json_array_append()`, the code becomes much simpler::
+
+ json_t *array = json_array();
+ json_array_append_new(array, json_integer(42));
+
+In this case, the user doesn't have to explicitly release the
+reference to the integer value, as :cfunc:`json_array_append_new()`
+steals the reference when appending the value to the array.
In the following sections it is clearly documented whether a function
will return a new or borrowed reference or steal a reference to its
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.
+drops to zero because the values are keeping the references to each
+other. 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
Number
======
-.. cfunction:: json_t *json_integer(int value)
+.. ctype:: json_int_t
+
+ This is the C type that is used to store JSON integer values. It
+ represents the widest integer type available on your system. In
+ practice it's just a typedef of ``long long`` if your compiler
+ supports it, otherwise ``long``.
+
+ Usually, you can safely use plain ``int`` in place of
+ ``json_int_t``, and the implicit C integer conversion handles the
+ rest. Only when you know that you need a full 64-bit range, you
+ should use ``json_int_t`` explicitly.
+
+``JSON_INTEGER_FORMAT``
+
+ This is a macro that expands to a :cfunc:`printf()` conversion
+ specifier that corresponds to :ctype:`json_int_t`, without the
+ leading ``%`` sign, i.e. either ``"lld"`` or ``"ld"``. This macro
+ is required because the actual type of :ctype:`json_int_t` can be
+ either ``long`` or ``long long``, and :cfunc:`printf()` reuiqres
+ different length modifiers for the two.
+
+ Example::
+
+ json_int_t x = 123123123;
+ printf("x is %" JSON_INTEGER_FORMAT "\n", x);
+
+
+.. cfunction:: json_t *json_integer(json_int_t value)
.. refcounting:: new
Returns a new JSON integer, or *NULL* on error.
-.. cfunction:: int json_integer_value(const json_t *integer)
+.. cfunction:: json_int_t 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)
+.. cfunction:: int json_integer_set(const json_t *integer, json_int_t value)
Sets the associated value of *integer* to *value*. Returns 0 on
success and -1 if *integer* is not a JSON integer.
Returns a new JSON array, or *NULL* on error. Initially, the array
is empty.
-.. cfunction:: unsigned int json_array_size(const json_t *array)
+.. cfunction:: size_t json_array_size(const json_t *array)
Returns the number of elements in *array*, or 0 if *array* is NULL
or not a JSON array.
-.. cfunction:: json_t *json_array_get(const json_t *array, unsigned int index)
+.. cfunction:: json_t *json_array_get(const json_t *array, size_t index)
.. refcounting:: borrow
if *array* is *NULL*, or if *index* is out of range, *NULL* is
returned.
-.. cfunction:: int json_array_set(json_t *array, unsigned int index, json_t *value)
+.. cfunction:: int json_array_set(json_t *array, size_t index, json_t *value)
Replaces the element in *array* at position *index* with *value*.
The valid range for *index* is from 0 to the return value of
:cfunc:`json_array_size()` minus 1. Returns 0 on success and -1 on
error.
-.. cfunction:: int json_array_set_new(json_t *array, unsigned int index, json_t *value)
+.. cfunction:: int json_array_set_new(json_t *array, size_t index, json_t *value)
Like :cfunc:`json_array_set()` but steals the reference to *value*.
This is useful when *value* is newly created and not used after
.. versionadded:: 1.1
-.. cfunction:: int json_array_insert(json_t *array, unsigned int index, json_t *value)
+.. cfunction:: int json_array_insert(json_t *array, size_t index, json_t *value)
Inserts *value* to *array* at position *index*, shifting the
elements at *index* and after it one position towards the end of
.. versionadded:: 1.1
-.. cfunction:: int json_array_insert_new(json_t *array, unsigned int index, json_t *value)
+.. cfunction:: int json_array_insert_new(json_t *array, size_t index, json_t *value)
Like :cfunc:`json_array_insert()` but steals the reference to
*value*. This is useful when *value* is newly created and not used
.. versionadded:: 1.1
-.. cfunction:: int json_array_remove(json_t *array, unsigned int index)
+.. cfunction:: int json_array_remove(json_t *array, size_t index)
Removes the element in *array* at position *index*, shifting the
elements after *index* one position towards the start of the array.
Returns a new JSON object, or *NULL* on error. Initially, the
object is empty.
-.. cfunction:: unsigned int json_object_size(const json_t *object)
+.. cfunction:: size_t json_object_size(const json_t *object)
Returns the number of elements in *object*, or 0 if *object* is not
a JSON object.
``JSON_INDENT(n)``
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
+ between 0 and 32, 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.
.. versionadded:: 1.2
+``JSON_PRESERVE_ORDER``
+ If this flag is used, object keys in the output are sorted into the
+ same order in which they were first inserted to the object. For
+ example, decoding a JSON text and then encoding with this flag
+ preserves the order of object keys.
+
+ .. versionadded:: 1.3
+
The following functions perform the actual JSON encoding. The result
is in UTF-8.
-.. cfunction:: char *json_dumps(const json_t *root, unsigned long flags)
+.. cfunction:: char *json_dumps(const json_t *root, size_t flags)
Returns the JSON representation of *root* as a string, or *NULL* on
error. *flags* is described above. The return value must be freed
by the caller using :cfunc:`free()`.
-.. cfunction:: int json_dumpf(const json_t *root, FILE *output, unsigned long flags)
+.. cfunction:: int json_dumpf(const json_t *root, FILE *output, size_t flags)
Write the JSON representation of *root* to the stream *output*.
*flags* is described above. Returns 0 on success and -1 on error.
*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)
+.. cfunction:: int json_dump_file(const json_t *json, const char *path, size_t flags)
Write the JSON representation of *root* to the file *path*. If
*path* already exists, it is overwritten. *flags* is described
projects / jansson.git / blobdiff