diff --git a/include/nlohmann/detail/output/serializer.hpp b/include/nlohmann/detail/output/serializer.hpp index eeba0a9de..fff89f51c 100644 --- a/include/nlohmann/detail/output/serializer.hpp +++ b/include/nlohmann/detail/output/serializer.hpp @@ -636,7 +636,7 @@ class serializer put_literal("\"subtype\": "); if (binary.has_subtype()) { - dump_integer(binary.subtype()); + dump_subtype(binary.subtype()); } else { @@ -662,7 +662,7 @@ class serializer put_literal("],\"subtype\":"); if (binary.has_subtype()) { - dump_integer(binary.subtype()); + dump_subtype(binary.subtype()); put_char('}'); } else @@ -1883,6 +1883,40 @@ class serializer write_buffer_pos = pos; } + /*! + @brief dump the subtype of a binary value + + The subtype is a std::uint64_t, whatever the number types are. @ref + dump_integer converts its argument to the magnitude type of + number_unsigned_t, so it writes the subtype only if that type has at least + 64 bits; otherwise (it would truncate the subtype) the digits are written + one by one. + + @param[in] subtype the subtype to dump + */ + void dump_subtype(std::uint64_t subtype) + { + dump_subtype(subtype, std::integral_constant {}); + } + + void dump_subtype(std::uint64_t subtype, std::true_type /*magnitude has at least 64 bits*/) + { + dump_integer(subtype); + } + + void dump_subtype(std::uint64_t subtype, std::false_type /*magnitude has less than 64 bits*/) + { + std::array digits{{}}; // 2^64 - 1 has 20 digits + std::size_t start = digits.size(); + do + { + digits[--start] = static_cast('0' + (subtype % 10)); + subtype /= 10; + } + while (subtype != 0); + put_string(digits, start, digits.size()); + } + /*! @brief dump an integer @@ -2136,6 +2170,11 @@ class serializer static constexpr bool magnitude_has_at_most_64_bits = std::numeric_limits::is_specialized && std::numeric_limits::digits <= 64; + /// whether every std::uint64_t fits number_magnitude_t (then dump_integer + /// can write a binary subtype) + static constexpr bool magnitude_has_at_least_64_bits = std::numeric_limits::is_specialized + && std::numeric_limits::digits >= 64; + /// whether @a x fits 64 bits: always if number_magnitude_t has at most /// 64 bits (selected by type, as the comparison would be reported as /// always true), else compared diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp index 473bfa894..ad99819dc 100644 --- a/single_include/nlohmann/json.hpp +++ b/single_include/nlohmann/json.hpp @@ -38122,7 +38122,7 @@ class serializer put_literal("\"subtype\": "); if (binary.has_subtype()) { - dump_integer(binary.subtype()); + dump_subtype(binary.subtype()); } else { @@ -38148,7 +38148,7 @@ class serializer put_literal("],\"subtype\":"); if (binary.has_subtype()) { - dump_integer(binary.subtype()); + dump_subtype(binary.subtype()); put_char('}'); } else @@ -39369,6 +39369,40 @@ class serializer write_buffer_pos = pos; } + /*! + @brief dump the subtype of a binary value + + The subtype is a std::uint64_t, whatever the number types are. @ref + dump_integer converts its argument to the magnitude type of + number_unsigned_t, so it writes the subtype only if that type has at least + 64 bits; otherwise (it would truncate the subtype) the digits are written + one by one. + + @param[in] subtype the subtype to dump + */ + void dump_subtype(std::uint64_t subtype) + { + dump_subtype(subtype, std::integral_constant {}); + } + + void dump_subtype(std::uint64_t subtype, std::true_type /*magnitude has at least 64 bits*/) + { + dump_integer(subtype); + } + + void dump_subtype(std::uint64_t subtype, std::false_type /*magnitude has less than 64 bits*/) + { + std::array digits{{}}; // 2^64 - 1 has 20 digits + std::size_t start = digits.size(); + do + { + digits[--start] = static_cast('0' + (subtype % 10)); + subtype /= 10; + } + while (subtype != 0); + put_string(digits, start, digits.size()); + } + /*! @brief dump an integer @@ -39622,6 +39656,11 @@ class serializer static constexpr bool magnitude_has_at_most_64_bits = std::numeric_limits::is_specialized && std::numeric_limits::digits <= 64; + /// whether every std::uint64_t fits number_magnitude_t (then dump_integer + /// can write a binary subtype) + static constexpr bool magnitude_has_at_least_64_bits = std::numeric_limits::is_specialized + && std::numeric_limits::digits >= 64; + /// whether @a x fits 64 bits: always if number_magnitude_t has at most /// 64 bits (selected by type, as the comparison would be reported as /// always true), else compared diff --git a/tests/src/unit-custom-number-types.cpp b/tests/src/unit-custom-number-types.cpp index 58353d67e..09d716dc2 100644 --- a/tests/src/unit-custom-number-types.cpp +++ b/tests/src/unit-custom-number-types.cpp @@ -483,3 +483,25 @@ TEST_CASE("custom number types: 32-bit integers in the binary formats") CHECK(json32::to_msgpack(values) == nlohmann::json::to_msgpack(values64)); CHECK(json32::to_ubjson(values) == nlohmann::json::to_ubjson(values64)); } + +TEST_CASE("custom number types: binary subtypes wider than the integer types") +{ + // the subtype of a binary value is a std::uint64_t, whatever the number types are + using json8 = nlohmann::json::with_integers_t; + using json16 = nlohmann::json::with_integers_t; + using json32 = nlohmann::json::with_integers_t; + const std::uint64_t max_uint64 = (std::numeric_limits::max)(); + + CHECK(json8::binary({1}, 300).dump() == "{\"bytes\":[1],\"subtype\":300}"); + CHECK(json8::binary({200}, 255).dump() == "{\"bytes\":[200],\"subtype\":255}"); + CHECK(json16::binary({1}, 65543).dump() == "{\"bytes\":[1],\"subtype\":65543}"); + CHECK(json32::binary({1}, 4294967301u).dump() == "{\"bytes\":[1],\"subtype\":4294967301}"); + CHECK(json32::binary({1}, max_uint64).dump() == "{\"bytes\":[1],\"subtype\":18446744073709551615}"); + CHECK(json32::binary({1}, 0).dump() == "{\"bytes\":[1],\"subtype\":0}"); + CHECK(json32::binary({1}, 4294967301u).dump(1) == "{\n \"bytes\": [1],\n \"subtype\": 4294967301\n}"); + CHECK(json8::binary({1}).dump() == "{\"bytes\":[1],\"subtype\":null}"); + + // unchanged for the default number types + CHECK(nlohmann::json::binary({1}, 4294967301u).dump() == "{\"bytes\":[1],\"subtype\":4294967301}"); + CHECK(nlohmann::json::binary({1}, max_uint64).dump(1) == "{\n \"bytes\": [1],\n \"subtype\": 18446744073709551615\n}"); +}