update nlohmann modernjson to v3.4 (with bson support)

namespace nlohmann

{

template<typename, typename>

struct adl_serializer

{

    */

    template<typename BasicJsonType, typename ValueType>

    static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(

        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val))) -> decltype(

            ::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void()

        )

        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))

    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())

    {

        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);

    }

    template <typename BasicJsonType, typename ValueType>

    static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(

        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))

    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)),

                void())

    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())

    {

        ::nlohmann::to_json(j, std::forward<ValueType>(val));

    }

};

}

}  // namespace nlohmann

}

template <

    typename BasicJsonType, typename CompatibleStringType,

    typename BasicJsonType, typename ConstructibleStringType,

    enable_if_t <

        is_compatible_string_type<BasicJsonType, CompatibleStringType>::value and

        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value and

        not std::is_same<typename BasicJsonType::string_t,

                         CompatibleStringType>::value,

                         ConstructibleStringType>::value,

        int > = 0 >

void from_json(const BasicJsonType& j, CompatibleStringType& s)

void from_json(const BasicJsonType& j, ConstructibleStringType& s)

{

    if (JSON_UNLIKELY(not j.is_string()))

    {

    }

}

template<typename BasicJsonType, typename CompatibleArrayType>

auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1> /*unused*/)

template<typename BasicJsonType, typename ConstructibleArrayType>

auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)

-> decltype(

    arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),

    j.template get<typename CompatibleArrayType::value_type>(),

    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),

    j.template get<typename ConstructibleArrayType::value_type>(),

    void())

{

    using std::end;

    {

        // get<BasicJsonType>() returns *this, this won't call a from_json

        // method when value_type is BasicJsonType

        return i.template get<typename CompatibleArrayType::value_type>();

        return i.template get<typename ConstructibleArrayType::value_type>();

    });

}

template <typename BasicJsonType, typename CompatibleArrayType>

void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr,

template <typename BasicJsonType, typename ConstructibleArrayType>

void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,

                          priority_tag<0> /*unused*/)

{

    using std::end;

    {

        // get<BasicJsonType>() returns *this, this won't call a from_json

        // method when value_type is BasicJsonType

        return i.template get<typename CompatibleArrayType::value_type>();

        return i.template get<typename ConstructibleArrayType::value_type>();

    });

}

template <typename BasicJsonType, typename CompatibleArrayType,

template <typename BasicJsonType, typename ConstructibleArrayType,

          enable_if_t <

              is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and

              not is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value and

              not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and

              not is_basic_json<CompatibleArrayType>::value,

              is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value and

              not is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value and

              not is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value and

              not is_basic_json<ConstructibleArrayType>::value,

              int > = 0 >

auto from_json(const BasicJsonType& j, CompatibleArrayType& arr)

auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)

-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),

j.template get<typename CompatibleArrayType::value_type>(),

j.template get<typename ConstructibleArrayType::value_type>(),

void())

{

    if (JSON_UNLIKELY(not j.is_array()))

    from_json_array_impl(j, arr, priority_tag<3> {});

}

template<typename BasicJsonType, typename CompatibleObjectType,

         enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>

void from_json(const BasicJsonType& j, CompatibleObjectType& obj)

template<typename BasicJsonType, typename ConstructibleObjectType,

         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>

void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)

{

    if (JSON_UNLIKELY(not j.is_object()))

    {

    }

    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();

    using value_type = typename CompatibleObjectType::value_type;

    using value_type = typename ConstructibleObjectType::value_type;

    std::transform(

        inner_object->begin(), inner_object->end(),

        std::inserter(obj, obj.begin()),

        [](typename BasicJsonType::object_t::value_type const & p)

    {

        return value_type(p.first, p.second.template get<typename CompatibleObjectType::mapped_type>());

        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());

    });

}

}

template<typename BasicJsonType, typename Tuple, std::size_t... Idx>

void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)

void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)

{

    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);

}

        return from_json(j, val);

    }

};

}

}  // namespace detail

/// namespace to hold default `from_json` function

/// to see why this is required:

namespace

{

constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;

}

}

} // namespace

}  // namespace nlohmann

