Address review findings on the binary writer output sinks

- binary_reserve_hint(): the 4-bytes-per-element estimate over-reserved by up to 4x for arrays of small scalars (CBOR encodes 0..23 in one byte), and the returned vector kept that capacity. Make the hint a strict lower bound on the encoded size instead, which also removes the 1 MiB clamp whose branch no test could reach (the largest container in the suite has 65793 elements). - Guard the -Wduplicated-branches pragma with __GNUC__ >= 7. The warning does not exist before GCC 7, so naming it made GCC 4.8/4.9/5/6 - which the CI matrix still builds - warn under -Wpragmas on every including translation unit, breaking downstream -Werror builds. - Constrain the adapter constructor of binary_writer with the enable_if its documentation already claimed, so a writer over some other sink type is no longer advertised as constructible from an output adapter. - Let output_vector_adapter wrap output_vector_sink rather than duplicating the append logic, so the type-erased and templated paths share one implementation. - Collapse the three copies of the memcpy/byte_swap/memcpy dance into a single byte_swap_buffer() helper, and add the MSVC _byteswap_* intrinsics so MSVC no longer falls back to the scalar shuffle this change exists to eliminate. - Add a vector_writer() helper for the five vector-returning to_* overloads instead of spelling out the writer type at each call site, and drop a dead default member initializer on output_adapter_sink. - New tests: the vector sink and the adapter sink must produce identical bytes for every format (the two to_* overloads no longer delegate to each other and could otherwise drift), and binary_reserve_hint() must never exceed the size actually written. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Reserve output capacity up front for binary serialization
2026-09-01 14:07:14 +00:00 · 2026-08-31 23:24:37 +00:00 · 2026-08-31 23:21:45 +00:00 · 2026-08-31 23:21:37 +00:00 · 2026-08-31 23:21:36 +00:00 · 2026-08-31 23:21:36 +00:00
21 changed files with 1312 additions and 5010 deletions
@@ -100,7 +100,7 @@ jobs:
    container: ubuntu:focal
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_simdutf]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git libssl-dev
@@ -212,24 +212,6 @@ add_custom_target(ci_test_legacycomparison
    COMMENT "Compile and test with legacy discarded value comparison enabled"
 )
 ###############################################################################
 # Validate UTF-8 with simdutf.
 ###############################################################################
 add_custom_target(ci_test_simdutf
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
    -DJSON_BuildTests=ON -DJSON_TestSimdutf=ON
    # simdutf needs C++17, so the library falls back to its scalar validator
    # below that: build the suite at C++11 to cover the fallback with the macro
    # defined, and at C++17 to run every test against simdutf itself
    "-DJSON_TestStandards=11\;17"
    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_simdutf
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_simdutf
    COMMAND cd ${PROJECT_BINARY_DIR}/build_simdutf && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
    COMMENT "Compile and test with simdutf UTF-8 validation enabled"
 )
 ###############################################################################
 # Enable brace-init copy semantics.
 ###############################################################################
@@ -24,7 +24,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_NO_IO**](json_no_io.md) - switch off functions relying on certain C++ I/O headers
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
 ## Library version
@@ -1,71 +0,0 @@
 # JSON_USE_SIMDUTF
 ```cpp
 #define JSON_USE_SIMDUTF
 ```
 When defined, the parser validates the UTF-8 content of JSON strings that come from a **contiguous byte input**
 (`std::string`, `std::vector<char>`/`<std::uint8_t>`, string literals, `const char*` ranges, …) using the
 [simdutf](https://github.com/simdutf/simdutf) library instead of the built-in scalar validator. On text with many
 non-ASCII characters (e.g. CJK or emoji) this can validate several times faster.
 This is an **opt-in external dependency**. The library itself remains header-only and its behavior is unchanged: the
 same input is accepted or rejected either way, and every parse error is reported at the same position with the same
 message (simdutf is only used to fast-path *valid* runs; anything it flags falls back to the scalar path so the exact
 diagnostic is preserved). Streaming inputs (files, `std::istream`, wide strings, user-defined adapters) always use the
 scalar path.
 When `JSON_USE_SIMDUTF` is defined you must make the `simdutf.h` header available on the include path and link the
 simdutf library. When it is not defined, no simdutf header is included and there is no dependency.
 !!! note "Requires C++17"
    simdutf requires C++17 and its header rejects older standards with an `#!cpp #error`. The backend is therefore only
    compiled in from C++17 on. In C++11 and C++14 the macro has no effect and the scalar validator is used, which
    accepts and rejects exactly the same input -- only throughput differs. Setting the macro project-wide is therefore
    safe even when some translation units are built with an older standard.
 !!! warning "Define consistently"
    The macro selects between two definitions of the same inline validation function. It must therefore be defined
    identically for **every** translation unit that includes the library; mixing translation units that define it with
    ones that do not is an ODR violation. Prefer setting it as a compile definition on the target rather than with
    `#!cpp #define` in individual source files.
 ## Default definition
 By default, `#!cpp JSON_USE_SIMDUTF` is not defined and the portable C++11 scalar validator is used.
 ```cpp
 #undef JSON_USE_SIMDUTF
 ```
 ## Examples
 ??? example
    The code below enables the simdutf backend for UTF-8 validation.
    ```cpp
    #define JSON_USE_SIMDUTF 1
    #include <nlohmann/json.hpp>
    ...
    ```
    The project must also link against simdutf, e.g. with CMake:
    ```cmake
    target_compile_definitions(your_target PRIVATE JSON_USE_SIMDUTF)
    target_link_libraries(your_target PRIVATE simdutf::simdutf)
    ```
 !!! hint "Testing this configuration"
    The unit tests can be built against the simdutf backend with the CMake option `JSON_TestSimdutf` (`OFF` by
    default), which fetches simdutf and defines `JSON_USE_SIMDUTF` for every test target. The `ci_test_simdutf` target
    runs the whole test suite in that configuration.
 ## Version history
 - Added in version 3.13.0.
@@ -137,14 +137,6 @@ behavior is deprecated and switched off (`0`) by default.
 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).
 ## `JSON_USE_SIMDUTF`
 When defined, UTF-8 validation of JSON strings read from contiguous byte input is delegated to the
 [simdutf](https://github.com/simdutf/simdutf) library instead of the built-in scalar validator. This is an opt-in
 external dependency and is not defined by default.
 See [full documentation of `JSON_USE_SIMDUTF`](../api/macros/json_use_simdutf.md).
 ## `NLOHMANN_DEFINE_TYPE_*(...)`, `NLOHMANN_DEFINE_DERIVED_TYPE_*(...)`
 The library defines 12 macros to simplify the serialization/deserialization of types. See the page on
@@ -296,7 +296,6 @@ nav:
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
          - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
          - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
          - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
          - 'NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_derived_type.md
          - 'NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_intrusive.md
          - 'NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_non_intrusive.md
@@ -155,31 +155,11 @@ class input_stream_adapter
 // General-purpose iterator-based adapter. It might not be as fast as
 // theoretically possible for some containers, but it is extremely versatile.
-// SentinelType defaults to IteratorType for backward compatibility, but may be
+// SentinelType defaults to IteratorType for backward compatibility, but may
-// a different type, e.g. a C++20 sentinel such as std::default_sentinel_t when
+// be a different type (e.g., a C++20 sentinel or counted_iterator).
 // IteratorType is a std::counted_iterator.
 template<typename IteratorType, typename SentinelType = IteratorType>
 class iterator_input_adapter
 {
    // Whether the number of elements between two positions can be computed in
    // O(1): either the iterator and the sentinel have the same type (plain
    // std::distance) or, in C++20, the sentinel is a sized sentinel for the
    // iterator (std::ranges::distance), e.g. std::default_sentinel_t paired
    // with std::counted_iterator.
    //
    // JSON_HAS_RANGES gates the C++20 branch: on standard libraries with an
    // incomplete <ranges> (libstdc++ < 11, see #4440) evaluating
    // std::contiguous_iterator on a std::counted_iterator is a hard error
    // instead of yielding false, and these traits are instantiated for every
    // adapter. Such toolchains fall back to the pointer-only test and simply
    // use the byte-at-a-time scanner.
    static constexpr bool sentinel_is_sized =
 #if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>;
 #else
        std::is_same<IteratorType, SentinelType>::value;
 #endif
  public:
    using char_type = typename std::iterator_traits<IteratorType>::value_type;
@@ -191,7 +171,7 @@ class iterator_input_adapter
    // in wide_string_input_adapter, which does not expose this).
    static constexpr bool supports_seek =
        std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
-        && sentinel_is_sized
+        && std::is_same<IteratorType, SentinelType>::value
        && sizeof(char_type) == 1;
    iterator_input_adapter(IteratorType first, SentinelType last)
@@ -239,60 +219,30 @@ class iterator_input_adapter
  private:
    // whether IteratorType refers to a contiguous range and therefore supports
    // a std::memcpy fast path (pointers always do; in C++20 we can also detect
-    // library iterators such as those of std::vector and std::string). The
+    // library iterators such as those of std::vector and std::string).
-    // available element count must also be computable in O(1), hence
+    // Computing the available element count needs either same-type iterators
-    // sentinel_is_sized.
+    // (plain std::distance) or, in C++20, a sized sentinel (std::ranges::distance),
-    static constexpr bool iterator_is_contiguous = sentinel_is_sized &&
+    // e.g. std::counted_iterator paired with std::default_sentinel_t.
-#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
+    static constexpr bool iterator_is_contiguous =
-        (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        (std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>)
        && (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
 #else
-        std::is_pointer<IteratorType>::value;
+        std::is_same<IteratorType, SentinelType>::value && std::is_pointer<IteratorType>::value;
 #endif
    // number of unread elements in [current, end)
    std::size_t remaining_count() const
    {
 #if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        // std::ranges::distance also supports sized sentinels of a different
        // type (e.g. std::counted_iterator + std::default_sentinel_t)
        return static_cast<std::size_t>(std::ranges::distance(current, end));
 #else
        return static_cast<std::size_t>(std::distance(current, end));
 #endif
    }
  public:
    // Whether the remaining input is a single contiguous block of 1-byte
    // elements that the lexer can inspect directly (used for the SWAR string
    // fast path).
    static constexpr bool supports_bulk_scan =
        iterator_is_contiguous && sizeof(char_type) == 1;
    // Pointer to the next unread element; only valid when bulk_remaining() > 0.
    const char_type* bulk_data() const
    {
        return &*current;
    }
    // Number of unread elements available as one contiguous block.
    std::size_t bulk_remaining() const
    {
        return remaining_count();
    }
    // Consume @a n elements previously inspected via bulk_data().
    void bulk_skip(std::size_t n)
    {
        std::advance(current, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(n));
    }
  private:
    // contiguous fast path: bulk copy the remaining range with std::memcpy
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::true_type /*contiguous*/)
    {
        const std::size_t wanted = count * sizeof(T);
-        const std::size_t available = remaining_count() * sizeof(char_type);
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        // std::ranges::distance also supports sized sentinels of a different
        // type (e.g. std::counted_iterator + std::default_sentinel_t)
        const std::size_t available = static_cast<std::size_t>(std::ranges::distance(current, end)) * sizeof(char_type);
 #else
        const std::size_t available = static_cast<std::size_t>(std::distance(current, end)) * sizeof(char_type);
 #endif
        const std::size_t copied = (std::min)(wanted, available);
        if (JSON_HEDLEY_LIKELY(copied != 0))
        {
@@ -620,46 +570,6 @@ typename iterator_input_adapter_factory<IteratorType, SentinelType>::adapter_typ
    return factory_type::create(first, last);
 }
 // The element type a container's data() points at, cv-qualifiers removed.
 // Ill-formed - and therefore SFINAE-friendly - for types without data().
 template<typename ContainerType>
 using container_data_t = typename std::remove_cv<typename std::remove_pointer <
                         decltype(std::declval<const ContainerType&>().data()) >::type >::type;
 // The container's own element type, cv-qualifiers removed. It is looked up on
 // the bare type so it is also found when ContainerType is deduced as a
 // reference by the forwarding-reference overload below.
 template<typename ContainerType>
 using container_value_t = typename std::remove_cv <
                          typename std::remove_cv<typename std::remove_reference<ContainerType>::type>::type::value_type >::type;
 // Detect a container that stores its elements contiguously as single bytes
 // (std::string, std::vector<char/unsigned char>, std::array<char, N>,
 // std::string_view, ...). Such inputs are wrapped in a pointer-based adapter so
 // they benefit from the contiguous fast paths (bulk string scanning, memcpy for
 // binary formats) in every C++ standard - not only in C++20, where the standard
 // library iterators model std::contiguous_iterator and are detected directly.
 //
 // data() and size() on their own would be duck typing: they say nothing about
 // size() counting the units data() points at, and reading [data(), data() +
 // size()) as bytes would be wrong for a type where it does not. Requiring the
 // container's own value_type to be that same single-byte element ties the two
 // together; every contiguous standard container satisfies it. Anything else
 // keeps the iterator-based adapter, which is always correct - only slower.
 template<typename ContainerType, typename = void>
 struct is_contiguous_byte_container : std::false_type {};
 template<typename ContainerType>
 struct is_contiguous_byte_container < ContainerType, void_t <
    container_data_t<ContainerType>,
    container_value_t<ContainerType>,
 decltype(std::declval<const ContainerType&>().size()) >>
            : std::integral_constant < bool,
        std::is_pointer<decltype(std::declval<const ContainerType&>().data())>::value&&
        std::is_integral<container_data_t<ContainerType>>::value&&
        sizeof(container_data_t<ContainerType>) == 1 &&
        std::is_same<container_data_t<ContainerType>, container_value_t<ContainerType>>::value > {};
 // Convenience shorthand from container to iterator
 // Enables ADL on begin(container) and end(container)
 // Encloses the using declarations in namespace for not to leak them to outside scope
@@ -687,32 +597,12 @@ struct container_input_adapter_factory< ContainerType,
 }  // namespace container_input_adapter_factory_impl
-// General container path (iterator-based). Contiguous single-byte containers
+template<typename ContainerType>
-// are excluded here and routed through the pointer-based overload below.
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType&& container)
 template < typename ContainerType,
           enable_if_t < !is_contiguous_byte_container<ContainerType>::value, int > = 0 >
 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType && container)
 {
    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(std::forward<ContainerType>(container));
 }
 // Contiguous single-byte containers (std::string, std::vector<char>, ...) are
 // wrapped in a pointer-based adapter so the contiguous fast paths apply in every
 // standard. The pointer keeps the container's own element type (const char* for
 // std::string, const std::uint8_t* for std::vector<std::uint8_t>, ...), so the
 // resulting char_type - and therefore the parsing behavior - is byte-for-byte
 // identical to the iterator-based path; only the raw pointer additionally
 // enables the bulk fast paths. The container outlives the adapter for the whole
 // parse (temporaries live until the end of the full expression), exactly as the
 // iterators it replaces did.
 template < typename ContainerType,
           enable_if_t < is_contiguous_byte_container<ContainerType>::value, int > = 0 >
 auto input_adapter(const ContainerType& container)
 -> decltype(input_adapter(container.data(), container.data() + container.size()))
 {
    return input_adapter(container.data(), container.data() + container.size());
 }
 // specialization for std::string
 using string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()));
