MadeOfJelly/MushMachine
MadeOfJelly/MushMachine
2
2
Fork 0
mirror of https://github.com/MadeOfJelly/MushMachine.git synced 2024-10-30 06:45:36 +01:00
Code Issues Projects Releases Wiki Activity
3a885ee250
MushMachine/external/json/include/nlohmann/detail/output/binary_writer.hpp

1839 lines
68 KiB
C++
Raw Normal View History

update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
// __ _____ _____ _____
// __| | __| | | | JSON for Modern C++
update nlohmann::json to v3.11.2
2022-10-30 02:36:30 +02:00
// | | |__ | | | | | | version 3.11.2
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
#pragma once
#include <algorithm> // reverse
#include <array> // array
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
#include <map> // map
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
#include <cmath> // isnan, isinf
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
#include <cstring> // memcpy
#include <limits> // numeric_limits
#include <string> // string
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
#include <utility> // move
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
#include <vector> // vector
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
#include <nlohmann/detail/input/binary_reader.hpp>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/output/output_adapters.hpp>
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
#include <nlohmann/detail/string_concat.hpp>
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
NLOHMANN_JSON_NAMESPACE_BEGIN
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
namespace detail
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
///////////////////
// binary writer //
///////////////////
/*!
@brief serialization to CBOR and MessagePack values
*/
template<typename BasicJsonType, typename CharType>
class binary_writer
{
using string_t = typename BasicJsonType::string_t;
using binary_t = typename BasicJsonType::binary_t;
using number_float_t = typename BasicJsonType::number_float_t;
public:
/*!
@brief create a binary writer
@param[in] adapter output adapter to write to
*/
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
JSON_ASSERT(oa);
}
/*!
@param[in] j JSON value to serialize
@pre j.type() == value_t::object
*/
void write_bson(const BasicJsonType& j)
{
switch (j.type())
{
case value_t::object:
{
write_bson_object(*j.m_value.object);
break;
}
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
case value_t::null:
case value_t::array:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
default:
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
}
}
/*!
@param[in] j JSON value to serialize
*/
void write_cbor(const BasicJsonType& j)
{
switch (j.type())
{
case value_t::null:
{
oa->write_character(to_char_type(0xF6));
break;
}
case value_t::boolean:
{
oa->write_character(j.m_value.boolean
? to_char_type(0xF5)
: to_char_type(0xF4));
break;
}
case value_t::number_integer:
{
if (j.m_value.number_integer >= 0)
{
// CBOR does not differentiate between positive signed
// integers and unsigned integers. Therefore, we used the
// code from the value_t::number_unsigned case here.
if (j.m_value.number_integer <= 0x17)
{
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x18));
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x19));
write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x1A));
write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
else
{
oa->write_character(to_char_type(0x1B));
write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
}
else
{
// The conversions below encode the sign in the first
// byte, and the value is converted to a positive number.
const auto positive_number = -1 - j.m_value.number_integer;
if (j.m_value.number_integer >= -24)
{
write_number(static_cast<std::uint8_t>(0x20 + positive_number));
}
else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x38));
write_number(static_cast<std::uint8_t>(positive_number));
}
else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x39));
write_number(static_cast<std::uint16_t>(positive_number));
}
else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x3A));
write_number(static_cast<std::uint32_t>(positive_number));
}
else
{
oa->write_character(to_char_type(0x3B));
write_number(static_cast<std::uint64_t>(positive_number));
}
}
break;
}
case value_t::number_unsigned:
{
if (j.m_value.number_unsigned <= 0x17)
{
write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x18));
write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x19));
write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x1A));
write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
}
else
{
oa->write_character(to_char_type(0x1B));
write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
}
break;
}
case value_t::number_float:
{
if (std::isnan(j.m_value.number_float))
{
// NaN is 0xf97e00 in CBOR
oa->write_character(to_char_type(0xF9));
oa->write_character(to_char_type(0x7E));
oa->write_character(to_char_type(0x00));
}
else if (std::isinf(j.m_value.number_float))
{
// Infinity is 0xf97c00, -Infinity is 0xf9fc00
oa->write_character(to_char_type(0xf9));
oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
oa->write_character(to_char_type(0x00));
}
else
{
write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
}
break;
}
case value_t::string:
{
// step 1: write control byte and the string length
const auto N = j.m_value.string->size();
if (N <= 0x17)
{
write_number(static_cast<std::uint8_t>(0x60 + N));
}
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x78));
write_number(static_cast<std::uint8_t>(N));
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x79));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x7A));
write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0x7B));
write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
// step 2: write the string
oa->write_characters(
reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
j.m_value.string->size());
break;
}
case value_t::array:
{
// step 1: write control byte and the array size
const auto N = j.m_value.array->size();
if (N <= 0x17)
{
write_number(static_cast<std::uint8_t>(0x80 + N));
}
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x98));
write_number(static_cast<std::uint8_t>(N));
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x99));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x9A));
write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0x9B));
write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
// step 2: write each element
for (const auto& el : *j.m_value.array)
{
write_cbor(el);
}
break;
}
case value_t::binary:
{
if (j.m_value.binary->has_subtype())
{
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
{
write_number(static_cast<std::uint8_t>(0xd8));
write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));
}
else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
{
write_number(static_cast<std::uint8_t>(0xd9));
write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));
}
else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
{
write_number(static_cast<std::uint8_t>(0xda));
write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));
}
else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
{
write_number(static_cast<std::uint8_t>(0xdb));
write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
// step 1: write control byte and the binary array size
const auto N = j.m_value.binary->size();
if (N <= 0x17)
{
write_number(static_cast<std::uint8_t>(0x40 + N));
}
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x58));
write_number(static_cast<std::uint8_t>(N));
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x59));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x5A));
write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0x5B));
write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
// step 2: write each element
oa->write_characters(
reinterpret_cast<const CharType*>(j.m_value.binary->data()),
N);
break;
}
case value_t::object:
{
// step 1: write control byte and the object size
const auto N = j.m_value.object->size();
if (N <= 0x17)
{
write_number(static_cast<std::uint8_t>(0xA0 + N));
}
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0xB8));
write_number(static_cast<std::uint8_t>(N));
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0xB9));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0xBA));
write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0xBB));
write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
// step 2: write each element
for (const auto& el : *j.m_value.object)
{
write_cbor(el.first);
write_cbor(el.second);
}
break;
}
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
case value_t::discarded:
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
default:
break;
}
}
/*!
@param[in] j JSON value to serialize
*/
void write_msgpack(const BasicJsonType& j)
{
switch (j.type())
{
case value_t::null: // nil
{
oa->write_character(to_char_type(0xC0));
break;
}
case value_t::boolean: // true and false
{
oa->write_character(j.m_value.boolean
? to_char_type(0xC3)
: to_char_type(0xC2));
break;
}
case value_t::number_integer:
{
if (j.m_value.number_integer >= 0)
{
// MessagePack does not differentiate between positive
// signed integers and unsigned integers. Therefore, we used
// the code from the value_t::number_unsigned case here.
if (j.m_value.number_unsigned < 128)
{
// positive fixnum
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
// uint 8
oa->write_character(to_char_type(0xCC));
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
// uint 16
oa->write_character(to_char_type(0xCD));
write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
// uint 32
oa->write_character(to_char_type(0xCE));
write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
{
// uint 64
oa->write_character(to_char_type(0xCF));
write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
}
else
{
if (j.m_value.number_integer >= -32)
{
// negative fixnum
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
// int 8
oa->write_character(to_char_type(0xD0));
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
// int 16
oa->write_character(to_char_type(0xD1));
write_number(static_cast<std::int16_t>(j.m_value.number_integer));
}
else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
// int 32
oa->write_character(to_char_type(0xD2));
write_number(static_cast<std::int32_t>(j.m_value.number_integer));
}
else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
{
// int 64
oa->write_character(to_char_type(0xD3));
write_number(static_cast<std::int64_t>(j.m_value.number_integer));
}
}
break;
}
case value_t::number_unsigned:
{
if (j.m_value.number_unsigned < 128)
{
// positive fixnum
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
// uint 8
oa->write_character(to_char_type(0xCC));
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
// uint 16
oa->write_character(to_char_type(0xCD));
write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
// uint 32
oa->write_character(to_char_type(0xCE));
write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
{
// uint 64
oa->write_character(to_char_type(0xCF));
write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
break;
}
case value_t::number_float:
{
write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
break;
}
case value_t::string:
{
// step 1: write control byte and the string length
const auto N = j.m_value.string->size();
if (N <= 31)
{
// fixstr
write_number(static_cast<std::uint8_t>(0xA0 | N));
}
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
// str 8
oa->write_character(to_char_type(0xD9));
write_number(static_cast<std::uint8_t>(N));
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// str 16
oa->write_character(to_char_type(0xDA));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// str 32
oa->write_character(to_char_type(0xDB));
write_number(static_cast<std::uint32_t>(N));
}
// step 2: write the string
oa->write_characters(
reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
j.m_value.string->size());
break;
}
case value_t::array:
{
// step 1: write control byte and the array size
const auto N = j.m_value.array->size();
if (N <= 15)
{
// fixarray
write_number(static_cast<std::uint8_t>(0x90 | N));
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// array 16
oa->write_character(to_char_type(0xDC));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// array 32
oa->write_character(to_char_type(0xDD));
write_number(static_cast<std::uint32_t>(N));
}
// step 2: write each element
for (const auto& el : *j.m_value.array)
{
write_msgpack(el);
}
break;
}
case value_t::binary:
{
// step 0: determine if the binary type has a set subtype to
// determine whether or not to use the ext or fixext types
const bool use_ext = j.m_value.binary->has_subtype();
// step 1: write control byte and the byte string length
const auto N = j.m_value.binary->size();
if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
std::uint8_t output_type{};
bool fixed = true;
if (use_ext)
{
switch (N)
{
case 1:
output_type = 0xD4; // fixext 1
break;
case 2:
output_type = 0xD5; // fixext 2
break;
case 4:
output_type = 0xD6; // fixext 4
break;
case 8:
output_type = 0xD7; // fixext 8
break;
case 16:
output_type = 0xD8; // fixext 16
break;
default:
output_type = 0xC7; // ext 8
fixed = false;
break;
}
}
else
{
output_type = 0xC4; // bin 8
fixed = false;
}
oa->write_character(to_char_type(output_type));
if (!fixed)
{
write_number(static_cast<std::uint8_t>(N));
}
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
std::uint8_t output_type = use_ext
? 0xC8 // ext 16
: 0xC5; // bin 16
oa->write_character(to_char_type(output_type));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
std::uint8_t output_type = use_ext
? 0xC9 // ext 32
: 0xC6; // bin 32
oa->write_character(to_char_type(output_type));
write_number(static_cast<std::uint32_t>(N));
}
// step 1.5: if this is an ext type, write the subtype
if (use_ext)
{
write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
}
// step 2: write the byte string
oa->write_characters(
reinterpret_cast<const CharType*>(j.m_value.binary->data()),
N);
break;
}
case value_t::object:
{
// step 1: write control byte and the object size
const auto N = j.m_value.object->size();
if (N <= 15)
{
// fixmap
write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
}
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// map 16
oa->write_character(to_char_type(0xDE));
write_number(static_cast<std::uint16_t>(N));
}
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// map 32
oa->write_character(to_char_type(0xDF));
write_number(static_cast<std::uint32_t>(N));
}
// step 2: write each element
for (const auto& el : *j.m_value.object)
{
write_msgpack(el.first);
write_msgpack(el.second);
}
break;
}
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
case value_t::discarded:
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
default:
break;
}
}
/*!
@param[in] j JSON value to serialize
@param[in] use_count whether to use '#' prefixes (optimized format)
@param[in] use_type whether to use '$' prefixes (optimized format)
@param[in] add_prefix whether prefixes need to be used for this value
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
@param[in] use_bjdata whether write in BJData format, default is false
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
*/
void write_ubjson(const BasicJsonType& j, const bool use_count,
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
const bool use_type, const bool add_prefix = true,
const bool use_bjdata = false)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
switch (j.type())
{
case value_t::null:
{
if (add_prefix)
{
oa->write_character(to_char_type('Z'));
}
break;
}
case value_t::boolean:
{
if (add_prefix)
{
oa->write_character(j.m_value.boolean
? to_char_type('T')
: to_char_type('F'));
}
break;
}
case value_t::number_integer:
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
break;
}
case value_t::number_unsigned:
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
break;
}
case value_t::number_float:
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
break;
}
case value_t::string:
{
if (add_prefix)
{
oa->write_character(to_char_type('S'));
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(j.m_value.string->size(), true, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
oa->write_characters(
reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
j.m_value.string->size());
break;
}
case value_t::array:
{
if (add_prefix)
{
oa->write_character(to_char_type('['));
}
bool prefix_required = true;
if (use_type && !j.m_value.array->empty())
{
JSON_ASSERT(use_count);
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
[this, first_prefix, use_bjdata](const BasicJsonType & v)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
return ubjson_prefix(v, use_bjdata) == first_prefix;
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
});
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
prefix_required = false;
oa->write_character(to_char_type('$'));
oa->write_character(first_prefix);
}
}
if (use_count)
{
oa->write_character(to_char_type('#'));
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(j.m_value.array->size(), true, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
for (const auto& el : *j.m_value.array)
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
if (!use_count)
{
oa->write_character(to_char_type(']'));
}
break;
}
case value_t::binary:
{
if (add_prefix)
{
oa->write_character(to_char_type('['));
}
if (use_type && !j.m_value.binary->empty())
{
JSON_ASSERT(use_count);
oa->write_character(to_char_type('$'));
oa->write_character('U');
}
if (use_count)
{
oa->write_character(to_char_type('#'));
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(j.m_value.binary->size(), true, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
if (use_type)
{
oa->write_characters(
reinterpret_cast<const CharType*>(j.m_value.binary->data()),
j.m_value.binary->size());
}
else
{
for (size_t i = 0; i < j.m_value.binary->size(); ++i)
{
oa->write_character(to_char_type('U'));
oa->write_character(j.m_value.binary->data()[i]);
}
}
if (!use_count)
{
oa->write_character(to_char_type(']'));
}
break;
}
case value_t::object:
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
if (use_bjdata && j.m_value.object->size() == 3 && j.m_value.object->find("_ArrayType_") != j.m_value.object->end() && j.m_value.object->find("_ArraySize_") != j.m_value.object->end() && j.m_value.object->find("_ArrayData_") != j.m_value.object->end())
{
if (!write_bjdata_ndarray(*j.m_value.object, use_count, use_type)) // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
{
break;
}
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
if (add_prefix)
{
oa->write_character(to_char_type('{'));
}
bool prefix_required = true;
if (use_type && !j.m_value.object->empty())
{
JSON_ASSERT(use_count);
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
const bool same_prefix = std::all_of(j.begin(), j.end(),
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
[this, first_prefix, use_bjdata](const BasicJsonType & v)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
return ubjson_prefix(v, use_bjdata) == first_prefix;
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
});
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
prefix_required = false;
oa->write_character(to_char_type('$'));
oa->write_character(first_prefix);
}
}
if (use_count)
{
oa->write_character(to_char_type('#'));
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(j.m_value.object->size(), true, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
for (const auto& el : *j.m_value.object)
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
oa->write_characters(
reinterpret_cast<const CharType*>(el.first.c_str()),
el.first.size());
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
if (!use_count)
{
oa->write_character(to_char_type('}'));
}
break;
}
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
case value_t::discarded:
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
default:
break;
}
}
private:
//////////
// BSON //
//////////
/*!
@return The size of a BSON document entry header, including the id marker
and the entry name size (and its null-terminator).
*/
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
const auto it = name.find(static_cast<typename string_t::value_type>(0));
if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
static_cast<void>(j);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
}
/*!
@brief Writes the given @a element_type and @a name to the output adapter
*/
void write_bson_entry_header(const string_t& name,
const std::uint8_t element_type)
{
oa->write_character(to_char_type(element_type)); // boolean
oa->write_characters(
reinterpret_cast<const CharType*>(name.c_str()),
name.size() + 1u);
}
/*!
@brief Writes a BSON element with key @a name and boolean value @a value
*/
void write_bson_boolean(const string_t& name,
const bool value)
{
write_bson_entry_header(name, 0x08);
oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
}
/*!
@brief Writes a BSON element with key @a name and double value @a value
*/
void write_bson_double(const string_t& name,
const double value)
{
write_bson_entry_header(name, 0x01);
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<double>(value, true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
/*!
@return The size of the BSON-encoded string in @a value
*/
static std::size_t calc_bson_string_size(const string_t& value)
{
return sizeof(std::int32_t) + value.size() + 1ul;
}
/*!
@brief Writes a BSON element with key @a name and string value @a value
*/
void write_bson_string(const string_t& name,
const string_t& value)
{
write_bson_entry_header(name, 0x02);
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
oa->write_characters(
reinterpret_cast<const CharType*>(value.c_str()),
value.size() + 1);
}
/*!
@brief Writes a BSON element with key @a name and null value
*/
void write_bson_null(const string_t& name)
{
write_bson_entry_header(name, 0x0A);
}
/*!
@return The size of the BSON-encoded integer @a value
*/
static std::size_t calc_bson_integer_size(const std::int64_t value)
{
return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
? sizeof(std::int32_t)
: sizeof(std::int64_t);
}
/*!
@brief Writes a BSON element with key @a name and integer @a value
*/
void write_bson_integer(const string_t& name,
const std::int64_t value)
{
if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
{
write_bson_entry_header(name, 0x10); // int32
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else
{
write_bson_entry_header(name, 0x12); // int64
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
}
/*!
@return The size of the BSON-encoded unsigned integer in @a j
*/
static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
{
return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
? sizeof(std::int32_t)
: sizeof(std::int64_t);
}
/*!
@brief Writes a BSON element with key @a name and unsigned @a value
*/
void write_bson_unsigned(const string_t& name,
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
const BasicJsonType& j)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
write_bson_entry_header(name, 0x10 /* int32 */);
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int32_t>(static_cast<std::int32_t>(j.m_value.number_unsigned), true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
write_bson_entry_header(name, 0x12 /* int64 */);
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int64_t>(static_cast<std::int64_t>(j.m_value.number_unsigned), true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
}
/*!
@brief Writes a BSON element with key @a name and object @a value
*/
void write_bson_object_entry(const string_t& name,
const typename BasicJsonType::object_t& value)
{
write_bson_entry_header(name, 0x03); // object
write_bson_object(value);
}
/*!
@return The size of the BSON-encoded array @a value
*/
static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
{
std::size_t array_index = 0ul;
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
return result + calc_bson_element_size(std::to_string(array_index++), el);
});
return sizeof(std::int32_t) + embedded_document_size + 1ul;
}
/*!
@return The size of the BSON-encoded binary array @a value
*/
static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
{
return sizeof(std::int32_t) + value.size() + 1ul;
}
/*!
@brief Writes a BSON element with key @a name and array @a value
*/
void write_bson_array(const string_t& name,
const typename BasicJsonType::array_t& value)
{
write_bson_entry_header(name, 0x04); // array
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
std::size_t array_index = 0ul;
for (const auto& el : value)
{
write_bson_element(std::to_string(array_index++), el);
}
oa->write_character(to_char_type(0x00));
}
/*!
@brief Writes a BSON element with key @a name and binary value @a value
*/
void write_bson_binary(const string_t& name,
const binary_t& value)
{
write_bson_entry_header(name, 0x05);
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
}
/*!
@brief Calculates the size necessary to serialize the JSON value @a j with its @a name
@return The calculated size for the BSON document entry for @a j with the given @a name.
*/
static std::size_t calc_bson_element_size(const string_t& name,
const BasicJsonType& j)
{
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
const auto header_size = calc_bson_entry_header_size(name, j);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
switch (j.type())
{
case value_t::object:
return header_size + calc_bson_object_size(*j.m_value.object);
case value_t::array:
return header_size + calc_bson_array_size(*j.m_value.array);
case value_t::binary:
return header_size + calc_bson_binary_size(*j.m_value.binary);
case value_t::boolean:
return header_size + 1ul;
case value_t::number_float:
return header_size + 8ul;
case value_t::number_integer:
return header_size + calc_bson_integer_size(j.m_value.number_integer);
case value_t::number_unsigned:
return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
case value_t::string:
return header_size + calc_bson_string_size(*j.m_value.string);
case value_t::null:
return header_size + 0ul;
// LCOV_EXCL_START
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
case value_t::discarded:
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
default:
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
return 0ul;
// LCOV_EXCL_STOP
}
}
/*!
@brief Serializes the JSON value @a j to BSON and associates it with the
key @a name.
@param name The name to associate with the JSON entity @a j within the
current BSON document
*/
void write_bson_element(const string_t& name,
const BasicJsonType& j)
{
switch (j.type())
{
case value_t::object:
return write_bson_object_entry(name, *j.m_value.object);
case value_t::array:
return write_bson_array(name, *j.m_value.array);
case value_t::binary:
return write_bson_binary(name, *j.m_value.binary);
case value_t::boolean:
return write_bson_boolean(name, j.m_value.boolean);
case value_t::number_float:
return write_bson_double(name, j.m_value.number_float);
case value_t::number_integer:
return write_bson_integer(name, j.m_value.number_integer);
case value_t::number_unsigned:
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
return write_bson_unsigned(name, j);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
case value_t::string:
return write_bson_string(name, *j.m_value.string);
case value_t::null:
return write_bson_null(name);
// LCOV_EXCL_START
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
case value_t::discarded:
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
default:
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
return;
// LCOV_EXCL_STOP
}
}
/*!
@brief Calculates the size of the BSON serialization of the given
JSON-object @a j.
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
@param[in] value JSON value to serialize
@pre value.type() == value_t::object
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
*/
static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
[](size_t result, const typename BasicJsonType::object_t::value_type & el)
{
return result += calc_bson_element_size(el.first, el.second);
});
return sizeof(std::int32_t) + document_size + 1ul;
}
/*!
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
@param[in] value JSON value to serialize
@pre value.type() == value_t::object
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
*/
void write_bson_object(const typename BasicJsonType::object_t& value)
{
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
for (const auto& el : value)
{
write_bson_element(el.first, el.second);
}
oa->write_character(to_char_type(0x00));
}
//////////
// CBOR //
//////////
static constexpr CharType get_cbor_float_prefix(float /*unused*/)
{
return to_char_type(0xFA); // Single-Precision Float
}
static constexpr CharType get_cbor_float_prefix(double /*unused*/)
{
return to_char_type(0xFB); // Double-Precision Float
}
/////////////
// MsgPack //
/////////////
static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
{
return to_char_type(0xCA); // float 32
}
static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
{
return to_char_type(0xCB); // float 64
}
////////////
// UBJSON //
////////////
// UBJSON: write number (floating point)
template<typename NumberType, typename std::enable_if<
std::is_floating_point<NumberType>::value, int>::type = 0>
void write_number_with_ubjson_prefix(const NumberType n,
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
const bool add_prefix,
const bool use_bjdata)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
if (add_prefix)
{
oa->write_character(get_ubjson_float_prefix(n));
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(n, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
// UBJSON: write number (unsigned integer)
template<typename NumberType, typename std::enable_if<
std::is_unsigned<NumberType>::value, int>::type = 0>
void write_number_with_ubjson_prefix(const NumberType n,
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
const bool add_prefix,
const bool use_bjdata)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('i')); // int8
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::uint8_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if (n <= (std::numeric_limits<std::uint8_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('U')); // uint8
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::uint8_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('I')); // int16
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::int16_t>(n), use_bjdata);
}
else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('u')); // uint16 - bjdata only
}
write_number(static_cast<std::uint16_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('l')); // int32
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::int32_t>(n), use_bjdata);
}
else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('m')); // uint32 - bjdata only
}
write_number(static_cast<std::uint32_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('L')); // int64
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::int64_t>(n), use_bjdata);
}
else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('M')); // uint64 - bjdata only
}
write_number(static_cast<std::uint64_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else
{
if (add_prefix)
{
oa->write_character(to_char_type('H')); // high-precision number
}
const auto number = BasicJsonType(n).dump();
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
for (std::size_t i = 0; i < number.size(); ++i)
{
oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
}
}
}
// UBJSON: write number (signed integer)
template < typename NumberType, typename std::enable_if <
std::is_signed<NumberType>::value&&
!std::is_floating_point<NumberType>::value, int >::type = 0 >
void write_number_with_ubjson_prefix(const NumberType n,
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
const bool add_prefix,
const bool use_bjdata)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('i')); // int8
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::int8_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('U')); // uint8
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::uint8_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('I')); // int16
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::int16_t>(n), use_bjdata);
}
else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
{
if (add_prefix)
{
oa->write_character(to_char_type('u')); // uint16 - bjdata only
}
write_number(static_cast<uint16_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('l')); // int32
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::int32_t>(n), use_bjdata);
}
else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
{
if (add_prefix)
{
oa->write_character(to_char_type('m')); // uint32 - bjdata only
}
write_number(static_cast<uint32_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('L')); // int64
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number(static_cast<std::int64_t>(n), use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
// LCOV_EXCL_START
else
{
if (add_prefix)
{
oa->write_character(to_char_type('H')); // high-precision number
}
const auto number = BasicJsonType(n).dump();
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
for (std::size_t i = 0; i < number.size(); ++i)
{
oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
}
}
// LCOV_EXCL_STOP
}
/*!
@brief determine the type prefix of container values
*/
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
switch (j.type())
{
case value_t::null:
return 'Z';
case value_t::boolean:
return j.m_value.boolean ? 'T' : 'F';
case value_t::number_integer:
{
if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
{
return 'u';
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
{
return 'm';
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
{
return 'L';
}
// anything else is treated as high-precision number
return 'H'; // LCOV_EXCL_LINE
}
case value_t::number_unsigned:
{
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
{
return 'i';
}
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
{
return 'U';
}
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
{
return 'I';
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
{
return 'u';
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
{
return 'l';
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
{
return 'm';
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
{
return 'L';
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
if (use_bjdata && j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
{
return 'M';
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
// anything else is treated as high-precision number
return 'H'; // LCOV_EXCL_LINE
}
case value_t::number_float:
return get_ubjson_float_prefix(j.m_value.number_float);
case value_t::string:
return 'S';
case value_t::array: // fallthrough
case value_t::binary:
return '[';
case value_t::object:
return '{';
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
case value_t::discarded:
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
default: // discarded values
return 'N';
}
}
static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
{
return 'd'; // float 32
}
static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
{
return 'D'; // float 64
}
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
/*!
@return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
*/
bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)
{
std::map<string_t, CharType> bjdtype = {{"uint8", 'U'}, {"int8", 'i'}, {"uint16", 'u'}, {"int16", 'I'},
{"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'}
};
string_t key = "_ArrayType_";
auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
if (it == bjdtype.end())
{
return true;
}
CharType dtype = it->second;
key = "_ArraySize_";
std::size_t len = (value.at(key).empty() ? 0 : 1);
for (const auto& el : value.at(key))
{
len *= static_cast<std::size_t>(el.m_value.number_unsigned);
}
key = "_ArrayData_";
if (value.at(key).size() != len)
{
return true;
}
oa->write_character('[');
oa->write_character('$');
oa->write_character(dtype);
oa->write_character('#');
key = "_ArraySize_";
write_ubjson(value.at(key), use_count, use_type, true, true);
key = "_ArrayData_";
if (dtype == 'U' || dtype == 'C')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::uint8_t>(el.m_value.number_unsigned), true);
}
}
else if (dtype == 'i')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::int8_t>(el.m_value.number_integer), true);
}
}
else if (dtype == 'u')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::uint16_t>(el.m_value.number_unsigned), true);
}
}
else if (dtype == 'I')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::int16_t>(el.m_value.number_integer), true);
}
}
else if (dtype == 'm')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::uint32_t>(el.m_value.number_unsigned), true);
}
}
else if (dtype == 'l')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::int32_t>(el.m_value.number_integer), true);
}
}
else if (dtype == 'M')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::uint64_t>(el.m_value.number_unsigned), true);
}
}
else if (dtype == 'L')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<std::int64_t>(el.m_value.number_integer), true);
}
}
else if (dtype == 'd')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<float>(el.m_value.number_float), true);
}
}
else if (dtype == 'D')
{
for (const auto& el : value.at(key))
{
write_number(static_cast<double>(el.m_value.number_float), true);
}
}
return false;
}
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
///////////////////////
// Utility functions //
///////////////////////
/*
@brief write a number to output input
@param[in] n number of type @a NumberType
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
@param[in] OutputIsLittleEndian Set to true if output data is
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
required to be little endian
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
@tparam NumberType the type of the number
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
@note This function needs to respect the system's endianness, because bytes
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
in CBOR, MessagePack, and UBJSON are stored in network order (big
endian) and therefore need reordering on little endian systems.
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
On the other hand, BSON and BJData use little endian and should reorder
on big endian systems.
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
*/
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
template<typename NumberType>
void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
{
// step 1: write number to array of length NumberType
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
std::array<CharType, sizeof(NumberType)> vec{};
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
std::memcpy(vec.data(), &n, sizeof(NumberType));
// step 2: write array to output (with possible reordering)
if (is_little_endian != OutputIsLittleEndian)
{
// reverse byte order prior to conversion if necessary
std::reverse(vec.begin(), vec.end());
}
oa->write_characters(vec.data(), sizeof(NumberType));
}
void write_compact_float(const number_float_t n, detail::input_format_t format)
{
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
{
oa->write_character(format == detail::input_format_t::cbor
? get_cbor_float_prefix(static_cast<float>(n))
: get_msgpack_float_prefix(static_cast<float>(n)));
write_number(static_cast<float>(n));
}
else
{
oa->write_character(format == detail::input_format_t::cbor
? get_cbor_float_prefix(n)
: get_msgpack_float_prefix(n));
write_number(n);
}
update nlohmann::json to 3.10.4
2021-12-11 23:32:21 +01:00
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
}
public:
// The following to_char_type functions are implement the conversion
// between uint8_t and CharType. In case CharType is not unsigned,
// such a conversion is required to allow values greater than 128.
// See <https://github.com/nlohmann/json/issues/1286> for a discussion.
template < typename C = CharType,
enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
static constexpr CharType to_char_type(std::uint8_t x) noexcept
{
return *reinterpret_cast<char*>(&x);
}
template < typename C = CharType,
enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
static CharType to_char_type(std::uint8_t x) noexcept
{
static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
CharType result;
std::memcpy(&result, &x, sizeof(x));
return result;
}
template<typename C = CharType,
enable_if_t<std::is_unsigned<C>::value>* = nullptr>
static constexpr CharType to_char_type(std::uint8_t x) noexcept
{
return x;
}
template < typename InputCharType, typename C = CharType,
enable_if_t <
std::is_signed<C>::value &&
std::is_signed<char>::value &&
std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
> * = nullptr >
static constexpr CharType to_char_type(InputCharType x) noexcept
{
return x;
}
private:
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
/// whether we can assume little endianness
const bool is_little_endian = little_endianness();
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
/// the output
output_adapter_t<CharType> oa = nullptr;
};
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
initial import, >900commits predate this
2020-09-29 13:47:50 +02:00
} // namespace detail
update nlohmann::json to v3.11.1
2022-08-02 14:28:39 +02:00
NLOHMANN_JSON_NAMESPACE_END
Reference in New Issue Copy Permalink