The translation has come to an end.
The translation has come to an end.
Exit Zen
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
:141
English
A counted memory resource will not be destroyed until every container with shared ownership of the resource is destroyed.
35/1210 · 121
14
:145
English
Parsing
2/100 · 7
15
:146
English
JSON can be parsed into the value container in one step using a free function. In the following snippet, a parse error is indicated by a thrown exception:
45/1540 · 154
16
:154
English
Error codes are also possible:
7/300 · 30
17
:161
English
By default, the parser is strict and only accepts JSON compliant with the standard. However this behavior can be relaxed by filling out an options structure enabling one or more extensions. Here we use a static buffer and enable two non-standard extensions:
85/2570 · 257
18
:171
English
The parser in this library implements a https://en.wikipedia.org/wiki/Online_algorithm[__streaming algorithm__]; it can process JSON piece-by-piece, without the requirement that the entire input is available from the start. The parser uses a temporary memory allocation to do its work. If you plan on parsing multiple JSONs, for example in a network server, keeping the same parser instance will allow re-use of this temporary storage, improving performance.
186/4580 · 458
19
:184
English
With strategic use of the right memory resources, parser instance, and calculated upper limits on buffer sizes, it is possible to parse and examine JSON without __any__ dynamic memory allocations. This is explored in more detail in a later section.
78/2480 · 248
20
:190
English
Serializing
3/110 · 11
21
:191
English
Simple free functions are provided for serializing a <<ref_value>> to a {std_string} containing JSON:
74/1010 · 101
22
:199
English
The serializer in this library implements a https://en.wikipedia.org/wiki/Online_algorithm[__streaming algorithm__]; it can output JSON a piece at a time, without the requirement that the entire output area is allocated at once:
116/2280 · 228
23
:210
English
Value Conversion
3/160 · 16
24
:211
English
Given a user-defined type:
12/260 · 26
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
:227
English
This allows us to use the library function <<ref_value_from>> to produce a <<ref_value>> from our type:
98/1030 · 103
27
:235
English
The library knows what to do with standard containers. Here we convert an array of customers to a value:
31/1040 · 104
28
:243
English
To go from JSON to a user-defined type we use <<ref_value_to>>, which uses another overload of `tag_invoke`. This converts a JSON value to a `customer`. It throws an exception if the contents of the value do not match what is expected:
129/2350 · 235
29
:253
English
The code above defines the convenience function `extract`, which deduces the types of the struct members. This works, but requires that the struct is {req_DefaultConstructible}. An alternative is to construct the object directly, which is a little more verbose but doesn't require default construction:
106/3020 · 302
30
:263
English
Now we can construct customers from JSON:
30/410 · 41
31
:270
English
The library's generic algorithms recognize when you are converting a <<ref_value>> to a container which resembles an array or object, so if you wanted to turn a JSON array into a vector of customers you might write:
91/2150 · 215
The translation has come to an end.