@@ -19,9 +19,7 @@
 #include <vector> // vector
 #include <nlohmann/detail/input/input_adapters.hpp>
 #include <nlohmann/detail/input/number_parse.hpp>
 #include <nlohmann/detail/input/position_t.hpp>
 #include <nlohmann/detail/input/string_scan.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
@@ -127,25 +125,6 @@ constexpr bool input_adapter_supports_seek(std::false_type /*detected*/)
    return false;
 }
 // Detect whether an input adapter exposes a contiguous byte block that the
 // lexer can scan directly (see iterator_input_adapter::supports_bulk_scan).
 // Adapters without the flag - file, stream, wide-string, user-defined - fall
 // back to the character-at-a-time string scanner.
 template<typename InputAdapterType>
 using detect_supports_bulk_scan = decltype(InputAdapterType::supports_bulk_scan);
 template<typename InputAdapterType>
 constexpr bool input_adapter_supports_bulk_scan(std::true_type /*detected*/)
 {
    return InputAdapterType::supports_bulk_scan;
 }
 template<typename InputAdapterType>
 constexpr bool input_adapter_supports_bulk_scan(std::false_type /*detected*/)
 {
    return false;
 }
 /*!
@brief lexical analysis
@@ -167,14 +146,6 @@ class lexer : public lexer_base<BasicJsonType>
    static constexpr bool lazy_token_string =
        input_adapter_supports_seek<InputAdapterType>(is_detected<detect_supports_seek, InputAdapterType> {});
    /// whether string scanning may bulk-consume runs of ordinary characters
    /// directly from a contiguous input buffer (SWAR fast path). This requires
    /// the token to be reconstructible lazily (lazy_token_string), so bypassing
    /// the per-character capture in get() cannot lose error diagnostics.
    static constexpr bool bulk_scan =
        lazy_token_string
        && input_adapter_supports_bulk_scan<InputAdapterType>(is_detected<detect_supports_bulk_scan, InputAdapterType> {});
  public:
    using token_type = typename lexer_base<BasicJsonType>::token_type;
@@ -294,40 +265,6 @@ class lexer : public lexer_base<BasicJsonType>
        return true;
    }
    /// contiguous input: bulk-append the run of ordinary characters and complete
    /// well-formed UTF-8 sequences starting at the current read position, leaving
    /// the first byte that needs individual handling (the closing quote, an
    /// escape, a control character, or an ill-formed UTF-8 byte) for get()
    void scan_string_bulk(std::true_type /*bulk*/)
    {
        // a pending unget must be consumed through the normal path first
        if (next_unget)
        {
            return;
        }
        const std::size_t remaining = ia.bulk_remaining();
        if (remaining == 0)
        {
            return;
        }
        const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
        const std::size_t pos = string_bulk_run(data, remaining);
        if (pos == 0)
        {
            return;
        }
        token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), pos);
        ia.bulk_skip(pos);
        // the run contains no newline (all bytes < 0x20 are treated as special),
        // so only the flat character counters advance
        position.chars_read_total += pos;
        position.chars_read_current_line += pos;
    }
    /// streaming input: no bulk fast path
    void scan_string_bulk(std::false_type /*bulk*/) const noexcept {}
    /*!
    @brief scan a string literal
@@ -353,10 +290,6 @@ class lexer : public lexer_base<BasicJsonType>
        while (true)
        {
            // bulk-consume ordinary characters from contiguous input, then
            // handle the next special byte through the switch below
            scan_string_bulk(std::integral_constant<bool, bulk_scan> {});
            // get the next character
            switch (get())
            {
@@ -1346,78 +1279,45 @@ scan_number_done:
        // we are done scanning a number)
        unget();
-        return convert_number(number_type);
+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-    }
+        errno = 0;
-    /*!
+        // try to parse integers first and fall back to floats
    @brief convert an already-validated integer token to its value
    The digit sequence in [first, last) has been validated by the caller, so a
    dedicated parser can avoid the locale/errno overhead of std::strtoull.
    @return the token type on success; token_type::uninitialized if @a
            number_type is not an integer type or the value does not fit, in
            which case the caller falls back to the floating-point conversion
            (matching the previous std::strtoull/std::strtoll behavior)
    */
    token_type convert_integer(token_type number_type, const char* first, const char* last)
    {
        if (number_type == token_type::value_unsigned)
        {
-            if (parse_integer_unsigned(first, last, value_unsigned))
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
            // we checked the number format before
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
            if (errno != ERANGE)
            {
                value_unsigned = static_cast<number_unsigned_t>(x);
                if (value_unsigned == x)
                {
                    return token_type::value_unsigned;
                }
            }
        }
        else if (number_type == token_type::value_integer)
        {
-            if (parse_integer_signed(first, last, value_integer))
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
            // we checked the number format before
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
            if (errno != ERANGE)
            {
                value_integer = static_cast<number_integer_t>(x);
                if (value_integer == x)
                {
                    return token_type::value_integer;
                }
            }
        return token_type::uninitialized;
    }
    /*!
    @brief convert the number text in token_buffer to its value and token type
    The digit sequence in token_buffer has already been validated (by the
    scan_number() state machine or by the contiguous fast path) and holds the
    locale decimal point in place of '.'. Integers are parsed first and fall
    back to floating point on overflow. This is shared so both scanners produce
    identical results.
    */
    token_type convert_number(token_type number_type)
    {
        const char* const num_begin = token_buffer.data();
        const char* const num_end = num_begin + token_buffer.size();
        if (number_type != token_type::value_float)
        {
            const token_type integer_result = convert_integer(number_type, num_begin, num_end);
            if (integer_result != token_type::uninitialized)
            {
                return integer_result;
            }
        }
        // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. Prefer std::from_chars
+        // integer conversion above failed
        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
        // otherwise the exact Clinger fast path (double only); otherwise the
        // locale-aware strtof/strtod.
        if (parse_float_from_chars(num_begin, num_end, value_float))
        {
            return token_type::value_float;
        }
        if (parse_float_fast(num_begin, num_end, decimal_point_char, value_float))
        {
            return token_type::value_float;
        }
        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
        strtof(value_float, token_buffer.data(), &endptr);
        // we checked the number format before
@@ -1426,156 +1326,6 @@ scan_number_done:
        return token_type::value_float;
    }
    /*!
    @brief contiguous fast path for scanning a number
    Parses the whole number token straight from the input buffer, avoiding the
    per-character get()/add() of scan_number(). On success it fills token_buffer
    (with the locale decimal point substituted, as scan_number() does) and
    returns the token type. On anything it does not fully recognize as a
    well-formed number it makes no state change and returns
    token_type::uninitialized, so the caller falls back to scan_number(), which
    then produces the exact diagnostic. @a current is the first digit or the
    leading minus (already read); the remaining bytes are taken from the adapter.
    */
    token_type scan_number_bulk_contiguous()
    {
        // a pending unget offsets the buffer position from current; fall back
        if (next_unget)
        {
            return token_type::uninitialized;
        }
        const std::size_t rem = ia.bulk_remaining();
        if (rem == 0)
        {
            // the first digit is the last input byte; let scan_number() finish
            return token_type::uninitialized;
        }
        // the byte before the next unread one is current (contiguous input)
        const char* const data = reinterpret_cast<const char*>(ia.bulk_data()) - 1;
        const std::size_t avail = rem + 1;
        // validate + classify the number extent (mirrors scan_number()'s grammar)
        std::size_t i = 0;
        std::size_t dot_index = std::string::npos;
        token_type number_type = token_type::value_unsigned;
        if (data[0] == '-')
        {
            number_type = token_type::value_integer;
            i = 1;
            if (i >= avail)
            {
                return token_type::uninitialized;
            }
        }
        if (data[i] == '0')
        {
            ++i;
        }
        else if (data[i] >= '1' && data[i] <= '9')
        {
            ++i;
            while (i < avail && data[i] >= '0' && data[i] <= '9')
            {
                ++i;
            }
        }
        else
        {
            return token_type::uninitialized;
        }
        if (i < avail && data[i] == '.')
        {
            number_type = token_type::value_float;
            dot_index = i;
            ++i;
            if (i >= avail || !(data[i] >= '0' && data[i] <= '9'))
            {
                return token_type::uninitialized;
            }
            while (i < avail && data[i] >= '0' && data[i] <= '9')
            {
                ++i;
            }
        }
        if (i < avail && (data[i] == 'e' || data[i] == 'E'))
        {
            number_type = token_type::value_float;
            ++i;
            if (i < avail && (data[i] == '+' || data[i] == '-'))
            {
                ++i;
            }
            if (i >= avail || !(data[i] >= '0' && data[i] <= '9'))
            {
                return token_type::uninitialized;
            }
            while (i < avail && data[i] >= '0' && data[i] <= '9')
            {
                ++i;
            }
        }
        const std::size_t len = i;
        // reset() records where this token starts (for diagnostics), so it has
        // to run before the input position advances below
        reset();
        // An integer token needs no token_buffer: the SAX callbacks for
        // number_integer/number_unsigned take only the value, and the overflow
        // diagnostic rebuilds the text from the input. Convert straight from the
        // input buffer and leave token_buffer empty. (JSON_DIAGNOSTIC_POSITIONS
        // derives a number's start position from get_string().size(), so there
        // the token still has to be materialized.)
 #if !JSON_DIAGNOSTIC_POSITIONS
        if (number_type != token_type::value_float)
        {
            const token_type integer_result = convert_integer(number_type, data, data + len);
            if (JSON_HEDLEY_LIKELY(integer_result != token_type::uninitialized))
            {
                ia.bulk_skip(len - 1);
                position.chars_read_total += (len - 1);
                position.chars_read_current_line += (len - 1);
                return integer_result;
            }
            // The value does not fit an integer, so this token converts as a
            // float. Recording that here keeps convert_number() below from
            // repeating the integer attempt that just failed.
            number_type = token_type::value_float;
        }
 #endif
        // materialize the token exactly as scan_number() would, substituting the
        // locale decimal point so convert_number()'s strtof fallback stays valid.
        // reset() already cleared token_buffer, so append() fills it (assign() is
        // avoided because custom string_t types need not provide it)
        token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), len);
        if (dot_index != std::string::npos)
        {
            token_buffer[dot_index] = static_cast<typename string_t::value_type>(decimal_point_char);
            decimal_point_position = dot_index;
        }
        ia.bulk_skip(len - 1);
        position.chars_read_total += (len - 1);
        position.chars_read_current_line += (len - 1);
        return convert_number(number_type);
    }
    /// contiguous input: try the number fast path, else the byte-path scanner
    token_type scan_number_dispatch(std::true_type /*bulk*/)
    {
        const token_type t = scan_number_bulk_contiguous();
        return (t != token_type::uninitialized) ? t : scan_number();
    }
    /// streaming input: always use the byte-path scanner
    token_type scan_number_dispatch(std::false_type /*bulk*/)
    {
        return scan_number();
    }
    /*!
    @param[in] literal_text  the literal text to expect
    @param[in] length        the length of the passed literal text
@@ -1663,9 +1413,6 @@ scan_number_done:
        if (current == '\n')
        {
            ++position.lines_read;
            // remember the column the newline was read at: chars_read_current_line
            // is about to be cleared, and a matching unget() cannot reconstruct it
            chars_read_before_newline = position.chars_read_current_line;
            position.chars_read_current_line = 0;
        }
@@ -1699,20 +1446,12 @@ scan_number_done:
        --position.chars_read_total;
        // in case we "unget" a newline, we have to also decrement the lines_read
        // and restore the column that get() cleared when it saw the newline;
        // chars_read_current_line == 0 can only mean the last get() read one
        if (position.chars_read_current_line == 0)
        {
            if (position.lines_read > 0)
            {
                --position.lines_read;
            }
            // chars_read_before_newline counts the newline itself, which is the
            // character being ungotten, hence the -1
            position.chars_read_current_line = (chars_read_before_newline > 0)
                                               ? chars_read_before_newline - 1
                                               : 0;
        }
        else
        {
@@ -1955,7 +1694,7 @@ scan_number_done:
            case '7':
            case '8':
            case '9':
-                return scan_number_dispatch(std::integral_constant<bool, bulk_scan> {});
+                return scan_number();
            // end of input (the null byte is needed when parsing from
            // string literals)
@@ -1986,10 +1725,6 @@ scan_number_done:
    /// the start position of the current token
    position_t position {};
    /// the value chars_read_current_line had when the last newline was read, so
    /// that unget() can restore the column instead of leaving it at 0
    std::size_t chars_read_before_newline = 0;
    /// raw input token string for error messages; only populated for streaming
    /// adapters (seekable adapters reconstruct it lazily via token_string_start)
    std::vector<char_type> token_string {};
@@ -1,302 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <array> // array
 #include <cfloat> // FLT_EVAL_METHOD
 #include <cstddef> // size_t
 #include <cstdint> // int64_t, uint64_t
 #include <limits> // numeric_limits
 #include <nlohmann/detail/macro_scope.hpp>
 // std::from_chars lives in <charconv>, but being in C++17 mode does not
 // guarantee the header exists: GCC 7 sets __cplusplus to C++17 yet ships no
 // <charconv> (added in GCC 8; floating-point support in GCC 11). Guard the
 // include with __has_include so such toolchains fall back to the scalar path.
 #if defined(JSON_HAS_CPP_17) && defined(__has_include)
    #if __has_include(<charconv>)
        #include <charconv> // from_chars (only used when __cpp_lib_to_chars is defined)
        #include <system_error> // errc
    #endif
 #endif
 // This file contains the value-conversion helpers used by the lexer to turn an
 // already-validated number token into a value, without the locale/errno
 // overhead of std::strtoull/std::strtod. They are free functions so the lexer
 // stays focused on scanning; see lexer::convert_number().
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
 /*!
@brief fast integer parser for an already-validated unsigned integer
 The number scanner has already checked that [first, last) is a valid JSON
 integer, so this only needs to accumulate the digits and detect overflow. This
 avoids the locale/errno machinery of std::strtoull, which dominates
 integer-heavy inputs.
@param[in]  first   pointer to the first character (a digit)
@param[in]  last    pointer past the last character
@param[out] value   the parsed value on success
@return true if the value fit into @a NumberUnsignedType; false on overflow, in
        which case the caller falls back to floating-point parsing (matching the
        previous std::strtoull behavior)
 */
 template<typename NumberUnsignedType>
 bool parse_integer_unsigned(const char* first, const char* last, NumberUnsignedType& value) noexcept
 {
    // accumulate in the widest unsigned type used by the previous strtoull
    // path so the overflow behavior is unchanged for custom number types
    std::uint64_t x = 0;
    constexpr std::uint64_t cutoff = (std::numeric_limits<std::uint64_t>::max)() / 10u;
    constexpr std::uint64_t cutlim = (std::numeric_limits<std::uint64_t>::max)() % 10u;
    for (const char* p = first; p != last; ++p)
    {
        const auto digit = static_cast<std::uint64_t>(static_cast<unsigned char>(*p) - static_cast<unsigned char>('0'));
        if (JSON_HEDLEY_UNLIKELY(x > cutoff || (x == cutoff && digit > cutlim)))
        {
            return false;
        }
        x = (x * 10u) + digit;
    }
    value = static_cast<NumberUnsignedType>(x);
    // reject values that do not round-trip into a narrower NumberUnsignedType
    return static_cast<std::uint64_t>(value) == x;
 }
 /*!
@brief fast integer parser for an already-validated negative integer
@param[in]  first   pointer to the leading '-'
@param[in]  last    pointer past the last character
@param[out] value   the parsed (negative) value on success
@return true on success; false on overflow (caller falls back to float)
 */
 template<typename NumberIntegerType>
 bool parse_integer_signed(const char* first, const char* last, NumberIntegerType& value) noexcept
 {
    // the state machine only reaches the signed path via a leading '-'
    JSON_ASSERT(first != last && *first == '-');
    std::uint64_t magnitude = 0;
    // |INT64_MIN| == INT64_MAX + 1; this is the largest admissible magnitude
    constexpr std::uint64_t limit = static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()) + 1u;
    for (const char* p = first + 1; p != last; ++p)
    {
        const auto digit = static_cast<std::uint64_t>(static_cast<unsigned char>(*p) - static_cast<unsigned char>('0'));
        if (JSON_HEDLEY_UNLIKELY(magnitude > (limit - digit) / 10u))
        {
            return false;
        }
        magnitude = (magnitude * 10u) + digit;
    }
    const std::int64_t x = (magnitude == limit)
                           ? (std::numeric_limits<std::int64_t>::min)()
                           : -static_cast<std::int64_t>(magnitude);
    value = static_cast<NumberIntegerType>(x);
    // reject values that do not round-trip into a narrower NumberIntegerType
    return static_cast<std::int64_t>(value) == x;
 }
 /*!
@brief exact fast path for parsing a `double` (Clinger's algorithm)
 For the common case - at most 19 significant digits, a decimal exponent in
 [-22, 22], and a significand below 2^53 - the value equals significand *
 10^exp computed in IEEE-754 double arithmetic, which is exact under
 round-to-nearest because both operands are exactly representable. This is the
 same fast path used by fast_float/simdjson; the general cases are left to
 std::strtod. The parser only activates for number_float_t == double; float and
 long double keep the std::strtof/std::strtold paths (see the templated overload
 below).
@param[in]  first          pointer to the first character of the number
@param[in]  last           pointer past the last character
@param[in]  decimal_point  the (locale-dependent) decimal point character
@param[out] out            the parsed value on success
@return true if the value was parsed exactly; false to fall back to strtod
 */
 template<typename DecimalPointType>
 bool parse_float_fast(const char* first, const char* last, DecimalPointType decimal_point, double& out) noexcept
 {
 #if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
    // Clinger's fast path is only exact when double operations are evaluated in
    // true double precision. On platforms that keep intermediates in extended
    // precision (e.g. the x87 FPU on 32-bit x86, where FLT_EVAL_METHOD == 2) the
    // single significand * 10^scale step is double-rounded and can be 1 ULP off,
    // so decline and let the caller fall back to the correctly-rounded
    // std::from_chars / std::strtod path.
    static_cast<void>(first);
    static_cast<void>(last);
    static_cast<void>(decimal_point);
    static_cast<void>(out);
    return false;
 #else
    static const std::array<double, 23> powers_of_ten =
    {
        {
            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,
            1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
        }
    };
    const char* p = first;
    bool negative = false;
    if (p != last && (*p == '-' || *p == '+'))
    {
        negative = (*p == '-');
        ++p;
    }
    std::uint64_t significand = 0;
    int num_digits = 0;
    int fractional_digits = 0;
    bool seen_dot = false;
    bool any_digit = false;
    for (; p != last; ++p)
    {
        const char c = *p;
        if (c >= '0' && c <= '9')
        {
            any_digit = true;
            if (JSON_HEDLEY_UNLIKELY(num_digits >= 19))
            {
                return false; // significand may not fit into uint64_t
            }
            significand = (significand * 10u) + static_cast<std::uint64_t>(c - '0');
            ++num_digits;
            fractional_digits += static_cast<int>(seen_dot);
        }
        else if (static_cast<DecimalPointType>(c) == decimal_point)
        {
            if (JSON_HEDLEY_UNLIKELY(seen_dot))
            {
                return false;
            }
            seen_dot = true;
        }
        else if (c == 'e' || c == 'E')
        {
            ++p;
            break;
        }
        else
        {
            return false;
        }
    }
    if (JSON_HEDLEY_UNLIKELY(!any_digit))
    {
        return false;
    }
    int exponent = 0;
    if (p != last) // an exponent part remains
    {
        bool exp_negative = false;
        if (p != last && (*p == '-' || *p == '+'))
        {
            exp_negative = (*p == '-');
            ++p;
        }
        bool any_exp_digit = false;
        for (; p != last; ++p)
        {
            if (JSON_HEDLEY_UNLIKELY(*p < '0' || *p > '9'))
            {
                return false;
            }
            exponent = (exponent * 10) + (*p - '0');
            any_exp_digit = true;
            if (JSON_HEDLEY_UNLIKELY(exponent > 9999))
            {
                return false;
            }
        }
        if (JSON_HEDLEY_UNLIKELY(!any_exp_digit))
        {
            return false;
        }
        if (exp_negative)
        {
            exponent = -exponent;
        }
    }
    const int scale = exponent - fractional_digits;
    if (JSON_HEDLEY_UNLIKELY(significand >= (static_cast<std::uint64_t>(1) << 53)))
    {
        return false; // significand not exactly representable as double
    }
    auto result = static_cast<double>(significand);
    if (scale >= 0)
    {
        if (JSON_HEDLEY_UNLIKELY(scale > 22))
        {
            return false;
        }
        result *= powers_of_ten[static_cast<std::size_t>(scale)];
    }
    else
    {
        if (JSON_HEDLEY_UNLIKELY(-scale > 22))
        {
            return false;
        }
        result /= powers_of_ten[static_cast<std::size_t>(-scale)];
    }
    out = negative ? -result : result;
    return true;
 #endif
 }
 /// fast float path is only exact for `double`; decline for float/long double
 template<typename DecimalPointType, typename FloatType>
 bool parse_float_fast(const char* /*first*/, const char* /*last*/, DecimalPointType /*decimal_point*/, FloatType& /*out*/) noexcept
 {
    return false;
 }
 /*!
@brief parse a float with std::from_chars (Eisel-Lemire) when available
 std::from_chars is locale-independent, correctly rounded, and - via the
 Eisel-Lemire algorithm in modern standard libraries - much faster than strtod
 over the whole value range (not just the Clinger subset). It is used only when
 __cpp_lib_to_chars indicates full floating-point support and only when it
 consumes the entire token ([first, last)); a partial parse means the buffer
 uses a non-'.' locale decimal point, in which case the caller falls back to the
 locale-aware path. An under-/overflow (result_out_of_range) also declines, so
 the caller's strtod fallback supplies the well-defined ±inf/0 result the parser
 expects (side-stepping the P4168 divergence between implementations).
@return true if the value was parsed exactly and fully; false to fall back
 */
 template<typename FloatType>
 bool parse_float_from_chars(const char* first, const char* last, FloatType& out) noexcept
 {
    // JSON_HAS_CPP_17 must gate the use as well as the <charconv> include above:
    // some standard libraries (e.g. libstdc++ 15) define __cpp_lib_to_chars even
    // in C++14 mode, where <charconv> is not included.
 #if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars)
    const auto result = std::from_chars(first, last, out);
    return result.ec == std::errc() && result.ptr == last;
 #else
    static_cast<void>(first);
    static_cast<void>(last);
    static_cast<void>(out);
    return false;
 #endif
 }
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -1,293 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <cstddef> // size_t
 #include <cstdint> // uint64_t
 #include <cstring> // memcpy
 #include <nlohmann/detail/macro_scope.hpp>
 // Optional SIMD backend for bulk UTF-8 validation. This is an opt-in external
 // dependency: nlohmann/json itself stays header-only and the C++11 scalar
 // validator below is always available; defining JSON_USE_SIMDUTF additionally
 // requires the simdutf headers on the include path and linking the simdutf
 // library. See string_bulk_run().
 //
 // simdutf.h itself requires C++17 - it rejects older standards with an #error -
 // so the backend is only compiled in from C++17 on. Below that the macro has no
 // effect and the scalar validator is used; it accepts and rejects exactly the
 // same input, so only throughput differs. macro_scope.hpp is included above to
 // have JSON_HAS_CPP_17 available for this test.
 #if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
    #include <simdutf.h>
 #endif
 // This file contains the byte-level string-scanning helpers used by the lexer's
 // contiguous fast path. They operate purely on raw bytes (no dependency on the
 // lexer's template parameters) so they are free functions, keeping the lexer
 // itself focused on the state machine; see lexer::scan_string_bulk().
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
 // classify a single byte as needing individual string handling: the closing
 // quote, an escape, a control character, or a non-ASCII (UTF-8)
 // lead/continuation byte. Ordinary bytes (0x20..0x7F except '"' and '\\') are
 // copied verbatim, which the bulk scanner does 8 bytes at a time.
 inline bool is_string_special(unsigned char c) noexcept
 {
    return c == '\"' || c == '\\' || c < 0x20u || c >= 0x80u;
 }
 // SWAR helper: return a word whose high bit is set in every byte of @a v that
 // is_string_special(); zero if the 8 bytes are all ordinary.
 inline std::uint64_t swar_string_special(std::uint64_t v) noexcept
 {
    constexpr std::uint64_t ones = 0x0101010101010101ull;
    constexpr std::uint64_t high = 0x8080808080808080ull;
    const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
    const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
    const std::uint64_t has_quote     = (q - ones) & ~q & high;
    const std::uint64_t has_backslash = (b - ones) & ~b & high;
    const std::uint64_t has_control   = (v - 0x2020202020202020ull) & ~v & high; // < 0x20
    const std::uint64_t has_non_ascii = v & high;                                // >= 0x80
    return has_quote | has_backslash | has_control | has_non_ascii;
 }
 // return the index of the first is_string_special() byte in [data, data+n), or
 // n if every byte is ordinary; scans 8 bytes at a time
 inline std::size_t find_string_special(const unsigned char* data, std::size_t n) noexcept
 {
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
        std::uint64_t word = 0;
        std::memcpy(&word, data + i, sizeof(word));
        if (swar_string_special(word) != 0)
        {
            // a special byte is in this word; locate it (endian-agnostic)
            for (std::size_t j = 0; j < 8; ++j)
            {
                if (is_string_special(data[i + j]))
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
    {
        if (is_string_special(data[i]))
        {
            return i;
        }
    }
    return n;
 }
 // classify a byte as one the serializer must NOT copy verbatim when
 // ensure_ascii is requested: the closing quote, an escape, a control character
 // (< 0x20), DEL (0x7F), or any non-ASCII byte (>= 0x80). Everything else -
 // printable ASCII except '"' and '\\' - is emitted unchanged. Note this differs
 // from is_string_special() only in that 0x7F is also a stop (it is escaped as
 // \u007f under ensure_ascii).
 inline bool is_ascii_copyable(unsigned char c) noexcept
 {
    return c >= 0x20u && c < 0x7Fu && c != '\"' && c != '\\';
 }
 // return the index of the first byte in [data, data+n) that is NOT
 // is_ascii_copyable(), or n if every byte can be copied verbatim; scans 8 bytes
 // at a time. Used by the serializer's ensure_ascii fast path.
 inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_t n) noexcept
 {
    constexpr std::uint64_t ones = 0x0101010101010101ull;
    constexpr std::uint64_t high = 0x8080808080808080ull;
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
        std::uint64_t v = 0;
        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
        const std::uint64_t d = v ^ 0x7F7F7F7F7F7F7F7Full; // DEL  (0x7F)
        const std::uint64_t stop = ((q - ones) & ~q & high)   // == '"'
                                   | ((b - ones) & ~b & high)  // == '\\'
                                   | ((d - ones) & ~d & high)  // == 0x7F
                                   | ((v - 0x2020202020202020ull) & ~v & high) // < 0x20
                                   | (v & high);               // >= 0x80
        if (stop != 0)
        {
            for (std::size_t j = 0; j < 8; ++j)
            {
                if (!is_ascii_copyable(data[i + j]))
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
    {
        if (!is_ascii_copyable(data[i]))
        {
            return i;
        }
    }
    return n;
 }
 // Validate one UTF-8 sequence at the front of [data, data+avail). Returns its
 // length (2..4) only when the bytes form a *well-formed* sequence using exactly
 // the same ranges as scan_string()'s per-byte switch, so the bulk path accepts
 // precisely what the byte path accepts. Returns 0 for anything that is invalid,
 // incomplete, or that the byte path must diagnose (the caller then defers to
 // that path, keeping error messages unchanged). Lead bytes < 0x80 are handled
 // by the caller and never passed here.
 inline std::size_t validate_one_utf8(const unsigned char* data, std::size_t avail) noexcept
 {
    const unsigned char c0 = data[0];
    if (c0 >= 0xC2 && c0 <= 0xDF)  // U+0080..U+07FF
    {
        if (avail >= 2 && data[1] >= 0x80 && data[1] <= 0xBF)
        {
            return 2;
        }
    }
    else if (c0 == 0xE0)  // U+0800..U+0FFF
    {
        if (avail >= 3 && data[1] >= 0xA0 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF)
        {
            return 3;
        }
    }
    else if ((c0 >= 0xE1 && c0 <= 0xEC) || c0 == 0xEE || c0 == 0xEF)  // U+1000..U+CFFF, U+E000..U+FFFF
    {
        if (avail >= 3 && data[1] >= 0x80 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF)
        {
            return 3;
        }
    }
    else if (c0 == 0xED)  // U+D000..U+D7FF (excludes surrogates)
    {
        if (avail >= 3 && data[1] >= 0x80 && data[1] <= 0x9F && data[2] >= 0x80 && data[2] <= 0xBF)
        {
            return 3;
        }
    }
    else if (c0 == 0xF0)  // U+10000..U+3FFFF
    {
        if (avail >= 4 && data[1] >= 0x90 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
        {
            return 4;
        }
    }
    else if (c0 >= 0xF1 && c0 <= 0xF3)  // U+40000..U+FFFFF
    {
        if (avail >= 4 && data[1] >= 0x80 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
        {
            return 4;
        }
    }
    else if (c0 == 0xF4)  // U+100000..U+10FFFF
    {
        if (avail >= 4 && data[1] >= 0x80 && data[1] <= 0x8F && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
        {
            return 4;
        }
    }
    return 0; // invalid, incomplete, or must be diagnosed by the byte path
 }
 // Scalar (C++11) computation of the bulk run length: the number of leading
 // bytes in [data, data+n) that are ordinary ASCII or complete well-formed UTF-8
 // sequences, stopping before the first byte that needs individual handling (the
 // closing quote, an escape, a control character, or an ill-formed/truncated
 // sequence). ASCII is skipped 8 bytes at a time.
 inline std::size_t scalar_string_bulk_run(const unsigned char* data, std::size_t n) noexcept
 {
    std::size_t pos = 0;
    while (pos < n)
    {
        pos += find_string_special(data + pos, n - pos);
        if (pos >= n || data[pos] < 0x80u)
        {
            break; // end of buffer, or a quote/escape/control byte
        }
        const std::size_t seq = validate_one_utf8(data + pos, n - pos);
        if (seq == 0)
        {
            break; // ill-formed or truncated: let the byte path diagnose it
        }
        pos += seq;
    }
    return pos;
 }
 #if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
 // Index of the first quote/escape/control byte in [data, data+n) (non-ASCII
 // bytes are *not* stops here - the whole run is handed to simdutf), or n.
 inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t n) noexcept
 {
    constexpr std::uint64_t ones = 0x0101010101010101ull;
    constexpr std::uint64_t high = 0x8080808080808080ull;
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
        std::uint64_t v = 0;
        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull;
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull;
        const std::uint64_t hit = ((q - ones) & ~q & high)
                                  | ((b - ones) & ~b & high)
                                  | ((v - 0x2020202020202020ull) & ~v & high);
        if (hit != 0)
        {
            for (std::size_t j = 0; j < 8; ++j)
            {
                const unsigned char c = data[i + j];
                if (c == '\"' || c == '\\' || c < 0x20u)
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
    {
        const unsigned char c = data[i];
        if (c == '\"' || c == '\\' || c < 0x20u)
        {
            return i;
        }
    }
    return n;
 }
 #endif
 // Backend-dispatched bulk run length. With JSON_USE_SIMDUTF the run up to the
 // next delimiter is validated in one shot by simdutf; on the rare failure the
 // scalar helper recomputes the exact valid prefix so the byte path still
 // produces the precise diagnostic. Without it, the pure scalar path is used.
 inline std::size_t string_bulk_run(const unsigned char* data, std::size_t n) noexcept
 {
 #if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
    const std::size_t run = find_string_delimiter(data, n);
    if (run != 0 && simdutf::validate_utf8(reinterpret_cast<const char*>(data), run))
    {
        return run;
    }
 #endif
    return scalar_string_bulk_run(data, n);
 }
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -13,6 +13,7 @@
 #include <iterator> // back_inserter
 #include <memory> // shared_ptr, make_shared
 #include <string> // basic_string
 #include <utility> // move
 #include <vector> // vector
 #ifndef JSON_NO_IO
@@ -44,22 +45,32 @@ template<typename CharType> struct output_adapter_protocol
 template<typename CharType>
 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
-/// output adapter for byte vectors
+/// @brief non-virtual output sink writing into a std::vector
 ///
 /// This sink is not part of the virtual output_adapter_protocol hierarchy: it is
 /// passed to binary_writer by value as a template parameter, so
 /// write_character()/write_characters() are ordinary (inlinable) calls with no
 /// vtable lookup and no shared_ptr. It is used for the common
 /// `to_cbor`/`to_msgpack`/... into a std::vector. output_vector_adapter below
 /// wraps this same sink to provide the virtual interface.
 template<typename CharType, typename AllocatorType = std::allocator<CharType>>
-class output_vector_adapter : public output_adapter_protocol<CharType>
+class output_vector_sink
 {
  public:
-    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+    explicit output_vector_sink(std::vector<CharType, AllocatorType>& vec) noexcept
        : v(vec)
    {}
-    void write_character(CharType c) override
+    void write_character(CharType c)
    {
        v.push_back(c);
    }
-    JSON_HEDLEY_NON_NULL(2)
+    // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    void write_characters(const CharType* s, std::size_t length) override
+    // pointer with length 0 for empty strings/binary values. Appending an empty
    // range is a no-op; the type-erased path tolerates this via the (unattributed)
    // virtual base, and the concrete sink must do the same.
    void write_characters(const CharType* s, std::size_t length)
    {
        v.insert(v.end(), s, s + length);
    }
@@ -68,6 +79,34 @@ class output_vector_adapter : public output_adapter_protocol<CharType>
    std::vector<CharType, AllocatorType>& v;
 };
 /// output adapter for byte vectors
 ///
 /// The appending itself lives in output_vector_sink; this class only adds the
 /// virtual output_adapter_protocol interface on top of it, so both the
 /// type-erased and the templated path share one implementation.
 template<typename CharType, typename AllocatorType = std::allocator<CharType>>
 class output_vector_adapter : public output_adapter_protocol<CharType>
 {
  public:
    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
        : sink(vec)
    {}
    void write_character(CharType c) override
    {
        sink.write_character(c);
    }
    JSON_HEDLEY_NON_NULL(2)
    void write_characters(const CharType* s, std::size_t length) override
    {
        sink.write_characters(s, length);
    }
  private:
    output_vector_sink<CharType, AllocatorType> sink;
 };
 #ifndef JSON_NO_IO
 /// output adapter for output streams
 template<typename CharType>
@@ -118,6 +157,39 @@ class output_string_adapter : public output_adapter_protocol<CharType>
    StringType& str;
 };
 /// @brief output sink forwarding to a type-erased output adapter
 ///
 /// Wraps the polymorphic output_adapter_t so the same binary_writer template can
 /// also target arbitrary adapters (output streams, strings, user-provided
 /// adapters) via the `output_adapter`-based overloads. Each write still goes
 /// through one virtual call, exactly as before; only the concrete sinks above
 /// avoid it.
 template<typename CharType>
 class output_adapter_sink
 {
  public:
    explicit output_adapter_sink(output_adapter_t<CharType> adapter)
        : oa(std::move(adapter))
    {
        JSON_ASSERT(oa);
    }
    void write_character(CharType c)
    {
        oa->write_character(c);
    }
    // no JSON_HEDLEY_NON_NULL: forwards (null, 0) for empty payloads, exactly as
    // the type-erased path already did before this sink existed
    void write_characters(const CharType* s, std::size_t length)
    {
        oa->write_characters(s, length);
    }
  private:
    output_adapter_t<CharType> oa;
 };
 template<typename CharType, typename StringType = std::basic_string<CharType>>
 class output_adapter
 {
@@ -140,7 +140,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    friend ::nlohmann::detail::serializer<basic_json>;
    template<typename BasicJsonType>
    friend class ::nlohmann::detail::iter_impl;
-    template<typename BasicJsonType, typename CharType>
+    template<typename BasicJsonType, typename CharType, typename OutputSinkType>
    friend class ::nlohmann::detail::binary_writer;
    template<typename BasicJsonType, typename InputType, typename SAX>
    friend class ::nlohmann::detail::binary_reader;
@@ -187,6 +187,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename InputType>
    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
    // binary_writer over a concrete (non-virtual) sink appending into a std::vector,
    // used by the vector-returning to_* overloads
    template<typename CharType> using vector_binary_writer =
        ::nlohmann::detail::binary_writer<basic_json, CharType, ::nlohmann::detail::output_vector_sink<CharType>>;
    template<typename CharType> static vector_binary_writer<CharType> vector_writer(std::vector<CharType>& v)
    {
        return vector_binary_writer<CharType>(::nlohmann::detail::output_vector_sink<CharType>(v));
    }
  JSON_PRIVATE_UNLESS_TESTED:
    using serializer = ::nlohmann::detail::serializer<basic_json>;
@@ -1341,12 +1349,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                  const error_handler_t error_handler = error_handler_t::strict) const
    {
        string_t result;
-        detail::output_string_adapter<char, string_t> string_adapter(result);
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
        serializer s(string_adapter, indent_char, error_handler);
        if (indent >= 0)
        {
-            s.dump(*this, true, ensure_ascii, static_cast<std::size_t>(indent));
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
        }
        else
        {
@@ -4056,8 +4063,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        o.width(0);
        // do the actual serialization
-        detail::output_stream_adapter<char> stream_adapter(o);
+        serializer s(detail::output_adapter<char>(o), o.fill());
        serializer s(stream_adapter, o.fill());
        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
        return o;
    }
@@ -4342,7 +4348,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
-        to_cbor(j, result);
+        result.reserve(detail::binary_reserve_hint(j));
        vector_writer(result).write_cbor(j);
        return result;
    }
@@ -4365,7 +4372,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
-        to_msgpack(j, result);
+        result.reserve(detail::binary_reserve_hint(j));
        vector_writer(result).write_msgpack(j);
        return result;
    }
@@ -4390,7 +4398,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            const bool use_type = false)
    {
        std::vector<std::uint8_t> result;
-        to_ubjson(j, result, use_size, use_type);
+        result.reserve(detail::binary_reserve_hint(j));
        vector_writer(result).write_ubjson(j, use_size, use_type);
        return result;
    }
@@ -4418,7 +4427,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            const bjdata_version_t version = bjdata_version_t::draft2)
    {
        std::vector<std::uint8_t> result;
-        to_bjdata(j, result, use_size, use_type, version);
+        result.reserve(detail::binary_reserve_hint(j));
        vector_writer(result).write_ubjson(j, use_size, use_type, true, true, version);
        return result;
    }
@@ -4445,7 +4455,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static std::vector<std::uint8_t> to_bson(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
-        to_bson(j, result);
+        result.reserve(detail::binary_reserve_hint(j));
        vector_writer(result).write_bson(j);
        return result;
    }
@@ -2,9 +2,6 @@ cmake_minimum_required(VERSION 3.13...4.0)
 option(JSON_Valgrind    "Execute test suite with Valgrind." OFF)
 option(JSON_FastTests   "Skip expensive/slow tests." OFF)
 option(JSON_TestSimdutf "Build the unit tests against the simdutf UTF-8 validation backend." OFF)
 set(JSON_SIMDUTF_VERSION 9.1.0 CACHE STRING "The simdutf version used by JSON_TestSimdutf.")
 set(JSON_32bitTest     AUTO CACHE STRING "Enable the 32bit unit test (ON/OFF/AUTO/ONLY).")
 set(JSON_TestStandards "" CACHE STRING "The list of standards to test explicitly.")
@@ -152,71 +149,6 @@ if(test_force)
 endif()
 message(STATUS "${msg}")
 #############################################################################
 # optionally validate UTF-8 with simdutf (JSON_USE_SIMDUTF)
 #############################################################################
 # The simdutf backend is opt-in and not vendored, so it is fetched here rather
 # than being a checked-in dependency. Everything below hangs off test_main,
 # whose usage requirements every test target inherits; the library target and
 # the installed CMake package are deliberately left untouched.
 if (JSON_TestSimdutf)
    # simdutf requires C++17, both to compile itself and to be reachable from
    # the library, which keeps its scalar validator below that. Find a tested
    # standard that satisfies it.
    set(simdutf_standard "")
    foreach(cxx_standard ${test_cxx_standards})
        if(NOT cxx_standard LESS 17 AND compiler_supports_cpp_${cxx_standard})
            set(simdutf_standard ${cxx_standard})
            break()
        endif()
    endforeach()
    if("${simdutf_standard}" STREQUAL "")
        # Building simdutf would fail outright without a C++17 compiler, and
        # even with one it would go unused if no C++17-or-later standard is
        # tested. Say so and fall back to the scalar validator rather than
        # failing the build.
        if(NOT compiler_supports_cpp_17)
            set(simdutf_reason "the compiler does not support C++17")
        else()
            set(simdutf_reason "no tested standard is C++17 or later (testing ${msg_standards})")
        endif()
        message(WARNING
            "JSON_TestSimdutf is enabled, but ${simdutf_reason}. simdutf requires C++17, so it "
            "is not fetched and JSON_USE_SIMDUTF is not defined: the tests run against the "
            "built-in scalar UTF-8 validator instead. Set JSON_TestStandards to include 17 or "
            "later, or build with a compiler that supports C++17.")
    else()
        if (CMAKE_VERSION VERSION_LESS 3.18)
            message(FATAL_ERROR "JSON_TestSimdutf requires CMake 3.18 or later (simdutf's minimum).")
        endif()
        include(FetchContent)
        # simdutf builds its tests and tools by default, and its tests pull
        # further dependencies of their own; only the library is needed here
        set(SIMDUTF_TESTS OFF CACHE BOOL "" FORCE)
        set(SIMDUTF_TOOLS OFF CACHE BOOL "" FORCE)
        set(SIMDUTF_BENCHMARKS OFF CACHE BOOL "" FORCE)
        set(SIMDUTF_ICONV OFF CACHE BOOL "" FORCE)
        FetchContent_Declare(simdutf
            URL https://github.com/simdutf/simdutf/archive/refs/tags/v${JSON_SIMDUTF_VERSION}.tar.gz
            DOWNLOAD_EXTRACT_TIMESTAMP TRUE
        )
        FetchContent_MakeAvailable(simdutf)
        target_compile_definitions(test_main PUBLIC JSON_USE_SIMDUTF)
        target_link_libraries(test_main PUBLIC simdutf::simdutf)
        # simdutf.h requires C++17; below that the library keeps its scalar
        # validator, so any C++11/14 test targets exercise the fallback and the
        # C++17-and-later ones exercise simdutf. Both must agree.
        message(STATUS "UTF-8 validation delegated to simdutf ${JSON_SIMDUTF_VERSION} for C++17 and later (JSON_USE_SIMDUTF)")
    endif()
 endif()
 # *DO* use json_test_set_test_options() above this line
 json_test_should_build_32bit_test(json_32bit_test json_32bit_test_only "${JSON_32bitTest}")
@@ -0,0 +1,198 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #include <cstdint>
 #include <string>
 #include <vector>
 namespace
 {
 // a spread of values exercising every writer path: scalars of each width, the
 // float paths, strings, binary, and containers big enough to reallocate
 std::vector<json> test_values()
 {
    json big_array = json::array();
    for (int i = 0; i < 5000; ++i)
    {
        big_array.push_back(i);
    }
    json big_object = json::object();
    for (int i = 0; i < 1000; ++i)
    {
        big_object[std::to_string(i)] = i;
    }
    return
    {
        json(nullptr), json(true), json(false),
        json(0), json(-1), json(255), json(-129), json(65535), json(-32769),
        json(4294967295U), json(-2147483649LL), json(18446744073709551615ULL),
        json(0.0), json(-0.5), json(3.1415926535897932),
        json(""), json("hello"), json(std::string(1000, 'x')),
        json::binary({0x00, 0x01, 0x02}, 42),
        json::array(), json::object(),
        json::array({1, 2, 3}), json({{"a", 1}, {"b", nullptr}}),
        json({{"nested", {{"deep", json::array({1, "two", 3.0, nullptr})}}}}),
        big_array, big_object
    };
 }
 // values to_bson() accepts: the document must be an object
 std::vector<json> bson_values()
 {
    json big_object = json::object();
    for (int i = 0; i < 1000; ++i)
    {
        big_object[std::to_string(i)] = i;
    }
    return
    {
        json::object(),
        json({{"a", 1}, {"b", nullptr}, {"c", true}, {"d", 2.5}, {"e", "text"}}),
        json({{"arr", json::array({1, 2, 3})}, {"obj", {{"k", "v"}}}}),
        big_object
    };
 }
 } // namespace
 // The vector-returning to_*(j) overloads write through the non-virtual
 // output_vector_sink, while to_*(j, adapter) goes through output_adapter_sink.
 // The two are separate code paths that must stay byte-for-byte identical; these
 // checks fail if either overload is ever changed without the other.
 TEST_CASE("binary writer output sinks")
 {
    SECTION("vector sink and adapter sink agree")
    {
        // note: no SUBCASE inside these loops - doctest keys subcases by
        // name/file/line, so a subcase in a loop body would only ever run for
        // the first iteration
        for (const auto& j : test_values())
        {
            CAPTURE(j.dump(-1, ' ', false, json::error_handler_t::replace));
            std::vector<std::uint8_t> cbor;
            json::to_cbor(j, cbor);
            CHECK(json::to_cbor(j) == cbor);
            std::vector<std::uint8_t> msgpack;
            json::to_msgpack(j, msgpack);
            CHECK(json::to_msgpack(j) == msgpack);
            for (const bool use_size :
                    {
                        false, true
                    })
            {
                for (const bool use_type :
                        {
                            false, true
                        })
                {
                    if (use_type && !use_size)
                    {
                        continue; // not a supported combination
                    }
                    CAPTURE(use_size);
                    CAPTURE(use_type);
                    std::vector<std::uint8_t> ubjson;
                    json::to_ubjson(j, ubjson, use_size, use_type);
                    CHECK(json::to_ubjson(j, use_size, use_type) == ubjson);
                }
            }
            for (const auto version :
                    {
                        json::bjdata_version_t::draft2, json::bjdata_version_t::draft3
                    })
            {
                std::vector<std::uint8_t> bjdata;
                json::to_bjdata(j, bjdata, false, false, version);
                CHECK(json::to_bjdata(j, false, false, version) == bjdata);
            }
        }
        for (const auto& j : bson_values())
        {
            CAPTURE(j.dump());
            std::vector<std::uint8_t> bson;
            json::to_bson(j, bson);
            CHECK(json::to_bson(j) == bson);
        }
    }
    SECTION("the char adapter produces the same bytes")
    {
        for (const auto& j : test_values())
        {
            CAPTURE(j.dump(-1, ' ', false, json::error_handler_t::replace));
            const std::vector<std::uint8_t> expected = json::to_cbor(j);
            std::vector<char> as_char;
            json::to_cbor(j, as_char);
            REQUIRE(as_char.size() == expected.size());
            std::vector<std::uint8_t> as_bytes;
            as_bytes.reserve(as_char.size());
            for (const char c : as_char)
            {
                as_bytes.push_back(static_cast<std::uint8_t>(c));
            }
            CHECK(as_bytes == expected);
        }
    }
 }
 // binary_reserve_hint() is documented as a *lower* bound on the serialized size,
 // so that reserving it up front can never leave the returned vector holding
 // capacity beyond what the value actually needs.
 TEST_CASE("binary_reserve_hint never over-reserves")
 {
    for (const auto& j : test_values())
    {
        CAPTURE(j.dump(-1, ' ', false, json::error_handler_t::replace));
        const std::size_t hint = nlohmann::detail::binary_reserve_hint(j);
        CHECK(hint <= json::to_cbor(j).size());
        CHECK(hint <= json::to_msgpack(j).size());
        CHECK(hint <= json::to_ubjson(j).size());
        CHECK(hint <= json::to_ubjson(j, true, true).size());
        CHECK(hint <= json::to_bjdata(j).size());
    }
    for (const auto& j : bson_values())
    {
        CAPTURE(j.dump());
        CHECK(nlohmann::detail::binary_reserve_hint(j) <= json::to_bson(j).size());
    }
    SECTION("scalars get no hint")
    {
        CHECK(nlohmann::detail::binary_reserve_hint(json(nullptr)) == 0);
        CHECK(nlohmann::detail::binary_reserve_hint(json(42)) == 0);
        CHECK(nlohmann::detail::binary_reserve_hint(json("a string")) == 0);
        CHECK(nlohmann::detail::binary_reserve_hint(json::binary({0x01})) == 0);
    }
    SECTION("containers are hinted from their element count")
    {
        CHECK(nlohmann::detail::binary_reserve_hint(json::array()) == 1);
        CHECK(nlohmann::detail::binary_reserve_hint(json::array({1, 2, 3})) == 4);
        CHECK(nlohmann::detail::binary_reserve_hint(json::object()) == 1);
        CHECK(nlohmann::detail::binary_reserve_hint(json({{"a", 1}, {"b", 2}})) == 5);
    }
 }
@@ -12,10 +12,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #include <sstream> // stringstream
 #include <string> // string
 #include <vector> // vector
 namespace
 {
 // shortcut to scan a string literal
@@ -228,381 +224,3 @@ TEST_CASE("lexer class")
        CHECK((scan_string("/**//**//**/", true) == json::lexer::token_type::end_of_input));
    }
 }
 TEST_CASE("lexer number fast path")
 {
    // The contiguous fast path (used for pointer/string input) must agree with
    // the streaming byte path (used for std::istream) on token type, numeric
    // value, and round-trip text for every well-formed number, and reject the
    // same malformed numbers with the same message.
    SECTION("contiguous vs streaming parity")
    {
        const std::vector<std::string> numbers =
        {
            "0", "-0", "1", "-1", "42", "-42", "10", "100", "1234567890",
            "0.0", "-0.0", "3.14", "-3.14", "0.5", "-0.001", "123.456789",
            "1e0", "1E0", "1e10", "1e-10", "1e+10", "1.5e3", "-2.5E-4",
            "9223372036854775807",             // INT64_MAX -> unsigned
            "9223372036854775808",             // INT64_MAX + 1 -> unsigned
            "18446744073709551615",            // UINT64_MAX -> unsigned
            "18446744073709551616",            // UINT64_MAX + 1 -> float
            "-9223372036854775808",            // INT64_MIN -> integer
            "-9223372036854775809",            // INT64_MIN - 1 -> float
            "123456789012345678901234567890",  // huge -> float
            "0.30000000000000004", "2.2250738585072014e-308", "1e308",
            // high-precision / wide-exponent values that exercise the
            // std::from_chars (Eisel-Lemire) path beyond the Clinger subset
            "1.7976931348623157e308", "1.2345678901234567e-250",
            "9007199254740993", "5e-324", "1e-320"
        };
        for (const auto& n : numbers)
        {
            const std::string doc = "[" + n + "]";
            // contiguous fast path
            const json a = json::parse(doc);
            // streaming byte path
            std::stringstream ss(doc);
            const json b = json::parse(ss);
            CAPTURE(n);
            CHECK(a == b);
            CHECK(a.dump() == b.dump());
            CHECK(a[0].type() == b[0].type());
        }
    }
    SECTION("token type classification")
    {
        CHECK((scan_string("0") == json::lexer::token_type::value_unsigned));
        CHECK((scan_string("-1") == json::lexer::token_type::value_integer));
        CHECK((scan_string("1.5") == json::lexer::token_type::value_float));
        CHECK((scan_string("1e5") == json::lexer::token_type::value_float));
        CHECK((scan_string("18446744073709551615") == json::lexer::token_type::value_unsigned));
        CHECK((scan_string("18446744073709551616") == json::lexer::token_type::value_float));
        CHECK((scan_string("-9223372036854775808") == json::lexer::token_type::value_integer));
        CHECK((scan_string("-9223372036854775809") == json::lexer::token_type::value_float));
    }
    SECTION("malformed numbers are rejected identically")
    {
        for (const char* bad :
                {"-", "1.", "1e", "1e+", "1.2e", "01", "-01", "1..2", "1.2.3"
                })
        {
            CAPTURE(bad);
            // the contiguous fast path must decline and let the byte path report
            const std::string doc = std::string("[") + bad + "]";
            CHECK_FALSE(json::accept(doc));
            std::stringstream ss(doc);
            CHECK_FALSE(json::accept(ss));
        }
    }
 #if !defined(JSON_NOEXCEPTION)
    // these sections parse invalid input, which aborts when exceptions are off
    SECTION("exhaustive grammar parity with the streaming path")
    {
        // The JSON number grammar is encoded twice: once as the scan_number()
        // state machine and once as the contiguous fast path. Enumerate every
        // short string over the number alphabet and require the two encodings to
        // agree exactly - on acceptance, on the reported error, and on the parsed
        // value - so they cannot drift apart.
        const std::string alphabet = "01.eE+-";
        // full outcome of parsing @a doc, so a mismatch in type, value, or error
        // message is caught, not just a mismatch in acceptance
        const auto outcome = [](const std::string & doc, bool streaming) -> std::string
        {
            try
            {
                if (streaming)
                {
                    std::stringstream ss(doc);
                    const json j = json::parse(ss);
                    return std::string(j[0].type_name()) + '|' + j.dump();
                }
                const json j = json::parse(doc);
                return std::string(j[0].type_name()) + '|' + j.dump();
            }
            catch (const json::parse_error& e)
            {
                return {e.what()};
            }
        };
        std::vector<std::string> mismatches;
        std::vector<std::string> tokens{""};
        for (std::size_t length = 1; length <= 4; ++length)
        {
            std::vector<std::string> next;
            next.reserve(tokens.size() * alphabet.size());
            for (const auto& prefix : tokens)
            {
                for (const char c : alphabet)
                {
                    next.push_back(prefix + c);
                }
            }
            tokens = next;
            for (const auto& token : tokens)
            {
                const std::string doc = "[" + token + "]";
                if (outcome(doc, false) != outcome(doc, true))
                {
                    mismatches.push_back(doc);
                }
            }
        }
        // 7 + 49 + 343 + 2401 tokens
        CHECK(tokens.size() == 2401);
        CAPTURE(mismatches);
        CHECK(mismatches.empty());
    }
    SECTION("error positions match the streaming path")
    {
        // Rejecting identically is not enough: the fast path must also report the
        // error at the same position as the byte path. A number directly followed
        // by a newline is the interesting case, because the byte path reaches the
        // newline (which resets the column) and then ungets it.
        // returns the parse_error message, or "" if the document parsed
        const auto contiguous_error = [](const std::string & doc) -> std::string
        {
            try
            {
                const json j = json::parse(doc);
                static_cast<void>(j);
            }
            catch (const json::parse_error& e)
            {
                return {e.what()};
            }
            return {};
        };
        const auto streaming_error = [](const std::string & doc) -> std::string
        {
            try
            {
                std::stringstream ss(doc);
                const json j = json::parse(ss);
                static_cast<void>(j);
            }
            catch (const json::parse_error& e)
            {
                return {e.what()};
            }
            return {};
        };
        for (const char* bad :
                {"[01\n]", "[00\n]", "[-01\n]", "{1\n}", "[1\n2]", "[1.2.3\n]",
                 "[1 \n2]", "[\n1\n2]", "1\n2", "[01\r\n]", "[1e\n]", "[-\n]"
                })
        {
            CAPTURE(bad);
            const std::string doc = bad;
            const std::string contiguous_what = contiguous_error(doc);
            CHECK_FALSE(contiguous_what.empty());
            CHECK(contiguous_what == streaming_error(doc));
        }
        // A number terminated by a newline must report the same position as the
        // same number terminated by anything else: scan_number() reads the
        // terminator and ungets it, so the reported column is the one reached
        // after the number's last character - not the 0 that an unget() across
        // the newline used to leave behind.
        CHECK(contiguous_error("[01\n]") == contiguous_error("[01 ]"));
        CHECK(contiguous_error("[01\n]") ==
              "[json.exception.parse_error.101] parse error at line 1, column 3: "
              "syntax error while parsing array - unexpected number literal; expected ']'");
        // the same for a multi-character token, where the column of the last
        // character (the '3' of "-2.5e3") differs from the column it starts at
        CHECK(contiguous_error("null -2.5e3\nfalse") == contiguous_error("null -2.5e3 false"));
        CHECK(contiguous_error("null -2.5e3\nfalse") ==
              "[json.exception.parse_error.101] parse error at line 1, column 11: "
              "syntax error while parsing value - unexpected number literal; expected end of input");
    }
 #endif
 }
 TEST_CASE("lexer string fast path")
 {
    // Build a byte string from explicit values: a hex escape in a string
    // literal swallows every following hex digit, which makes sequences like
    // "\xC3\xA9b" mean something other than they look like.
    const auto bytes = [](std::initializer_list<int> values)
    {
        std::string result;
        for (const int value : values)
        {
            result.push_back(static_cast<char>(value));
        }
        return result;
    };
 #if !defined(JSON_NOEXCEPTION)
    // the full outcome of parsing @a doc: the parsed value, or the exact error
    // message, so a mismatch in either is caught. Only usable with exceptions
    // on: parsing invalid input aborts when they are off.
    const auto outcome = [](const std::string & doc, bool streaming) -> std::string
    {
        try
        {
            if (streaming)
            {
                std::stringstream ss(doc);
                const json j = json::parse(ss);
                return j.dump();
            }
            const json j = json::parse(doc);
            return j.dump();
        }
        // not just parse_error: if a bulk scanner ever let ill-formed UTF-8
        // through, dump() would throw type_error.316, and that has to surface
        // as a reported mismatch rather than as an uncaught exception
        catch (const json::exception& e)
        {
            return {e.what()};
        }
    };
 #endif
    // once at the start of the string, once past the first 8-byte SWAR word, so
    // the bulk scanner sees each case with and without a run behind it
    const std::vector<std::size_t> offsets{0, 9};
 #if !defined(JSON_NOEXCEPTION)
    SECTION("exhaustive contiguous vs streaming parity")
    {
        // ordinary ASCII, both specials, a control byte, characters that make
        // the preceding backslash a valid escape, a UTF-8 lead byte of each
        // length, a continuation byte, and a byte that is never valid
        const std::vector<std::string> alphabet =
        {
            "a", "\"", "\\", "n", "u", "0", bytes({0x01}),
            bytes({0xC3}), bytes({0xA9}), bytes({0xE4}), bytes({0xF0}),
            bytes({0x80}), bytes({0xFF})
        };
        std::vector<std::string> mismatches;
        std::vector<std::string> tokens{""};
        for (std::size_t length = 1; length <= 3; ++length)
        {
            std::vector<std::string> next;
            next.reserve(tokens.size() * alphabet.size());
            for (const auto& prefix : tokens)
            {
                for (const auto& symbol : alphabet)
                {
                    next.push_back(prefix + symbol);
                }
            }
            tokens = next;
            for (const auto& token : tokens)
            {
                for (const std::size_t offset : offsets)
                {
                    const std::string doc = "[\"" + std::string(offset, 'a') + token + "\"]";
                    if (outcome(doc, false) != outcome(doc, true))
                    {
                        mismatches.push_back(doc);
                    }
                }
            }
        }
        // 13 + 169 + 2197 tokens, each at two offsets
        CHECK(tokens.size() == 2197);
        CAPTURE(mismatches);
        CHECK(mismatches.empty());
    }
    SECTION("special bytes at every offset of the SWAR stride")
    {
        // The bulk scanner consumes 8 bytes at a time and then a tail; place
        // every kind of byte that ends a run at each offset across two words,
        // so multibyte sequences also straddle the word boundary.
        const std::vector<std::string> specials =
        {
            "\"", "\\", bytes({0x01}), bytes({0x1F}), bytes({0x7F}),
            bytes({0xC3, 0xA9}), bytes({0xE4, 0xB8, 0xAD}), bytes({0xF0, 0x9F, 0x98, 0x80}),
            bytes({0xFF}), bytes({0xC3}), bytes({0xE4, 0xB8})
        };
        std::vector<std::string> mismatches;
        for (std::size_t offset = 0; offset <= 17; ++offset)
        {
            for (const auto& special : specials)
            {
                const std::string doc = "[\"" + std::string(offset, 'a') + special + "\"]";
                if (outcome(doc, false) != outcome(doc, true))
                {
                    mismatches.push_back(doc);
                }
            }
        }
        CAPTURE(mismatches);
        CHECK(mismatches.empty());
    }
 #endif
    // json::accept() never throws, so the ranges stay covered without exceptions
    SECTION("UTF-8 ranges are accepted and rejected as documented")
    {
        // The bulk validator must accept exactly what the byte-at-a-time
        // scanner accepts, so pin the boundaries of every range it recognizes.
        // aggregate, only ever brace-initialized below; default member
        // initializers would stop it being an aggregate in C++11
        struct utf8_case // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
        {
            std::string sequence;
            bool valid;
            const char* description;
        };
        const std::vector<utf8_case> cases =
        {
            {bytes({0xC2, 0x80}), true, "U+0080, shortest two-byte"},
            {bytes({0xDF, 0xBF}), true, "U+07FF, longest two-byte"},
            {bytes({0xC1, 0xBF}), false, "overlong two-byte"},
            {bytes({0xC2, 0x7F}), false, "two-byte with bad continuation"},
            {bytes({0xE0, 0xA0, 0x80}), true, "U+0800, shortest three-byte"},
            {bytes({0xE0, 0x9F, 0xBF}), false, "overlong three-byte"},
            {bytes({0xED, 0x9F, 0xBF}), true, "U+D7FF, just below the surrogates"},
            {bytes({0xED, 0xA0, 0x80}), false, "surrogate U+D800"},
            {bytes({0xED, 0xBF, 0xBF}), false, "surrogate U+DFFF"},
            {bytes({0xEE, 0x80, 0x80}), true, "U+E000, just above the surrogates"},
            {bytes({0xEF, 0xBF, 0xBF}), true, "U+FFFF"},
            {bytes({0xF0, 0x90, 0x80, 0x80}), true, "U+10000, shortest four-byte"},
            {bytes({0xF0, 0x8F, 0xBF, 0xBF}), false, "overlong four-byte"},
            {bytes({0xF4, 0x8F, 0xBF, 0xBF}), true, "U+10FFFF, highest code point"},
            {bytes({0xF4, 0x90, 0x80, 0x80}), false, "above U+10FFFF"},
            {bytes({0xF5, 0x80, 0x80, 0x80}), false, "lead byte out of range"},
            {bytes({0x80}), false, "bare continuation byte"},
            {bytes({0xFF}), false, "byte that never appears in UTF-8"},
            {bytes({0xC3}), false, "truncated two-byte"},
            {bytes({0xE4, 0xB8}), false, "truncated three-byte"},
            {bytes({0xF0, 0x9F, 0x98}), false, "truncated four-byte"}
        };
        for (const auto& test_case : cases)
        {
            CAPTURE(test_case.description);
            for (const std::size_t offset : offsets)
            {
                CAPTURE(offset);
                const std::string doc = "[\"" + std::string(offset, 'a') + test_case.sequence + "\"]";
                CHECK(json::accept(doc) == test_case.valid);
 #if !defined(JSON_NOEXCEPTION)
                CHECK(outcome(doc, false) == outcome(doc, true));
 #endif
            }
        }
    }
 }
@@ -98,10 +98,8 @@ void check_escaped(const char* original, const char* escaped = "", bool ensure_a
 void check_escaped(const char* original, const char* escaped, const bool ensure_ascii)
 {
    std::stringstream ss;
-    nlohmann::detail::output_stream_adapter<char> adapter(ss);
+    json::serializer s(nlohmann::detail::output_adapter<char>(ss), ' ');
    json::serializer s(adapter, ' ');
    s.dump_escaped(original, ensure_ascii);
    s.flush(); // dump_escaped writes into the serializer's internal buffer
    CHECK(ss.str() == escaped);
 }
 } // namespace
@@ -382,232 +382,3 @@ TEST_CASE("dump for basic_json with long double number_float_t")
        check_same(100.0L,  100.0);
    }
 }
 TEST_CASE("serialization of strings (bulk fast path)")
 {
    // These cases exercise the SWAR bulk-copy fast path in dump_escaped and the
    // internal write buffer: long runs, escapes interrupting runs, 0x7F/DEL,
    // multibyte UTF-8 under both ensure_ascii settings, and payloads larger than
    // the write buffer.
    SECTION("long unescaped ASCII exceeds the write buffer")
    {
        const std::string big(3000, 'a');
        const json j = big;
        CHECK(j.dump() == '"' + big + '"');
        CHECK(j.dump(-1, ' ', true) == '"' + big + '"');
        // round-trips
        CHECK(json::parse(j.dump()) == j);
    }
    SECTION("runs interrupted by escapes")
    {
        const json j = std::string(500, 'x') + "\n\"\\" + std::string(500, 'y');
        const std::string out = j.dump();
        CHECK(out == '"' + std::string(500, 'x') + "\\n\\\"\\\\" + std::string(500, 'y') + '"');
        CHECK(json::parse(out) == j);
    }
    SECTION("DEL (0x7F) depends on ensure_ascii")
    {
        const json j = std::string("a\x7f" "b");
        CHECK(j.dump(-1, ' ', false) == "\"a\x7f" "b\"");   // copied verbatim
        CHECK(j.dump(-1, ' ', true) == "\"a\\u007fb\"");    // escaped
    }
    SECTION("multibyte UTF-8 under both ensure_ascii settings")
    {
        const json j = std::string("A\xc3\xa9\xe4\xbd\xa0\xf0\x9f\x98\x80Z"); // A é 你 😀 Z
        // not escaping non-ASCII: bytes are copied through the bulk validator
        CHECK(j.dump(-1, ' ', false) == "\"A\xc3\xa9\xe4\xbd\xa0\xf0\x9f\x98\x80Z\"");
        // ensure_ascii: escaped (with a surrogate pair for the emoji)
        CHECK(j.dump(-1, ' ', true) == "\"A\\u00e9\\u4f60\\ud83d\\ude00Z\"");
        CHECK(json::parse(j.dump(-1, ' ', true)) == j);
    }
    SECTION("many small structural writes exceed the write buffer")
    {
        json arr = json::array();
        for (int i = 0; i < 2000; ++i)
        {
            arr.push_back(i);
        }
        const std::string out = arr.dump();
        CHECK(out.front() == '[');
        CHECK(out.back() == ']');
        CHECK(json::parse(out) == arr);
        json obj = json::object();
        for (int i = 0; i < 500; ++i)
        {
            obj["key" + std::to_string(i)] = i;
        }
        CHECK(json::parse(obj.dump()) == obj);
        CHECK(json::parse(obj.dump(2)) == obj);
        // an array of many empty strings emits a long run of single-character
        // writes ('"', '"', ',') at shallow nesting depth, so the write buffer
        // fills and flushes mid-run without the deep recursion that would
        // overflow the stack on some debug builds
        json many_empty = json::array();
        for (int i = 0; i < 500; ++i)
        {
            many_empty.push_back("");
        }
        const std::string out2 = many_empty.dump();
        CHECK(out2.size() > 1024); // spans multiple write-buffer flushes
        CHECK(out2.front() == '[');
        CHECK(out2.back() == ']');
        CHECK(json::parse(out2) == many_empty);
    }
    SECTION("invalid UTF-8 handling is unaffected by the fast path")
    {
        const json j = std::string("valid\xff" "more");
        CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0xFF", json::type_error&);
        CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"valid\xef\xbf\xbd" "more\"");
        CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"valid\\ufffdmore\"");
        CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"validmore\"");
    }
 }
 TEST_CASE("indentation is written straight into the write buffer")
 {
    // put_indent() memsets the indentation into the write buffer instead of
    // copying it out of a pre-grown indentation string. These cases cover an
    // indentation wider than the buffer, a non-space indentation character, and
    // nesting deep enough that the accumulated indentation spans several
    // buffer-fulls - the situations the old grow-a-string approach got wrong.
    SECTION("indent_step wider than the write buffer")
    {
        const json j = {{"a", 1}};
        // 2000 > the 1024-byte write buffer, and > the 512 the indentation
        // string used to start at
        CHECK(j.dump(2000) == "{\n" + std::string(2000, ' ') + "\"a\": 1\n}");
        // several whole buffer-fulls, so the buffer is refilled once and then
        // flushed repeatedly
        CHECK(j.dump(5000) == "{\n" + std::string(5000, ' ') + "\"a\": 1\n}");
        CHECK(j.dump(5000, '\t') == "{\n" + std::string(5000, '\t') + "\"a\": 1\n}");
        // an exact multiple of the buffer size
        CHECK(j.dump(4096) == "{\n" + std::string(4096, ' ') + "\"a\": 1\n}");
    }
    SECTION("a non-space indentation character is used throughout")
    {
        const json j = {{"a", 1}};
        // 600 is past the point where the indentation used to be grown, which
        // is where a hard-coded space would have shown up
        CHECK(j.dump(600, '\t') == "{\n" + std::string(600, '\t') + "\"a\": 1\n}");
        CHECK(j.dump(3, '.') == "{\n...\"a\": 1\n}");
    }
    SECTION("accumulated indentation spans several buffer-fulls")
    {
        // five levels deep at 400 per level: the innermost value is indented by
        // 2000 characters, reached in steps that each straddle the buffer end
        json j = json::array({1});
        for (int i = 0; i < 4; ++i)
        {
            j = json::array({j});
        }
        const std::string out = j.dump(400);
        CHECK(out.find(std::string("\n") + std::string(2000, ' ') + "1\n") != std::string::npos);
        CHECK(json::parse(out) == j);
    }
    SECTION("indentation is unchanged for ordinary widths")
    {
        const json j = {{"a", {1, 2}}, {"b", nullptr}};
        CHECK(j.dump(2) == "{\n  \"a\": [\n    1,\n    2\n  ],\n  \"b\": null\n}");
        CHECK(j.dump(0) == "{\n\"a\": [\n1,\n2\n],\n\"b\": null\n}");
    }
 }
 TEST_CASE("serialization of deeply nested values")
 {
    // dump() descends into a bounded number of levels and writes out whatever
    // is nested deeper than that without the call stack; see
    // https://github.com/nlohmann/json/issues/5387
    SECTION("nested deeper than the call stack could follow")
    {
        // parsing is iterative, so building these costs little
        const std::size_t depth = 100000;
        const std::string array_text = std::string(depth, '[') + '0' + std::string(depth, ']');
        CHECK(json::parse(array_text).dump() == array_text);
        std::string object_text;
        object_text.reserve((6 * depth) + 1);
        for (std::size_t i = 0; i < depth; ++i)
        {
            object_text += "{\"a\":";
        }
        object_text += '1';
        object_text.append(depth, '}');
        CHECK(json::parse(object_text).dump() == object_text);
    }
    SECTION("depths around the bound of the descent")
    {
        // Cover every depth around the bound, so that the two ways of writing a
        // value are known to meet cleanly - wherever the bound is set.
        for (std::size_t d = 1; d <= 300; ++d)
        {
            CAPTURE(d);
            const std::string array_text = std::string(d, '[') + '7' + std::string(d, ']');
            CHECK(json::parse(array_text).dump() == array_text);
            std::string object_text;
            for (std::size_t i = 0; i < d; ++i)
            {
                object_text += "{\"k\":";
            }
            object_text += '7';
            object_text.append(d, '}');
            CHECK(json::parse(object_text).dump() == object_text);
        }
    }
    SECTION("pretty-printing across the bound")
    {
        for (std::size_t d = 120; d <= 140; ++d)
        {
            CAPTURE(d);
            const json j = json::parse(std::string(d, '[') + '7' + std::string(d, ']'));
            std::string expected;
            for (std::size_t i = 0; i < d; ++i)
            {
                expected += std::string(2 * i, ' ') + "[\n";
            }
            expected += std::string(2 * d, ' ') + '7';
            for (std::size_t i = d; i > 0; --i)
            {
                expected += '\n' + std::string(2 * (i - 1), ' ') + ']';
            }
            CHECK(j.dump(2) == expected);
        }
    }
    SECTION("an empty container below the bound")
    {
        // an empty container is written out in full and never descended into,
        // so it must not gain a newline when it is reached iteratively
        for (std::size_t d = 125; d <= 135; ++d)
        {
            CAPTURE(d);
            const std::string compact = std::string(d, '[') + "[]" + std::string(d, ']');
            CHECK(json::parse(compact).dump() == compact);
            const std::string with_object = std::string(d, '[') + "{}" + std::string(d, ']');
            CHECK(json::parse(with_object).dump() == with_object);
        }
    }
 }
