Copies node.
If the node contains complex data types, their reference counts are increased, regardless of whether the node is mutable or immutable.
The copy will be immutable if, and only if, node is immutable. However,
there should be no need to copy an immutable node.
the copied of the given node
Gets a copy of the string value stored inside a node.
If the node does not hold a string value, NULL is returned.
a copy of the string inside the node
Check whether a and b are equal node, meaning they have the same
type and same values (checked recursively).
Note that integer values are compared numerically, ignoring type, so a double value 4.0 is equal to the integer value 4.
TRUE if a and b are equal; FALSE otherwise
Frees the resources allocated by the node.
Gets the boolean value stored inside a node.
If the node holds an integer or double value which is zero, FALSE is
returned; otherwise TRUE is returned.
If the node holds a JSON_NODE_NULL value or a value of another
non-boolean type, FALSE is returned.
a boolean value.
Gets the double value stored inside a node.
If the node holds an integer value, it is returned as a double.
If the node holds a FALSE boolean value, 0.0 is returned; otherwise
a non-zero double is returned.
If the node holds a JSON_NODE_NULL value or a value of another
non-double type, 0.0 is returned.
a double value.
Gets the integer value stored inside a node.
If the node holds a double value, its integer component is returned.
If the node holds a FALSE boolean value, 0 is returned; otherwise,
a non-zero integer is returned.
If the node holds a JSON_NODE_NULL value or a value of another
non-integer type, 0 is returned.
an integer value.
Gets the string value stored inside a node.
If the node does not hold a string value, NULL is returned.
a string value.
Retrieves a value from a node and copies into value.
When done using it, call g_value_unset() on the GObject.Value to free the
associated resources.
It is a programmer error to call this on a node which doesn’t hold a scalar
value. Use JSON_NODE_HOLDS_VALUE first.
Returns the GObject.GType of the payload of the node.
For JSON_NODE_NULL nodes, the returned type is G_TYPE_INVALID.
the type for the payload
Calculate a hash value for the given key.
The hash is calculated over the node and its value, recursively. If the node is immutable, this is a fast operation; otherwise, it scales proportionally with the size of the node’s value (for example, with the number of members in the JSON object if this node contains an object).
hash value for key
Check whether the given node has been marked as immutable by calling
Json.Node.seal on it.
TRUE if the node is immutable
Checks whether node is a JSON_NODE_NULL.
A JSON_NODE_NULL node is not the same as a NULL node; a JSON_NODE_NULL
represents a literal null value in the JSON tree.
TRUE if the node is null
Seals the given node, making it immutable to further changes.
In order to be sealed, the node must have a type and value set. The value
will be recursively sealed — if the node holds an object, that JSON object
will be sealed, etc.
If the node is already immutable, this is a no-op.
Sets value as the boolean content of the node, replacing any existing
content.
It is an error to call this on an immutable node, or on a node which is not a value node.
a boolean value
Sets value as the double content of the node, replacing any existing
content.
It is an error to call this on an immutable node, or on a node which is not a value node.
a double value
Sets value as the integer content of the node, replacing any existing
content.
It is an error to call this on an immutable node, or on a node which is not a value node.
an integer value
Sets value as the string content of the node, replacing any existing
content.
It is an error to call this on an immutable node, or on a node which is not a value node.
a string value
Sets a scalar value inside the given node.
The contents of the given GObject.Value are copied into the Json.Node.
The following GObject.Value types have a direct mapping to JSON types:
G_TYPE_INT64G_TYPE_DOUBLEG_TYPE_BOOLEANG_TYPE_STRINGJSON-GLib will also automatically promote the following GObject.Value types:
G_TYPE_INT to G_TYPE_INT64G_TYPE_FLOAT to G_TYPE_DOUBLEIt is an error to call this on an immutable node, or on a node which is not a value node.
the value to set
Retrieves the user readable name of the data type contained by node.
Note: The name is only meant for debugging purposes, and there is no guarantee the name will stay the same across different versions.
a string containing the name of the type
Decrements the reference count of node.
If the reference count reaches zero, the node is freed.
StaticallocStaticnew
A generic container of JSON data types.
Json.Node can contain fundamental types (integers, booleans, floating point numbers, strings) and complex types (arrays and objects).
When parsing a JSON data stream you extract the root node and walk the node tree by retrieving the type of data contained inside the node with the
JSON_NODE_TYPEmacro. If the node contains a fundamental type you can retrieve a copy of the GObject.Value holding it with the Json.Node.get_value function, and then use the GObject.Value API to extract the data; if the node contains a complex type you can retrieve the Json.Object or the Json.Array using Json.Node.get_object or Json.Node.get_array respectively, and then retrieve the nodes they contain.A Json.Node may be marked as immutable using Json.Node.seal. This marks the node and all its descendents as read-only, and means that subsequent calls to setter functions (such as Json.Node.set_array) on them will abort as a programmer error. By marking a node tree as immutable, it may be referenced in multiple places and its hash value cached for fast lookups, without the possibility of a value deep within the tree changing and affecting hash values. Immutable nodes may be passed to functions which retain a reference to them without needing to take a copy.
A Json.Node supports two types of memory management:
malloc/freesemantics, and reference counting semantics. The two may be mixed to a limited extent: nodes may be allocated (which gives them a reference count of 1), referenced one or more times, unreferenced exactly that number of times (using Json.Node.unref), then either unreferenced exactly once more or freed (using Json.Node.free) to destroy them. The Json.Node.free function must not be used when a node might have a reference count not equal to 1. To this end, JSON-GLib uses Json.Node.copy and Json.Node.unref internally.