#pragma once #include // reverse #include // array #include // uint8_t, uint16_t, uint32_t, uint64_t #include // memcpy #include // numeric_limits #include #include namespace nlohmann { namespace detail { /////////////////// // binary writer // /////////////////// /*! @brief serialization to CBOR and MessagePack values */ template class binary_writer { public: /*! @brief create a binary writer @param[in] adapter output adapter to write to */ explicit binary_writer(output_adapter_t adapter) : oa(adapter) { assert(oa); } /*! @brief[in] j JSON value to serialize */ void write_cbor(const BasicJsonType& j) { switch (j.type()) { case value_t::null: { oa->write_character(static_cast(0xF6)); break; } case value_t::boolean: { oa->write_character(j.m_value.boolean ? static_cast(0xF5) : static_cast(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(j.m_value.number_integer)); } else if (j.m_value.number_integer <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x18)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_integer <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x19)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_integer <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x1A)); write_number(static_cast(j.m_value.number_integer)); } else { oa->write_character(static_cast(0x1B)); write_number(static_cast(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(0x20 + positive_number)); } else if (positive_number <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x38)); write_number(static_cast(positive_number)); } else if (positive_number <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x39)); write_number(static_cast(positive_number)); } else if (positive_number <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x3A)); write_number(static_cast(positive_number)); } else { oa->write_character(static_cast(0x3B)); write_number(static_cast(positive_number)); } } break; } case value_t::number_unsigned: { if (j.m_value.number_unsigned <= 0x17) { write_number(static_cast(j.m_value.number_unsigned)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x18)); write_number(static_cast(j.m_value.number_unsigned)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x19)); write_number(static_cast(j.m_value.number_unsigned)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x1A)); write_number(static_cast(j.m_value.number_unsigned)); } else { oa->write_character(static_cast(0x1B)); write_number(static_cast(j.m_value.number_unsigned)); } break; } case value_t::number_float: { oa->write_character(get_cbor_float_prefix(j.m_value.number_float)); write_number(j.m_value.number_float); 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(0x60 + N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x78)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x79)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x7A)); write_number(static_cast(N)); } // LCOV_EXCL_START else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x7B)); write_number(static_cast(N)); } // LCOV_EXCL_STOP // step 2: write the string oa->write_characters( reinterpret_cast(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(0x80 + N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x98)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x99)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x9A)); write_number(static_cast(N)); } // LCOV_EXCL_START else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x9B)); write_number(static_cast(N)); } // LCOV_EXCL_STOP // step 2: write each element for (const auto& el : *j.m_value.array) { write_cbor(el); } 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(0xA0 + N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0xB8)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0xB9)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0xBA)); write_number(static_cast(N)); } // LCOV_EXCL_START else if (N <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0xBB)); write_number(static_cast(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; } default: break; } } /*! @brief[in] j JSON value to serialize */ void write_msgpack(const BasicJsonType& j) { switch (j.type()) { case value_t::null: // nil { oa->write_character(static_cast(0xC0)); break; } case value_t::boolean: // true and false { oa->write_character(j.m_value.boolean ? static_cast(0xC3) : static_cast(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(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 8 oa->write_character(static_cast(0xCC)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 16 oa->write_character(static_cast(0xCD)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 32 oa->write_character(static_cast(0xCE)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 64 oa->write_character(static_cast(0xCF)); write_number(static_cast(j.m_value.number_integer)); } } else { if (j.m_value.number_integer >= -32) { // negative fixnum write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_integer >= (std::numeric_limits::min)() and j.m_value.number_integer <= (std::numeric_limits::max)()) { // int 8 oa->write_character(static_cast(0xD0)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_integer >= (std::numeric_limits::min)() and j.m_value.number_integer <= (std::numeric_limits::max)()) { // int 16 oa->write_character(static_cast(0xD1)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_integer >= (std::numeric_limits::min)() and j.m_value.number_integer <= (std::numeric_limits::max)()) { // int 32 oa->write_character(static_cast(0xD2)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_integer >= (std::numeric_limits::min)() and j.m_value.number_integer <= (std::numeric_limits::max)()) { // int 64 oa->write_character(static_cast(0xD3)); write_number(static_cast(j.m_value.number_integer)); } } break; } case value_t::number_unsigned: { if (j.m_value.number_unsigned < 128) { // positive fixnum write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 8 oa->write_character(static_cast(0xCC)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 16 oa->write_character(static_cast(0xCD)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 32 oa->write_character(static_cast(0xCE)); write_number(static_cast(j.m_value.number_integer)); } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { // uint 64 oa->write_character(static_cast(0xCF)); write_number(static_cast(j.m_value.number_integer)); } break; } case value_t::number_float: { oa->write_character(get_msgpack_float_prefix(j.m_value.number_float)); write_number(j.m_value.number_float); 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(0xA0 | N)); } else if (N <= (std::numeric_limits::max)()) { // str 8 oa->write_character(static_cast(0xD9)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { // str 16 oa->write_character(static_cast(0xDA)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { // str 32 oa->write_character(static_cast(0xDB)); write_number(static_cast(N)); } // step 2: write the string oa->write_characters( reinterpret_cast(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(0x90 | N)); } else if (N <= (std::numeric_limits::max)()) { // array 16 oa->write_character(static_cast(0xDC)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { // array 32 oa->write_character(static_cast(0xDD)); write_number(static_cast(N)); } // step 2: write each element for (const auto& el : *j.m_value.array) { write_msgpack(el); } 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(0x80 | (N & 0xF))); } else if (N <= (std::numeric_limits::max)()) { // map 16 oa->write_character(static_cast(0xDE)); write_number(static_cast(N)); } else if (N <= (std::numeric_limits::max)()) { // map 32 oa->write_character(static_cast(0xDF)); write_number(static_cast(N)); } // step 2: write each element for (const auto& el : *j.m_value.object) { write_msgpack(el.first); write_msgpack(el.second); } break; } 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 */ void write_ubjson(const BasicJsonType& j, const bool use_count, const bool use_type, const bool add_prefix = true) { switch (j.type()) { case value_t::null: { if (add_prefix) { oa->write_character(static_cast('Z')); } break; } case value_t::boolean: { if (add_prefix) oa->write_character(j.m_value.boolean ? static_cast('T') : static_cast('F')); break; } case value_t::number_integer: { write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix); break; } case value_t::number_unsigned: { write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix); break; } case value_t::number_float: { write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix); break; } case value_t::string: { if (add_prefix) { oa->write_character(static_cast('S')); } write_number_with_ubjson_prefix(j.m_value.string->size(), true); oa->write_characters( reinterpret_cast(j.m_value.string->c_str()), j.m_value.string->size()); break; } case value_t::array: { if (add_prefix) { oa->write_character(static_cast('[')); } bool prefix_required = true; if (use_type and not j.m_value.array->empty()) { assert(use_count); const CharType first_prefix = ubjson_prefix(j.front()); const bool same_prefix = std::all_of(j.begin() + 1, j.end(), [this, first_prefix](const BasicJsonType & v) { return ubjson_prefix(v) == first_prefix; }); if (same_prefix) { prefix_required = false; oa->write_character(static_cast('$')); oa->write_character(first_prefix); } } if (use_count) { oa->write_character(static_cast('#')); write_number_with_ubjson_prefix(j.m_value.array->size(), true); } for (const auto& el : *j.m_value.array) { write_ubjson(el, use_count, use_type, prefix_required); } if (not use_count) { oa->write_character(static_cast(']')); } break; } case value_t::object: { if (add_prefix) { oa->write_character(static_cast('{')); } bool prefix_required = true; if (use_type and not j.m_value.object->empty()) { assert(use_count); const CharType first_prefix = ubjson_prefix(j.front()); const bool same_prefix = std::all_of(j.begin(), j.end(), [this, first_prefix](const BasicJsonType & v) { return ubjson_prefix(v) == first_prefix; }); if (same_prefix) { prefix_required = false; oa->write_character(static_cast('$')); oa->write_character(first_prefix); } } if (use_count) { oa->write_character(static_cast('#')); write_number_with_ubjson_prefix(j.m_value.object->size(), true); } for (const auto& el : *j.m_value.object) { write_number_with_ubjson_prefix(el.first.size(), true); oa->write_characters( reinterpret_cast(el.first.c_str()), el.first.size()); write_ubjson(el.second, use_count, use_type, prefix_required); } if (not use_count) { oa->write_character(static_cast('}')); } break; } default: break; } } std::size_t write_bson_boolean(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { oa->write_character(static_cast(0x08)); // boolean oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); oa->write_character(j.m_value.boolean ? static_cast(0x01) : static_cast(0x00)); return /*id*/ 1ul + name.size() + 1u + /*boolean value*/ 1u; } std::size_t write_bson_double(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { oa->write_character(static_cast(0x01)); // double oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); write_number_little_endian(j.m_value.number_float); return /*id*/ 1ul + name.size() + 1u + /*double value*/ 8u; } std::size_t write_bson_string(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { oa->write_character(static_cast(0x02)); // string (UTF-8) oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); write_number_little_endian(static_cast(j.m_value.string->size() + 1ul)); oa->write_characters( reinterpret_cast(j.m_value.string->c_str()), j.m_value.string->size() + 1); return /*id*/ 1ul + name.size() + 1ul + sizeof(std::int32_t) + j.m_value.string->size() + 1ul; } std::size_t write_bson_null(const typename BasicJsonType::string_t& name, const BasicJsonType&) { oa->write_character(static_cast(0x0A)); // null oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); return /*id*/ 1ul + name.size() + 1ul; } std::size_t write_bson_integer(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { auto n = j.m_value.number_integer; if ((std::numeric_limits::min)() <= n and n <= (std::numeric_limits::max)()) { oa->write_character(static_cast(0x10)); // int32 oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); write_number_little_endian(static_cast(n)); return /*id*/ 1ul + name.size() + 1ul + sizeof(std::int32_t); } else { oa->write_character(static_cast(0x12)); // int64 oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); write_number_little_endian(static_cast(j.m_value.number_integer)); return /*id*/ 1ul + name.size() + 1ul + sizeof(std::int64_t); } } std::size_t write_bson_unsigned(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { auto n = j.m_value.number_integer; if (n <= static_cast((std::numeric_limits::max)())) { oa->write_character(static_cast(0x10)); // int32 oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); write_number_little_endian(static_cast(n)); return /*id*/ 1ul + name.size() + 1ul + sizeof(std::int32_t); } else { oa->write_character(static_cast(0x12)); // int64 oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); write_number_little_endian(static_cast(j.m_value.number_integer)); return /*id*/ 1ul + name.size() + 1ul + sizeof(std::int64_t); } } std::size_t write_bson_object_internal(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { oa->write_character(static_cast(0x03)); // object oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); auto const embedded_document_size = write_bson_object(j); return /*id*/ 1ul + name.size() + 1ul + embedded_document_size; } std::size_t write_bson_array(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { oa->write_character(static_cast(0x04)); // object oa->write_characters( reinterpret_cast(name.c_str()), name.size() + 1u); auto document_size_offset = oa->reserve_characters(4ul); std::int32_t embedded_document_size = 5ul; for (const auto& el : *j.m_value.array) { embedded_document_size += write_bson_object_entry("", el); } oa->write_character(static_cast(0x00)); write_number_little_endian_at(document_size_offset, embedded_document_size); return /*id*/ 1ul + name.size() + 1ul + embedded_document_size; } std::size_t write_bson_object_entry(const typename BasicJsonType::string_t& name, const BasicJsonType& j) { switch (j.type()) { default: JSON_THROW(type_error::create(317, "JSON value of type be serialized to requested format: " + std::to_string((int)j.type()))); break; case value_t::object: return write_bson_object_internal(name, j); case value_t::array: return write_bson_array(name, j); case value_t::boolean: return write_bson_boolean(name, j); case value_t::number_float: return write_bson_double(name, j); case value_t::number_integer: return write_bson_integer(name, j); case value_t::number_unsigned: return write_bson_unsigned(name, j); case value_t::string: return write_bson_string(name, j); case value_t::null: return write_bson_null(name, j); }; return 0ul; } /*! @param[in] j JSON value to serialize @pre j.type() == value_t::object */ std::size_t write_bson_object(const BasicJsonType& j) { assert(j.type() == value_t::object); auto document_size_offset = oa->reserve_characters(4ul); std::int32_t document_size = 5ul; for (const auto& el : *j.m_value.object) { document_size += write_bson_object_entry(el.first, el.second); } oa->write_character(static_cast(0x00)); write_number_little_endian_at(document_size_offset, document_size); return document_size; } /*! @param[in] j JSON value to serialize @pre j.type() == value_t::object */ void write_bson(const BasicJsonType& j) { switch (j.type()) { default: JSON_THROW(type_error::create(317, "JSON value cannot be serialized to requested format")); break; case value_t::discarded: break; case value_t::object: write_bson_object(j); break; } } private: /* @brief write a number to output input @param[in] n number of type @a NumberType @tparam NumberType the type of the number @note This function needs to respect the system's endianess, because bytes in CBOR, MessagePack, and UBJSON are stored in network order (big endian) and therefore need reordering on little endian systems. */ template void write_number(const NumberType n) { // step 1: write number to array of length NumberType std::array vec; std::memcpy(vec.data(), &n, sizeof(NumberType)); // step 2: write array to output (with possible reordering) if (is_little_endian) { // reverse byte order prior to conversion if necessary std::reverse(vec.begin(), vec.end()); } oa->write_characters(vec.data(), sizeof(NumberType)); } /* @brief write a number to output in little endian format @param[in] n number of type @a NumberType @tparam NumberType the type of the number */ template void write_number_little_endian(const NumberType n) { // step 1: write number to array of length NumberType std::array vec; std::memcpy(vec.data(), &n, sizeof(NumberType)); // step 2: write array to output (with possible reordering) if (!is_little_endian) { // reverse byte order prior to conversion if necessary std::reverse(vec.begin(), vec.end()); } oa->write_characters(vec.data(), sizeof(NumberType)); } /* @brief write a number to output in little endian format @param[in] offset The offset where to start writing @param[in] n number of type @a NumberType @tparam NumberType the type of the number */ template void write_number_little_endian_at(std::size_t offset, const NumberType n) { // step 1: write number to array of length NumberType std::array vec; std::memcpy(vec.data(), &n, sizeof(NumberType)); // step 2: write array to output (with possible reordering) if (!is_little_endian) { // reverse byte order prior to conversion if necessary std::reverse(vec.begin(), vec.end()); } oa->write_characters_at(offset, vec.data(), sizeof(NumberType)); } // UBJSON: write number (floating point) template::value, int>::type = 0> void write_number_with_ubjson_prefix(const NumberType n, const bool add_prefix) { if (add_prefix) { oa->write_character(get_ubjson_float_prefix(n)); } write_number(n); } // UBJSON: write number (unsigned integer) template::value, int>::type = 0> void write_number_with_ubjson_prefix(const NumberType n, const bool add_prefix) { if (n <= static_cast((std::numeric_limits::max)())) { if (add_prefix) { oa->write_character(static_cast('i')); // int8 } write_number(static_cast(n)); } else if (n <= (std::numeric_limits::max)()) { if (add_prefix) { oa->write_character(static_cast('U')); // uint8 } write_number(static_cast(n)); } else if (n <= static_cast((std::numeric_limits::max)())) { if (add_prefix) { oa->write_character(static_cast('I')); // int16 } write_number(static_cast(n)); } else if (n <= static_cast((std::numeric_limits::max)())) { if (add_prefix) { oa->write_character(static_cast('l')); // int32 } write_number(static_cast(n)); } else if (n <= static_cast((std::numeric_limits::max)())) { if (add_prefix) { oa->write_character(static_cast('L')); // int64 } write_number(static_cast(n)); } else { JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n))); } } // UBJSON: write number (signed integer) template::value and not std::is_floating_point::value, int>::type = 0> void write_number_with_ubjson_prefix(const NumberType n, const bool add_prefix) { if ((std::numeric_limits::min)() <= n and n <= (std::numeric_limits::max)()) { if (add_prefix) { oa->write_character(static_cast('i')); // int8 } write_number(static_cast(n)); } else if (static_cast((std::numeric_limits::min)()) <= n and n <= static_cast((std::numeric_limits::max)())) { if (add_prefix) { oa->write_character(static_cast('U')); // uint8 } write_number(static_cast(n)); } else if ((std::numeric_limits::min)() <= n and n <= (std::numeric_limits::max)()) { if (add_prefix) { oa->write_character(static_cast('I')); // int16 } write_number(static_cast(n)); } else if ((std::numeric_limits::min)() <= n and n <= (std::numeric_limits::max)()) { if (add_prefix) { oa->write_character(static_cast('l')); // int32 } write_number(static_cast(n)); } else if ((std::numeric_limits::min)() <= n and n <= (std::numeric_limits::max)()) { if (add_prefix) { oa->write_character(static_cast('L')); // int64 } write_number(static_cast(n)); } // LCOV_EXCL_START else { JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n))); } // LCOV_EXCL_STOP } /*! @brief determine the type prefix of container values @note This function does not need to be 100% accurate when it comes to integer limits. In case a number exceeds the limits of int64_t, this will be detected by a later call to function write_number_with_ubjson_prefix. Therefore, we return 'L' for any value that does not fit the previous limits. */ CharType ubjson_prefix(const BasicJsonType& j) const noexcept { 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::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits::max)()) { return 'i'; } else if ((std::numeric_limits::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits::max)()) { return 'U'; } else if ((std::numeric_limits::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits::max)()) { return 'I'; } else if ((std::numeric_limits::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits::max)()) { return 'l'; } else // no check and assume int64_t (see note above) { return 'L'; } } case value_t::number_unsigned: { if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { return 'i'; } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { return 'U'; } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { return 'I'; } else if (j.m_value.number_unsigned <= (std::numeric_limits::max)()) { return 'l'; } else // no check and assume int64_t (see note above) { return 'L'; } } 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: return '['; case value_t::object: return '{'; default: // discarded values return 'N'; } } static constexpr CharType get_cbor_float_prefix(float) { return static_cast(0xFA); // Single-Precision Float } static constexpr CharType get_cbor_float_prefix(double) { return static_cast(0xFB); // Double-Precision Float } static constexpr CharType get_msgpack_float_prefix(float) { return static_cast(0xCA); // float 32 } static constexpr CharType get_msgpack_float_prefix(double) { return static_cast(0xCB); // float 64 } static constexpr CharType get_ubjson_float_prefix(float) { return 'd'; // float 32 } static constexpr CharType get_ubjson_float_prefix(double) { return 'D'; // float 64 } private: /// whether we can assume little endianess const bool is_little_endian = binary_reader::little_endianess(); /// the output output_adapter_t oa = nullptr; }; } }