@@ -18,12 +18,7 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #include <array> // array
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t
 #include <list>
 #include <string> // string
 #include <vector> // vector
 #if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
    #include <iterator>
@@ -217,66 +212,6 @@ TEST_CASE("Parse with heterogeneous iterator and sentinel types")
    CHECK(j2.at(0) == 1);
 }
 // A type whose data() hands out raw bytes but whose size() counts something
 // else - here fixed-size records. Reading [data(), data() + size()) as bytes
 // would silently truncate the input, so data() and size() alone must not be
 // taken as evidence of contiguous byte storage.
 struct record_buffer
 {
    using value_type = std::array<char, 4>;
    std::string bytes;
    const char* data() const noexcept
    {
        return bytes.data();
    }
    std::size_t size() const noexcept
    {
        return bytes.size() / sizeof(value_type);
    }
    const char* begin() const noexcept
    {
        return bytes.data();
    }
    const char* end() const noexcept
    {
        return bytes.data() + bytes.size();
    }
 };
 TEST_CASE("Contiguous byte containers take the pointer adapter")
 {
    // Containers with contiguous single-byte storage are routed through the
    // pointer-based adapter so the bulk fast paths apply in every standard, not
    // only in C++20 where the library iterators model std::contiguous_iterator.
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::string>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::vector<char>>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::vector<std::uint8_t>>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::array<char, 4>>::value);
    // input_adapter() takes its container by forwarding reference, so the trait
    // is also asked about reference types
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::string&>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<const std::string&>::value);
    // everything else keeps the iterator-based adapter
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<std::list<char>>::value);
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<std::vector<int>>::value);
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<const char*>::value);
    // including a type that has data() and size() but whose size() does not
    // count the units data() points at: its value_type says so
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<record_buffer>::value);
    // and such a container still parses through its iterators, in full - taking
    // it for a byte container would stop after data() + size() bytes
    const record_buffer buffer{"[1,2,3,4,5]"};
    CHECK(buffer.data() == buffer.bytes.data());
    CHECK(buffer.size() * sizeof(record_buffer::value_type) < buffer.bytes.size());
    CHECK(json::parse(buffer) == json({1, 2, 3, 4, 5}));
 }
 #if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
 // JSON_HAS_CPP_20 (do not remove; see note at top of file)
 TEST_CASE("Parse with std::counted_iterator and std::default_sentinel_t")