{

    static constexpr int kPrecision = 64; // = q

    uint64_t f;

    int e;

    uint64_t f = 0;

    int e = 0;

    constexpr diyfp() noexcept : f(0), e(0) {}

    constexpr diyfp(uint64_t f_, int e_) noexcept : f(f_), e(e_) {}

    /*!

        assert(x.e == y.e);

        assert(x.f >= y.f);

        return diyfp(x.f - y.f, x.e);

        return {x.f - y.f, x.e};

    }

    /*!

        const uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32);

        return diyfp(h, x.e + y.e + 64);

        return {h, x.e + y.e + 64};

    }

    /*!

        assert(delta >= 0);

        assert(((x.f << delta) >> delta) == x.f);

        return diyfp(x.f << delta, target_exponent);

        return {x.f << delta, target_exponent};

    }

};

    assert(e >= -1500);

    assert(e <=  1500);

    const int f = kAlpha - e - 1;

    const int k = (f * 78913) / (1 << 18) + (f > 0);

    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);

    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;

    assert(index >= 0);

    const diyfp one(uint64_t{1} << -M_plus.e, M_plus.e);

    uint32_t p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)

    auto p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)

    uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e

    // 1)

        *buf++ = '+';

    }

    uint32_t k = static_cast<uint32_t>(e);

    auto k = static_cast<uint32_t>(e);

    if (k < 10)

    {

        // Always print at least two digits in the exponent.

@note The result is NOT null-terminated.

*/

template <typename FloatType>

char* to_chars(char* first, char* last, FloatType value)

char* to_chars(char* first, const char* last, FloatType value)

{

    static_cast<void>(last); // maybe unused - fix warning

    assert(std::isfinite(value));

// for https://github.com/nlohmann/json/pull/1134

template<typename BasicJsonType, typename T,

         enable_if_t<std::is_same<T, typename iteration_proxy<typename BasicJsonType::iterator>::iteration_proxy_internal>::value, int> = 0>

void to_json(BasicJsonType& j, T b) noexcept

void to_json(BasicJsonType& j, const T& b)

{

    j = {{b.key(), b.value()}};

}

template<typename BasicJsonType, typename Tuple, std::size_t... Idx>

void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...>)

void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)

{

    j = {std::get<Idx>(t)...};

}

        return to_json(j, std::forward<T>(val));

    }

};

}

}  // namespace detail

/// namespace to hold default `to_json` function

namespace

{

constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;

}

}

} // namespace

}  // namespace nlohmann

#include <stdexcept> // runtime_error

#include <string> // to_string

#include <lib/modernjson/detail/input/position_t.hpp>

namespace nlohmann

{

namespace detail

json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.

json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.

json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.

json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).

@note For an input with n bytes, 1 is the index of the first character and n+1

      is the index of the terminating null byte or the end of file. This also

    /*!

    @brief create a parse error exception

    @param[in] id_       the id of the exception

    @param[in] byte_     the byte index where the error occurred (or 0 if the

                         position cannot be determined)

    @param[in] position  the position where the error occurred (or with

                         chars_read_total=0 if the position cannot be

                         determined)

    @param[in] what_arg  the explanatory string

    @return parse_error object

    */

    static parse_error create(int id_, const position_t& pos, const std::string& what_arg)

    {

        std::string w = exception::name("parse_error", id_) + "parse error" +

                        position_string(pos) + ": " + what_arg;

        return parse_error(id_, pos.chars_read_total, w.c_str());

    }

    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)

    {

        std::string w = exception::name("parse_error", id_) + "parse error" +

                        (byte_ != 0 ? (" at " + std::to_string(byte_)) : "") +

                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +

                        ": " + what_arg;

        return parse_error(id_, byte_, w.c_str());

    }

  private:

    parse_error(int id_, std::size_t byte_, const char* what_arg)

        : exception(id_, what_arg), byte(byte_) {}

    static std::string position_string(const position_t& pos)

    {

        return " at line " + std::to_string(pos.lines_read + 1) +

               ", column " + std::to_string(pos.chars_read_current_line);

    }

};

/*!

json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.

json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.

json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |

json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |

@liveexample{The following code shows how a `type_error` exception can be

caught.,type_error}

json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.

json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.

json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.

json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON only supports integers numbers up to 9223372036854775807. |

json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. |

json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |

json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |

@liveexample{The following code shows how an `out_of_range` exception can be

caught.,out_of_range}

  private:

    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}

};

}

}

}  // namespace detail

}  // namespace nlohmann