Exit Zen
40
:144
English
The parser implementation uses temporary storage space to accumulate values during parsing. When using the <<ref_parse>> free functions, this storage is allocated and freed in each call. However, by declaring an instance of <<ref_parser>> or <<ref_stream_parser>>, this temporary storage can be reused when parsing more than one JSON text, reducing the total number of dynamic memory allocations.
217/3960 · 396
40
:90
English
Google Summer of Code 2018 data.
32/320 · 32
:87
:87
English
The result is an <<ref_array>>.
38/310 · 31
41
:151
English
To use the <<ref_parser>>, declare an instance. Then call <<ref_parser_write>> once with the buffer containing representing the input JSON. Finally, call <<ref_parser_release>> to take ownership of the resulting <<ref_value>> upon success. This example persists the parser instance in a class member to reuse across calls:
250/3220 · 322
41
:87
English
Type satisfying <<ref_is_tuple_like>>.
55/380 · 38
42
:162
English
Sometimes a protocol may have a JSON text followed by data that is in a different format or specification. The JSON portion can still be parsed by using the function <<ref_parser_write_some>>. Upon success, the return value will indicate the number of characters consumed from the input, which will exclude the non-JSON characters:
151/3310 · 331
42
:90
English
216KB
5/100 · 5
43
:95
English
https://en.cppreference.com/w/cpp/types/integer[`std::int64_t`]
63/630 · 63
45
:116
English
The <<ref_monotonic_resource>> optimizes this memory allocation pattern by allocating increasingly large blocks of global memory internally and parceling those blocks out in smaller pieces to fulfill allocation requests. It has a trivial deallocate function. The monotonic resource does not actually deallocate memory until the resource is destroyed. Thus, it is ideally suited for the use-case where JSON is parsed, and the resulting value is then inspected but not modified.
187/4760 · 476
45
:182
English
The <<ref_stream_parser>> implements a https://en.wikipedia.org/wiki/Online_algorithm[__streaming algorithm__]; it allows incremental processing of large JSON inputs using one or more contiguous character buffers. The entire input JSON does not need to be loaded into memory at once. A network server can use the streaming interface to process incoming JSON in fixed-size amounts, providing these benefits:
198/4060 · 406
45
:90
English
2.91MB
6/100 · 6
45
:87
English
The result is an <<ref_object>> with described members' names as keys.
52/700 · 70
46
:97
English
`string_view`
13/130 · 13
46
:124
English
The resource to use when constructing values may be specified in calls to <<ref_parse>> as shown here:
58/1020 · 102
46
:87
English
The result is default-constructed and described members are assigned
25/680 · 68
47
:98
English
`memory_resource`, `polymorphic_allocator`
42/420 · 42
48
:99
English
`error_category`, `error_code`, `error_condition`, `system_error`
65/650 · 65
48
:90
English
707KB
5/100 · 5
50
:151
English
A <<ref_static_resource>> constructs from a caller-provided buffer, and satisfies all memory allocation requests from the buffer. Once the buffer is exhausted, subsequent calls to allocate throw the exception `std::bad_alloc`. The resource offers a simple invariant: dynamic heap allocations are never performed.
147/3120 · 312
50
:194
English
To use the <<ref_stream_parser>>, declare an instance. Then call <<ref_stream_parser_write>> zero or more times with successive buffers representing the input JSON. When there are no more buffers, call <<ref_stream_parser_finish>>. The function <<ref_stream_parser_done>> returns `true` after a successful call to `write` or `finish` if parsing is complete.
324/3570 · 357