@@ -293,180 +228,6 @@ TEST_CASE("Parse with std::counted_iterator and std::default_sentinel_t")
    const std::counted_iterator<iterator_type> first2(json_str.begin(), len);
    CHECK(json::accept(first2, std::default_sentinel));
 }
 TEST_CASE("std::counted_iterator reaches the contiguous fast paths")
 {
    // A sized sentinel makes the remaining element count computable in O(1), so
    // std::counted_iterator over a contiguous iterator must reach the same bulk
    // string/number scanners as a plain pointer - not just the byte-at-a-time
    // fallback (see #5268 for the equivalent memcpy fast path).
 #if JSON_HAS_RANGES
    // JSON_HAS_RANGES is 0 on standard libraries with an incomplete <ranges>
    // (libstdc++ < 11, libc++ < 16), where the adapter deliberately falls back
    // to the byte-at-a-time scanner; everything below still has to work there.
    using adapter_type = nlohmann::detail::iterator_input_adapter<std::counted_iterator<const char*>, std::default_sentinel_t>;
    CHECK(adapter_type::supports_bulk_scan);
    CHECK(adapter_type::supports_seek);
 #endif
    // exercise every fast path: long ASCII run, multibyte UTF-8, escapes, and
    // integer/floating-point numbers
    const std::string json_str =
        R"({"ascii":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",)"
        "\"utf8\":\"\xe4\xb8\xad\xe6\x96\x87\xf0\x9f\x98\x80\xc3\xa9\","
        R"("escaped":"aéb\n\\","ints":[0,-1,18446744073709551615,-9223372036854775808],)"
        R"("floats":[1.5,-2.25e3,0.30000000000000004]})";
    const auto len = static_cast<std::iter_difference_t<const char*>>(json_str.size());
    const std::counted_iterator<const char*> first(json_str.data(), len);
    const json j = json::parse(first, std::default_sentinel);
    // parsing through the pointer adapter must give exactly the same result
    CHECK(j == json::parse(json_str));
 #if !defined(JSON_NOEXCEPTION)
    // Diagnostics that quote the offending token are reconstructed from the
    // already-consumed input (supports_seek), a path a sized sentinel only
    // reaches now; check a few that include the "last read" text. Parsing
    // invalid input aborts when exceptions are off, hence the guard.
    // Raw strings and explicit bytes: an escaped literal and two literals
    // written next to each other both read as mistakes to static analysis.
    const auto byte = [](int value)
    {
        return std::string(1, static_cast<char>(value));
    };
    const std::vector<std::string> diagnostic_docs =
    {
        "1\nx",
        "truX",
        "[tru]",
        R"("abc)",
        R"(["\ud834"])",
        R"(["a)" + byte(0x01) + R"(b"])",
        R"([")" + byte(0xC3) + byte(0x28) + R"("])",
        "[1e]",
        R"(["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaX)"
    };
    for (const auto& text : diagnostic_docs)
    {
        CAPTURE(text);
        const std::counted_iterator<const char*> it(text.data(), static_cast<std::iter_difference_t<const char*>>(text.size()));
        std::string counted_message;
        std::string string_message;
        try
        {
            const json counted_result = json::parse(it, std::default_sentinel);
            static_cast<void>(counted_result);
        }
        catch (const json::parse_error& e)
        {
            counted_message = e.what();
        }
        try
        {
            const json string_result = json::parse(text);
            static_cast<void>(string_result);
        }
        catch (const json::parse_error& e)
        {
            string_message = e.what();
        }
        CHECK_FALSE(counted_message.empty());
        CHECK(counted_message == string_message);
    }
    // and errors must still be reported identically
    const std::string bad = "[01\n]";
    const std::counted_iterator<const char*> bad_first(bad.data(), static_cast<std::iter_difference_t<const char*>>(bad.size()));
    std::string counted_what;
    std::string string_what;
    try
    {
        const json counted_result = json::parse(bad_first, std::default_sentinel);
        static_cast<void>(counted_result);
    }
    catch (const json::parse_error& e)
    {
        counted_what = e.what();
    }
    try
    {
        const json string_result = json::parse(bad);
        static_cast<void>(string_result);
    }
    catch (const json::parse_error& e)
    {
        string_what = e.what();
    }
    CHECK_FALSE(counted_what.empty());
    CHECK(counted_what == string_what);
 #endif
 }
 #if !defined(JSON_NOEXCEPTION)
 // several cases below are truncated on purpose, and parsing invalid input
 // aborts when exceptions are off
 TEST_CASE("std::counted_iterator bulk scanning stops at the counted end")
 {
    // The count, not the size of the underlying buffer, is the end of the
    // input: the bulk scanners must never look at the bytes behind it, even
    // though they are readable. Each case is compared against parsing the
    // equivalent prefix as a std::string.
    const auto via_counted = [](const std::string & buf, std::size_t n) -> std::string
    {
        const std::counted_iterator<const char*> first(buf.data(), static_cast<std::iter_difference_t<const char*>>(n));
        try
        {
            const json j = json::parse(first, std::default_sentinel);
            return "OK|" + j.dump();
        }
        catch (const json::parse_error& e)
        {
            return {e.what()};
        }
    };
    const auto via_prefix = [](const std::string & buf, std::size_t n) -> std::string
    {
        try
        {
            const json j = json::parse(buf.substr(0, n));
            return "OK|" + j.dump();
        }
        catch (const json::parse_error& e)
        {
            return {e.what()};
        }
    };
    struct testcase // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
    {
        const char* buffer;
        std::size_t count;
    };
    const std::vector<testcase> cases =
    {
        {"[\"abc\"]____TRAILING____", 7},                    // exact fit, tail hidden
        {"[\"abcdefghijklmnop\"]____", 8},                   // cut inside a string
        {"[\"abc\"]____", 6},                                // cut just before the closing quote
        {"[12345]xxxxx", 4},                                 // cut inside a number
        {"[123]999999", 5},                                  // number ends exactly at the count
        {"[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"]", 12},        // closing quote only behind the count
        {"[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"]", 19},      // cut inside an 8-byte SWAR stride
        {"[\"\xe4\xb8\xad\xe6\x96\x87\"]", 5},               // cut inside a UTF-8 sequence
        {"[\"\xe4\xb8\xad\xe6\x96\x87\"]____", 10},          // complete UTF-8, tail hidden
        {"[1.25e3]TRAILINGDIGITS999", 7},                    // number token reaches the count
    };
    for (const auto& tc : cases)
    {
        CAPTURE(tc.buffer);
        CAPTURE(tc.count);
        const std::string buffer = tc.buffer;
        CHECK(via_counted(buffer, tc.count) == via_prefix(buffer, tc.count));
    }
 }
 #endif
 #endif
 } // namespace
