2. Boost Json Translation (zh_Hans)
3. Doc / Pages / Io / Parsing (adoc)
4. English
5. Zen

37 :140
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Streaming API, parse input JSON incrementally 45/10000 · 45
38 :141
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Improved performance when parsing multiple JSON texts 53/10000 · 53
39 :142
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Ignore non-JSON content after the end of a JSON text 52/10000 · 52
40 :144
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 396/10000 · 396
41 :151
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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: 322/10000 · 322
42 :162
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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: 331/10000 · 331
43 :173
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The parser instance may be constructed with parse options which allow some non-standard JSON extensions to be recognized: 121/10000 · 121
44 :181
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Streaming Parser 16/10000 · 16
45 :182
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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: 406/10000 · 406
46 :189
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — CPU consumption per I/O cycle is bounded 40/10000 · 40
47 :190
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Memory consumption per I/O cycle is bounded 43/10000 · 43
48 :191
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Jitter, unfairness, and latency is reduced 42/10000 · 42
49 :192
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Less total memory is required to process the full input 55/10000 · 55
50 :194
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 357/10000 · 357
51 :200
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In the following example a JSON text is parsed from standard input a line at a time. Error codes are used instead. The function <<ref_stream_parser_finish>> is used to indicate the end of the input: 198/10000 · 198
52 :204
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — This example will break, if comments are enabled, because of 60/10000 · 60
53 :205
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — `std::getline` use (see the warning in <<non_standard_json>> section). 70/10000 · 70
54 :212
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — We can complicate the example further by extracting _several_ JSON values from the sequence of lines. 101/10000 · 101
55 :220
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Controlling Memory 18/10000 · 18
56 :221
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — After default construction, or after <<ref_stream_parser_reset>> is called with no arguments, the <<ref_value>> produced after a successful parse operation uses the default memory resource. To use a different memory resource, call `reset` with the resource to use. Here we use a <<ref_monotonic_resource>>, which is optimized for parsing but not subsequent modification: 370/10000 · 370