wt/json

0 Fork 0

mirror of https://github.com/nlohmann/json.git synced 2026-10-16 10:39:42 +00:00

Files

T

Niels Lohmann 4001fe68b9 Fix silent wrong results for custom number types

Two bugs for custom number types that compile on develop (found while
analysing #3578):

- compare_integer_with_float() took the signedness of the integer type
  from std::is_signed, which is false for class types such as
  absl::int128 or boost::multiprecision::cpp_int. Any float below zero
  then compared less than every integer, e.g. json(int128(-5)) <
  json(-2.5) was false. The signedness now comes from
  std::numeric_limits, like the digits used for the range bound.

- With number_integer_t/number_unsigned_t wider than 64 bits (e.g.
  __int128), CBOR, MessagePack, and BSON silently truncated integers
  beyond 64 bits (to_cbor of 2^100 read back as 0), BJData truncated
  unsigned ones with the 'M' marker and could encode truncated ND-array
  elements and dimensions, and BON8 did not compile (std::to_string is
  ambiguous for __int128). The writers now throw out_of_range.407 when
  an integer does not fit the format's range ([-2^64, 2^64-1] for CBOR,
  [-2^63, 2^64-1] for MessagePack, int64/uint64 for BSON, int64 for
  BON8); BJData writes such unsigned values as high-precision numbers,
  as it already did for signed ones and UBJSON does for both, and falls
  back to a plain object for the ND-array. The checks use
  std::numeric_limits digits and compile away when the number types are
  at most 64 bits wide, so the default types pay nothing (the CBOR,
  MessagePack, and BSON writers compile to identical code).

The new unit-custom-number-types.cpp tests the comparison with a small
class-type integer and the writers with __int128 where the standard
library supports it as an integral type.

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

2026-10-10 16:55:26 +02:00

4.0 KiB

Raw Blame History

nlohmann::basic_json::to_cbor

// (1)
static std::vector<std::uint8_t> to_cbor(const basic_json& j,
                                          const error_handler_t error_handler = error_handler_t::keep);

// (2)
static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o,
                     const error_handler_t error_handler = error_handler_t::keep);
static void to_cbor(const basic_json& j, detail::output_adapter<char> o,
                     const error_handler_t error_handler = error_handler_t::keep);

Serializes a given JSON value j to a byte vector using the CBOR (Concise Binary Object Representation) serialization format. CBOR is a binary serialization format that aims to be more compact than JSON itself, yet more efficient to parse.

Returns a byte vector containing the CBOR serialization.
Writes the CBOR serialization to an output adapter.

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

Parameters

j (in): JSON value to serialize
o (in): output adapter to write serialization to
error_handler (in): how to treat a string or object key in j that is not valid UTF-8; see error_handler_t. The default, keep, writes the ill-formed bytes to the output as is, as every version of to_cbor did before this parameter was added; strict throws; replace/ignore sanitize it the same way dump would. If JSON_STRICT_BINARY_UTF8 is enabled, the default is strict instead.

Return value

CBOR serialization as a byte vector
(none)

Exception safety

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

Exceptions

Throws out_of_range.407 if j contains an integer outside [-2^64, 2^64-1], which is only possible with a number type wider than 64 bits; example: "integer number 18446744073709551616 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]"
Throws type_error.316 if a string or object key in j is not valid UTF-8 and error_handler is strict (the default only if JSON_STRICT_BINARY_UTF8 is enabled)
Throws type_error.321 if j or a value nested in it is discarded; example: "cannot serialize discarded value to CBOR"

Complexity

Linear in the size of the JSON value j.

Examples

??? example

The example shows the serialization of a JSON value to a byte vector in CBOR format.
 
```cpp
--8<-- "examples/to_cbor.cpp"
```

Output:

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

Version history

Added in version 2.0.9.
Compact representation of floating-point numbers added in version 3.8.0.
Added error_handler parameter in version 3.13.0. Its default, keep, writes the bytes of a string or object key that is not valid UTF-8 unchanged, as before; strict (the default if JSON_STRICT_BINARY_UTF8 is enabled) throws type_error.316.
Throws type_error.321 for a discarded value since version 3.13.0; previously, a discarded value nested in an array or object was silently skipped, producing invalid CBOR.
Throws out_of_range.407 for integers that do not fit 64 bits since version 3.13.0; previously, integers of a number type wider than 64 bits were silently truncated.

4.0 KiB Raw Blame History