Author	SHA1	Message	Date
Niels Lohmann	aad5fa9a29	Address review findings on the binary writer output sinks - binary_reserve_hint(): the 4-bytes-per-element estimate over-reserved by up to 4x for arrays of small scalars (CBOR encodes 0..23 in one byte), and the returned vector kept that capacity. Make the hint a strict lower bound on the encoded size instead, which also removes the 1 MiB clamp whose branch no test could reach (the largest container in the suite has 65793 elements). - Guard the -Wduplicated-branches pragma with __GNUC__ >= 7. The warning does not exist before GCC 7, so naming it made GCC 4.8/4.9/5/6 - which the CI matrix still builds - warn under -Wpragmas on every including translation unit, breaking downstream -Werror builds. - Constrain the adapter constructor of binary_writer with the enable_if its documentation already claimed, so a writer over some other sink type is no longer advertised as constructible from an output adapter. - Let output_vector_adapter wrap output_vector_sink rather than duplicating the append logic, so the type-erased and templated paths share one implementation. - Collapse the three copies of the memcpy/byte_swap/memcpy dance into a single byte_swap_buffer() helper, and add the MSVC _byteswap_* intrinsics so MSVC no longer falls back to the scalar shuffle this change exists to eliminate. - Add a vector_writer() helper for the five vector-returning to_* overloads instead of spelling out the writer type at each call site, and drop a dead default member initializer on output_adapter_sink. - New tests: the vector sink and the adapter sink must produce identical bytes for every format (the two to_* overloads no longer delegate to each other and could otherwise drift), and binary_reserve_hint() must never exceed the size actually written. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-31 23:24:37 +00:00
Niels LohmannandClaude Opus 4.8	1d51b00830	Reserve output capacity up front for binary serialization The vector-returning to_cbor/to_msgpack/to_ubjson/to_bjdata/to_bson grew the output buffer purely by geometric reallocation. Reserving an estimate up front avoids the early reallocations, which is the dominant per-byte cost for array/object-heavy output. The estimate (binary_reserve_hint) is deliberately conservative and safe against untrusted input: it consults only the top-level element count (O(1), no walk of the DOM), guards the multiplication against overflow, and clamps the result to a fixed 1 MiB ceiling, so a large or hostile DOM can never force an oversized allocation here. The buffer still grows geometrically past the hint, so an underestimate only costs a few later reallocations; scalars/strings/binary are written in one shot and get no hint. Reserving capacity does not change the bytes produced. Throughput (g++/clang -O3, vs the previous commit): cbor int array +10% / +13% cbor object array +20% / +38% Output is byte-for-byte identical to develop across the binary differential corpus. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XAYM1qhSA2FDaDcGfPW3fG Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-31 23:21:45 +00:00
Niels LohmannandClaude Opus 4.8	09e5e85ba5	Encode big-endian numbers with a byte swap instead of std::reverse write_number() reordered multi-byte numbers for the big-endian formats (CBOR/MessagePack/UBJSON) with std::reverse over the byte array. GCC lowered only some sizes to a bswap; clang kept a scalar byte shuffle (0 bswap instructions in the CBOR number path). Replace the reverse with size-dispatched __builtin_bswap16/32/64 helpers (portable shift fallback for other compilers; std::reverse retained for exotic sizes such as a long double number_float_t). Codegen: the CBOR number path now emits bswap on both compilers (gcc 2 -> 16, clang 0 -> 4). Output is byte-for-byte identical to the previous implementation across the binary differential corpus. Throughput (isolated vs the std::reverse version, best of 9): CBOR int64 array gcc +7% clang +10% CBOR uint16 array gcc +27% clang flat Modest but consistent on number-dense encodings; negligible on string/blob-heavy output, as expected. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XAYM1qhSA2FDaDcGfPW3fG Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-31 23:21:37 +00:00
Niels LohmannandClaude Opus 4.8	5675ef167f	Fix CI failures from binary_writer output-sink change Four CI jobs failed on the initial commit; all are addressed here without changing any output (binary encodings remain byte-for-byte identical to develop across the differential corpus): 1. ci_test_gcc / cuda (-Werror=duplicated-branches): for number_float_t == float, static_cast<float>(n) is the identity, so write_compact_float's two branches are intentionally identical. Once the concrete vector sink is inlined, GCC constant-folds and diagnoses this (the type-erased path hid it behind a non-inlined virtual call). Silence -Wduplicated-branches for GCC (clang has no such warning) alongside the existing -Wfloat-equal pragma. 2. ci_static_analysis_clang (UBSan nonnull-attribute): binary_writer passes a null pointer with length 0 for empty strings/binary. output_vector_sink / output_adapter_sink declared write_characters JSON_HEDLEY_NON_NULL, so the sanitizer flagged the (harmless) zero-length call once the sink was called directly rather than through the attribute-free virtual base. Drop the attribute from both sinks, matching the pre-existing behavior. 3. ci_cpplint (build/include_what_you_use): output_adapter_sink uses std::move; add #include <utility>. 4. ci_cuda_example (nvcc 11.8): NVCC's front end rejects the default template argument on the binary_writer alias template. Revert the alias to its original single-parameter form (relying on binary_writer's own defaulted OutputSinkType) and spell out the full type in the vector-sink convenience functions. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XAYM1qhSA2FDaDcGfPW3fG Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-31 23:21:36 +00:00
Niels LohmannandClaude Opus 4.8	1883bdb34d	Devirtualize binary_writer via a value-type output sink to_cbor/to_msgpack/to_ubjson/to_bjdata/to_bson wrote every byte through output_adapter_t, a shared_ptr<output_adapter_protocol> whose write_character/write_characters are virtual. Unlike the lexer (templated on a concrete InputAdapterType), the binary writer never got that treatment, so binary output paid a vtable lookup per byte and a make_shared per call. Template binary_writer on an OutputSinkType and give it two concrete, non-virtual sinks: - output_vector_sink: appends straight into a std::vector (push_back / insert), used by the vector-returning to_* convenience functions. No vtable, no shared_ptr; the writes inline. - output_adapter_sink: forwards to a type-erased output_adapter_t, so the existing to_*(j, output_adapter) overloads (streams, strings, custom adapters) keep working exactly as before -- one virtual call each, unchanged. binary_writer keeps a convenience constructor taking output_adapter_t (building the default output_adapter_sink), so the adapter overloads are untouched; only the convenience functions switch to the vector sink. The friend declaration and the basic_json binary_writer alias gain the new (defaulted) template parameter. Output is byte-for-byte identical: verified across ~3000 randomized values plus curated edge cases (all scalar widths, strings with invalid UTF-8, binary, nested arrays/objects) for CBOR, MessagePack, UBJSON (both size/type settings), BJData, and BSON, plus the output_adapter path, in C++11/17/20. Warning-clean under clang -Weverything and the gcc pedantic set; clang-tidy clean on the changed headers; make check-amalgamation clean. Throughput (g++ -O3, vs develop): scalar-dense binary output such as integer arrays ~1.4x; many small to_cbor calls ~1.04x (DOM traversal bound); string/blob-heavy output unchanged (already bulk-bound). No workload regressed. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XAYM1qhSA2FDaDcGfPW3fG Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-31 23:21:36 +00:00