Exit Zen
15
:45
English
a `std::string` parameter and two `size_type` parameters that specify a
53/710 · 71
15
:99
English
Combining Contexts
5/180 · 18
15
:72
English
While overloads of `tag_invoke` called by <<ref_value_to>> take the form:
65/730 · 73
15
:91
English
Formatted Output
5/160 · 16
15
:67
English
After a <<ref_value>> is constructed, its kind can change depending on what is assigned to it, or by calling functions such as <<ref_value_emplace_array,`value::emplace_array`>> or <<ref_value_emplace_bool,`value::emplace_bool`>>. If the assignment is successful, in other words it completes without any exceptions then the value is replaced. Otherwise, the value is unchanged. All operations which can fail to modify a value offer the strong exception safety guarantee.
326/4700 · 470
15
:41
English
<<ref_get_null_resource>>
8/250 · 25
15
:91
English
This can be worked around by declaring the container to use a custom allocator (perhaps using a `std::shared_ptr< std::pmr::memory_resource >` as a data member). This hinders library composition; every library now exports unique, incompatible container types. A raw memory resource pointer is also easy to misuse:
132/3130 · 313
15
:38
English
<<ref_stream_parser>>
47/210 · 21
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
15
:49
English
https://rapidjson.org/classrapidjson_1_1_crt_allocator.html[`CrtAllocator`], which uses the standard C++ allocator, and is designed for general use including mutation of the document after it is parsed. The https://rapidjson.org/classrapidjson_1_1_generic_document.html[`Document`] object holding temporary memory is not reused between trials, otherwise memory consumption grows without bounds and invalidates the benchmark.
245/4240 · 424
:70
:70
English
{icon_bad} No incremental parsing, no incremental serialization.
29/640 · 64
15
:42
English
The <<ref_serialize>> function converts a <<ref_value>> into a {std_string}:
95/760 · 76
15
:58
English
`std::int64_t`, if `T` is a signed integer'; or
32/470 · 47
16
:23
English
http://www.boost.org/development/tests/develop/developer/json.html[image:https://img.shields.io/badge/matrix-develop-brightgreen.svg[Matrix]]
139/1410 · 141
16
:41
English
These containers are explored in-depth in the sections that follow.
67/670 · 67
16
:46
English
substring, or
6/130 · 13
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
:74
English
``` T tag_invoke( const value_to_tag< T >&, const value& ); ```
77/630 · 63
16
:93
English
When an <<ref_object>> is formatted to a {std_ostream}, the result is a valid JSON. That is, the object will be output with curly braces and a comma separated list of key/value pairs, as per the JSON specification.
109/2140 · 214
16
:80
English
The following table shows all of the ways to determine and access the contents of a <<ref_value>>:
53/980 · 98