amorfo77/json

0 Fork 0

mirror of https://github.com/nlohmann/json.git synced 2026-11-13 23:45:23 +00:00

Files

T

Niels Lohmann 81888ff9f0 Report a missing 0xFF after a final BON8 string also without strict (#6119 )

A BON8 string ends at the first byte that cannot continue it. When a
string ends a value and is not terminated by 0xFF, that byte belongs to
whatever follows the value, but the reader has already taken it from the
input and keeps it in its push-back buffer. With strict = true the
end-of-input check reports it; with strict = false the buffer was
discarded, so a following value in a stream lost its first byte or bytes
without an error ({0x61, 0x90} read "a" and then dropped the 0 that
follows).

Report parse_error.110 "string at the end of the value is not terminated
by 0xFF" when the push-back buffer is not empty once a BON8 value is
complete and strict is false, as bon8.md requires the final 0xFF. Output
of to_bon8 always has it, so canonical input is not affected.

Fixes #6110.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

2026-11-13 17:54:30 +01:00

5.0 KiB

Raw Blame History

nlohmann::basic_json::from_bon8

// (1)
template<typename InputType>
static basic_json from_bon8(InputType&& i,
                            const bool strict = true,
                            const bool allow_exceptions = true);
// (2)
template<typename IteratorType, typename SentinelType = IteratorType>
static basic_json from_bon8(IteratorType first, SentinelType last,
                            const bool strict = true,
                            const bool allow_exceptions = true);

Deserializes a given input to a JSON value using the BON8 (Binary Object Notation 8) serialization format.

Reads from a compatible input.
Reads from an iterator range, or an iterator and a sentinel of a different type (C++20 ranges support).

The exact mapping and its limitations are described on a dedicated page.

Template parameters

InputType

A compatible input, for instance:

an std::istream object
a FILE pointer
a C-style array of characters
a pointer to a null-terminated string of single byte characters
a container obj for which begin(obj) and end(obj) produce a valid pair of iterators (as found via ADL or member functions, with semantics compatible to std::begin and std::end)

IteratorType

a compatible iterator type

SentinelType

defaults to IteratorType; may be a different type comparable to IteratorType via operator!=, for instance.

a custom sentinel type for C++20 ranges
std::default_sentinel_t, when IteratorType is std::counted_iterator

Parameters

i (in): an input in BON8 format convertible to an input adapter
first (in): iterator to the start of the input
last (in): iterator to the end of the input, or a sentinel value that compares equal to the end iterator with operator!=
strict (in): whether to expect the input to be consumed until EOF (#!cpp true by default)
allow_exceptions (in): whether to throw exceptions in case of a parse error (optional, #!cpp true by default)

Return value

deserialized JSON value; in case of a parse error and allow_exceptions set to #!cpp false, the return value will be value_t::discarded. The latter can be checked with is_discarded.

Exception safety

Strong guarantee: if an exception is thrown, there are no changes in the JSON value.

Exceptions

Throws parse_error.110 if the given input ends prematurely, if the end of the file was not reached when strict was set to true, or if a string at the end of the value is not terminated by 0xFF although a byte follows it (also when strict is false: the byte that ends the string is taken from the input, so the next value would be lost)
Throws parse_error.112 if a parse error occurs, for instance an invalid byte, a string that is not valid UTF-8, or an object key that is not a string

The UTF-8 validity of strings is always checked, independent of JSON_STRICT_BINARY_UTF8, because the end of a BON8 string is determined from its encoding. Duplicate object keys are accepted; the last value wins (see BON8).

Complexity

Linear in the size of the input.

Examples

??? example

The example shows the deserialization of a byte vector in BON8 format to a JSON value.
 
```cpp
--8<-- "examples/from_bon8.cpp"
```

Output:

```json
--8<-- "examples/from_bon8.output"
```

Version history

Added in version 3.13.0.

!!! warning "Deprecation"

- Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
  deprecated in version 3.13.0. In version 4.0.0, this overload
  will be deleted (`= delete`) rather than removed. Please replace all calls like
  `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.

You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
function.

5.0 KiB Raw Blame History