Exit Zen
8
:29
English
An empty object may be constructed without incurring any memory allocations using the <<default_memory_resource,default memory resource>>. A <<ref_storage_ptr>> can also be explicitly specified:
175/1940 · 194
8
:67
English
Similarly, an initializer list for an <<ref_object>> is always interpreted as an <<ref_object>>. In such cases, the initializer list must be a list of key-value pairs. For example, the following code will not compile because `1` is not convertible to a string:
133/2600 · 260
9
:100
English
To permit custom memory allocation strategies, these containers all allow construction with a <<ref_storage_ptr>> which is a smart pointer to a {ref_memory_resource}. The constructor signatures have the same ordering as their `std` equivalents which use {req_Allocator} parameters. Once a container is constructed its memory resource can never change. Here we create an array without performing any dynamic allocations:
192/4190 · 419
11
:54
English
Similar to the `std` counterpart, elements may be accessed directly by their key with bounds checking using <<ref_object_at>>, or without bounds checking using <<ref_object_operator_lb_rb>> which creates a null element if the key does not already exist:
165/2530 · 253
12
:38
English
A <<ref_value>> constructed from `nullptr` or default constructed represents a null JSON element:
64/970 · 97
12
:129
English
Up until now we have shown how values may be constructed from a memory resource pointer, where ownership is not transferred. In this case the caller is responsible for ensuring that the lifetime of the resource is extended for the life of the container. Sometimes you want the container to acquire shared ownership of the resource. This is accomplished with <<ref_make_shared_resource>>:
144/3870 · 387
13
:66
English
Overloads of `tag_invoke` called by <<ref_value_from>> take the form:
69/690 · 69
13
:46
English
The member function <<ref_value_kind,`value::kind`>> may be used to query the kind stored in the value. Alternatively, member functions like <<ref_value_is_object,`value::is_object`>> <<ref_value_is_number,`value::is_number`>> may be used to check whether or not the value is a particular kind:
293/2940 · 294
14
:57
English
Functions like <<ref_value_if_object,`value::if_object`>> actually return a pointer to the object if the value is an object, otherwise they return null. This allows them to be used both in boolean contexts as above, and in assignments or conditional expressions to capture the value of the pointer:
161/2980 · 298
15
:72
English
While overloads of `tag_invoke` called by <<ref_value_to>> take the form:
65/730 · 73
15
:42
English
The <<ref_serialize>> function converts a <<ref_value>> into a {std_string}:
95/760 · 76
16
:100
English
Often it is needed to use several conversion contexts together. For example, consider a log of remote users identified by IP addresses accessing a system. We can represent it as `std::vector<std::pair<std::chrono::system_clock::time_point, ip_address>>`. We want to serialize both ``ip_address``es and ``time_point``s as strings, but for this we need both `as_string` and `as_iso_8601` contexts. To combine several contexts just use {std_tuple}. Conversion functions will select the first element of the tuple for which a `tag_invoke` overload exists and will call that overload. As usual, `tag_invoke` overloads that don't use contexts and library-provided generic conversions are also supported. Thus, here's our example:
396/7230 · 723
16
:80
English
The following table shows all of the ways to determine and access the contents of a <<ref_value>>:
53/980 · 98
16
:49
English
In situations where serializing a <<ref_value>> in its entirety is inefficient or even impossible, <<ref_serializer>> can be used to serialize a <<ref_value>> incrementally. This may be done for a variety of reasons, such as to avoid buffering the entire output, or to ensure that a fixed amount of work is performed in each cycle. Instances of <<ref_serializer>> maintain an output state using internal dynamically allocated structures, with an interface to retrieve successive buffers of the serialized output into a caller provided buffer. Here is an example, demonstrating how <<ref_operator_lt_lt>> may be implemented using a <<ref_serializer>>:
349/6500 · 650
21
:48
English
The <<ref_parse>> function offers a simple interface for converting a serialized JSON text to a <<ref_value>> in a single function call. This overload uses exceptions to indicate errors:
113/1860 · 186
21
:191
English
Simple free functions are provided for serializing a <<ref_value>> to a {std_string} containing JSON:
74/1010 · 101
24
:56
English
This design removes several redundant overloads from the interface. For example, the 11 overloads of `std::string::insert` are reduced to just 3 in <<ref_string>>, while still providing identical functionality. In addition to these changes, overloads taking a `std::initializer_list<char>` parameter have been removed. Such overloads have little use, as they serve as little more than wrappers for arrays with an inefficient syntax:
206/4320 · 432
25
:68
English
With the removal of overloads that specify parameters for a substring, a member function `subview` that returns a <<ref_string_view>> is provided to facilitate cheap substring operations:
105/1870 · 187
25
:218
English
We can define a conversion from the user-defined type to a <<ref_value>> by defining an overload of `tag_invoke` in the same namespace. This maps `customer` to a JSON object:
107/1740 · 174
26
:77
English
A <<ref_string>> may be constructed using the <<default_memory_resource,default memory resource>> without incurring any memory allocations. Alternatively, a <<ref_storage_ptr>> can be provided explicitly:
218/2040 · 204