Time copies together with their destruction in the benchmarks

Copy timed only the copy and destroyed it with the timer paused, and
Destroy did the reverse. How a document is freed shapes the heap the next
copy allocates from: since the faster destruction (#5762/#5767), part of
its saved work shows up in the next copy's allocations. Copy therefore
looked up to 40% slower than 3.12.0 on glibc although copying and
destroying together got 1.1-1.5x faster.

Copy now times a temporary copy including its destruction. CopyAssign
assigns over an earlier copy, and CopyRing replaces the oldest of eight
live copies. The old benchmarks remain as CopyOnly and DestroyOnly, with
a note that they tell the halves apart but do not compare versions.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

include/nlohmann/detail/output/binary_writer.hpp

@@ -23,7 +23,6 @@
     #include <cstdlib> // _byteswap_ushort, _byteswap_ulong, _byteswap_uint64
 #endif
 
-#include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/input/binary_reader.hpp>
 #include <nlohmann/detail/input/string_scan.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
@@ -205,12 +204,24 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers
+                    write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    // a negative integer n is encoded as -1 - n
+                    write_cbor_head(0x20, static_cast<std::uint64_t>(-1 - j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_cbor_integer(j);
+                write_cbor_head(0x00, conditional_static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -245,7 +256,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_cbor_array(j, depth);
+                // step 1: write control byte and the array size
+                write_cbor_head(0x80, j.m_data.m_value.array->size());
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el, depth + 1);
+                }
                 break;
             }
 
@@ -403,12 +420,54 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers.
+                    write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa.write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa.write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa.write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        // int 64
+                        oa.write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_msgpack_integer(j, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
+                write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -426,7 +485,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_msgpack_array(j, depth);
+                // step 1: write control byte and the array size
+                write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el, depth + 1);
+                }
                 break;
             }
 
@@ -1886,316 +1951,6 @@ class binary_writer
         }
     }
 
-    /*!
-    @brief size class of an unsigned integer from its bit length
-
-    1, 2, 3, or 4 if @a x fits 1, 2, 4, or 8 bytes. Looked up from the number
-    of leading zero bits instead of found by branches: the sizes of a stream
-    of numbers are hard to predict, and a mispredicted branch costs more than
-    writing the number. (A table, as comparisons are vectorized by clang into
-    slower code.)
-    */
-    static unsigned integer_size_class(const std::uint64_t x) noexcept
-    {
-        static constexpr std::array<std::uint8_t, 64> size_class_by_leading_zeros =
-        {
-            {
-                4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-                3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-                2, 2, 2, 2, 2, 2, 2, 2,
-                1, 1, 1, 1, 1, 1, 1, 1
-            }
-        };
-        // x | 1 keeps count_leading_zeros() away from 0
-        return size_class_by_leading_zeros[static_cast<std::size_t>(count_leading_zeros(x | 1u))];
-    }
-
-    /*!
-    @brief encode @a first_byte and the low-order bytes of @a value that
-           @a size_class calls for (none, or 1, 2, 4, or 8) in network order
-           to @a out
-    @return the number of characters of the encoding; up to
-            @ref integer_encoding_space characters at @a out are overwritten
-
-    The bytes are written as one byte and one 8-byte word whose bytes after
-    the value are scratch that the caller drops, so that writing them does not
-    depend on the size class. For class 0 the word is all scratch; it is
-    shifted by 60 bits rather than 64, which would be undefined.
-    */
-    std::size_t encode_first_byte_and_tail(CharType* out, const std::uint8_t first_byte, const unsigned size_class, const std::uint64_t value) const noexcept
-    {
-        out[0] = to_char_type(first_byte);
-        const unsigned unused_bits = 64u - ((8u << size_class) >> 1u);
-        const std::uint64_t tail = is_little_endian ? byte_swap(value) >> unused_bits : value << unused_bits;
-        std::memcpy(out + 1, &tail, sizeof(tail));
-        return ((std::size_t{1} << size_class) >> 1u) + 1;
-    }
-
-    /// characters encode_first_byte_and_tail() may overwrite: the first byte
-    /// and one 8-byte word
-    static constexpr std::size_t integer_encoding_space = 9;
-
-    /*!
-    @brief the 64 bits of a number_integer or number_unsigned value, and a mask
-           that is all ones if it is negative, else zero
-
-    Selected through masks rather than branches, as the type and the sign of
-    the values in an array of mixed signs alternate unpredictably (non-negative
-    integers are number_unsigned after parsing). Up to 64 bits, the sign is bit
-    63 of the result (a narrower integer is sign-extended); computing it with
-    masks keeps GCC from branching on the type. A wider integer has to be
-    compared.
-    */
-    static std::uint64_t integer_bits(const BasicJsonType& j, std::uint64_t& sign_mask) noexcept
-    {
-        const bool is_signed = j.m_data.m_type == value_t::number_integer;
-        const std::uint64_t raw = is_signed
-                                  ? static_cast<std::uint64_t>(j.m_data.m_value.number_integer)
-                                  : static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned);
-        sign_mask = sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-                    ? (std::uint64_t{0} - static_cast<std::uint64_t>(is_signed)) & (std::uint64_t{0} - (raw >> 63u))
-                    : std::uint64_t{0} - static_cast<std::uint64_t>(is_signed && j.m_data.m_value.number_integer < 0);
-        return raw;
-    }
-
-    /*!
-    @brief encode the head of a CBOR integer to @a out without branching on its
-           size
-    @return the number of characters of the head
-
-    Same output as @ref write_cbor_head. The lengths of strings and containers
-    are mostly predictable, so their heads keep the branches; the sizes of a
-    run of integers are not, so an integer's head is assembled without them.
-    */
-    std::size_t encode_cbor_integer_head(CharType* out, const std::uint8_t major_type, const std::uint64_t argument) const noexcept
-    {
-        // an argument of at most 23 is in size class 1 (one byte) and is moved
-        // to class 0, the first byte, by subtracting 1
-        const auto is_immediate = static_cast<unsigned>(argument <= 0x17u);
-        const unsigned size_class = integer_size_class(argument) - is_immediate;
-
-        // the first byte: the argument itself if it is immediate, else
-        // 0x17 + size_class, selected through a mask
-        const std::uint64_t immediate_mask = std::uint64_t{0} - is_immediate;
-        const auto first_byte = static_cast<std::uint8_t>(major_type + ((argument & immediate_mask) | ((0x17u + size_class) & ~immediate_mask)));
-        return encode_first_byte_and_tail(out, first_byte, size_class, argument);
-    }
-
-    /*!
-    @brief write an array value (head and elements) as CBOR
-
-    Integer elements, the most common scalar, are written without a call to
-    @ref write_cbor. The loop is kept out of line: inlined into write_cbor, its
-    registers would be saved and restored on every call of write_cbor, which
-    is one call per value nested in an object.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_cbor_head(0x80, j.m_data.m_value.array->size());
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_cbor_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_cbor(el, depth + 1);
-        });
-    }
-
-    /*!
-    @brief write the elements of the array @a j, runs of integers with
-           @a encode_integer and all other values with @a write_value
-
-    Runs of integers are encoded straight into space reserved from the sink
-    for a whole run: the write pointer stays a local, where it would otherwise
-    be reloaded from the sink for every value, as a store of a character may
-    alias it.
-    */
-    template<typename EncodeInteger, typename WriteValue>
-    void write_array_elements(const BasicJsonType& j, EncodeInteger encode_integer, WriteValue write_value)
-    {
-        constexpr std::size_t max_run = max_reserve_size / integer_encoding_space;
-        auto it = j.m_data.m_value.array->begin();
-        const auto end = j.m_data.m_value.array->end();
-        while (it != end)
-        {
-            if (it->is_number_integer())
-            {
-                CharType* const start = oa.reserve(max_run * integer_encoding_space);
-                CharType* out = start;
-                for (std::size_t n = 0; n < max_run && it != end && it->is_number_integer(); ++n, ++it)
-                {
-                    out += encode_integer(out, *it);
-                }
-                oa.commit(static_cast<std::size_t>(out - start));
-            }
-            else
-            {
-                write_value(*it);
-                ++it;
-            }
-        }
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a CBOR integer
-
-    A negative integer n has major type 1 and the argument -1 - n, which is ~n.
-    Kept out of line, like the other per-value paths, so that write_cbor stays
-    small (runs of integers in an array are encoded inline instead).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_integer(const BasicJsonType& j)
-    {
-        oa.commit(encode_cbor_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_cbor_integer) and return the number of characters
-    std::size_t encode_cbor_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-        // ~raw is -1 - n in the 64 bits that are written
-        return encode_cbor_integer_head(out, static_cast<std::uint8_t>(sign_mask & 0x20u), raw ^ sign_mask);
-    }
-
-    /*!
-    @brief whether the MessagePack integers of BasicJsonType are written by
-           @ref encode_msgpack_integer
-
-    It picks the format from the low 64 bits; a wider number type keeps the
-    range checks of @ref write_msgpack on the whole value.
-    */
-    static constexpr bool msgpack_integers_fit_64_bits() noexcept
-    {
-        return sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-               && sizeof(typename BasicJsonType::number_unsigned_t) <= sizeof(std::uint64_t);
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a MessagePack
-           integer without branching on its sign or size
-
-    Same output as @ref write_msgpack: a non-negative integer as positive fixint
-    (< 128) or uint 8/16/32/64, a negative one as negative fixint (>= -32) or
-    int 8/16/32/64. Kept out of line (see @ref write_cbor_integer).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_integer(const BasicJsonType& j, std::true_type /*fits_64_bits*/)
-    {
-        oa.commit(encode_msgpack_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_msgpack_integer) and return the number of characters
-    std::size_t encode_msgpack_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-
-        // A negative n fits int 8/16/32 exactly if 2 * (-1 - n) + 1 fits
-        // uint 8/16/32, so x gives the size class of either sign.
-        const std::uint64_t is_negative = sign_mask & 1u;
-        const std::uint64_t x = ((raw ^ sign_mask) << is_negative) | is_negative;
-
-        // A fixint is at most 127, or at least -32 (x at most 63). It is in
-        // size class 1 and is moved to class 0, the first byte, by subtracting 1.
-        const auto is_fixint = static_cast<unsigned>(x <= (127u ^ (sign_mask & 64u)));
-        const unsigned size_class = integer_size_class(x) - is_fixint;
-
-        // the first byte: the low byte of the integer for a fixint, else the
-        // marker 0xCC..0xCF (uint) or 0xD0..0xD3 (int), selected through a mask
-        const std::uint64_t fixint_mask = std::uint64_t{0} - is_fixint;
-        const std::uint64_t marker = 0xCBu + size_class + (sign_mask & 4u);
-        const auto first_byte = static_cast<std::uint8_t>((raw & fixint_mask) | (marker & ~fixint_mask));
-        return encode_first_byte_and_tail(out, first_byte, size_class, raw);
-    }
-
-    /// write a number_integer or number_unsigned value of a number type wider
-    /// than 64 bits as a MessagePack integer, with range checks on the whole value
-    void write_msgpack_integer(const BasicJsonType& j, std::false_type /*fits_64_bits*/)
-    {
-        if (j.m_data.m_type == value_t::number_unsigned)
-        {
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
-            return;
-        }
-
-        if (j.m_data.m_value.number_integer >= 0)
-        {
-            // MessagePack does not differentiate between positive
-            // signed integers and unsigned integers.
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
-        }
-        else
-        {
-            if (j.m_data.m_value.number_integer >= -32)
-            {
-                // negative fixnum
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
-            {
-                // int 8
-                oa.write_character(to_char_type(0xD0));
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
-            {
-                // int 16
-                oa.write_character(to_char_type(0xD1));
-                write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
-            {
-                // int 32
-                oa.write_character(to_char_type(0xD2));
-                write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
-            }
-            else
-            {
-                // int 64
-                oa.write_character(to_char_type(0xD3));
-                write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
-            }
-        }
-    }
-
-    /*!
-    @brief write an array value (head and elements) as MessagePack
-
-    See @ref write_cbor_array.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
-        write_msgpack_array_elements(j, depth, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::true_type /*fits_64_bits*/)
-    {
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_msgpack_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_msgpack(el, depth + 1);
-        });
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::false_type /*fits_64_bits*/)
-    {
-        for (const auto& el : *j.m_data.m_value.array)
-        {
-            write_msgpack(el, depth + 1);
-        }
-    }
-
     /*!
     @brief write an object key as a CBOR text string
 

include/nlohmann/detail/output/output_adapters.hpp

@@ -8,10 +8,7 @@
 
 #pragma once
 
-#include <algorithm> // max
-#include <array> // array
 #include <cstddef> // size_t
-#include <cstring> // memcpy
 #include <memory> // shared_ptr, make_shared
 #include <string> // basic_string
 #include <type_traits> // conditional, integral_constant, is_same
@@ -51,170 +48,32 @@ template<typename CharType> struct output_adapter_protocol
 template<typename CharType>
 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
 
-/// the largest number of characters a writer may reserve() from a sink at once;
-/// output_vector_sink also appends writes of at least this size with insert()
-constexpr std::size_t max_reserve_size = 256;
-
 /// @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.
-///
-/// Most writes are a few bytes - a type marker, or a number of 1, 2, 4, or 8
-/// bytes - and appending those with push_back() or insert() cost more than
-/// encoding them: insert() is an out-of-line call into a routine that can insert
-/// anywhere, and resize() is one as well with libstdc++. The sink therefore keeps
-/// its own write position: it grows the vector geometrically ahead of the
-/// position and copies each write to it, so a write is a capacity check and a
-/// short copy. The destructor shrinks the vector to the bytes actually written,
-/// also when a write throws; shrinking a vector never allocates. The sink owns
-/// that trim, so it can be moved but not copied, and the vector must not be used
-/// while the sink is alive.
+/// `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_sink
 {
   public:
     explicit output_vector_sink(std::vector<CharType, AllocatorType>& vec) noexcept
-        : v(&vec), position(vec.size())
-    {}
-
-    output_vector_sink(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(output_vector_sink&&) = delete;
-
-    output_vector_sink(output_vector_sink&& other) noexcept
-        : v(other.v), position(other.position)
-    {
-        other.v = nullptr;
-    }
-
-    ~output_vector_sink()
-    {
-        if (v != nullptr)
-        {
-            v->resize(position);
-        }
-    }
-
-    // always inlined: GCC otherwise keeps these out of line in a large
-    // translation unit, and a call per byte or number costs more than the write
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_character(CharType c)
-    {
-        if (JSON_HEDLEY_UNLIKELY(position == v->size()))
-        {
-            grow(1);
-        }
-        (*v)[position++] = c;
-    }
-
-    // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; memcpy must not
-    // see it.
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_characters(const CharType* s, std::size_t length)
-    {
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            if (length >= max_reserve_size)
-            {
-                append(s, length);
-                return;
-            }
-            grow(length);
-        }
-        if (length != 0)
-        {
-            std::memcpy(v->data() + position, s, length * sizeof(CharType));
-            position += length;
-        }
-    }
-
-    /// @brief space for writing up to @a length characters directly
-    ///
-    /// Returns a pointer to at least @a length (at most @ref max_reserve_size)
-    /// writable characters at the write position; @ref commit then keeps the
-    /// first ones of them. A writer can store whole words there and keep only
-    /// the bytes it needs, and keep its write pointer in a register across many
-    /// values instead of updating the sink after each.
-    JSON_HEDLEY_ALWAYS_INLINE
-    CharType* reserve(const std::size_t length)
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            grow(length);
-        }
-        return v->data() + position;
-    }
-
-    /// keep the first @a length characters written to the space from reserve()
-    JSON_HEDLEY_ALWAYS_INLINE
-    void commit(const std::size_t length) noexcept
-    {
-        position += length;
-    }
-
-  private:
-    /// make room for at least @a length more characters after the position;
-    /// kept out of line so that the write functions stay small enough for
-    /// GCC to inline them into the writer
-    JSON_HEDLEY_NEVER_INLINE
-    void grow(const std::size_t length)
-    {
-        // use the capacity the vector already has, else at least double it;
-        // never less than 64 characters, so that a small value does not
-        // reallocate for every few bytes
-        const std::size_t needed = position + length;
-        v->resize((std::max)(std::size_t{64}, needed <= v->capacity()
-                             ? v->capacity()
-                             : (std::max)(needed, v->capacity() * 2)));
-    }
-
-    /// append @a length (at least max_reserve_size) characters that do not fit
-    /// the space ahead of the position: insert() copies them once into the
-    /// grown vector, where grow() would first zero the new space and then copy
-    /// over it - noticeable for a large string or binary value
-    JSON_HEDLEY_NEVER_INLINE
-    void append(const CharType* s, const std::size_t length)
-    {
-        v->resize(position);
-        if (v->capacity() - position < length)
-        {
-            // grow geometrically, with room for the writes that follow, so
-            // that the next grow() need not reallocate right away
-            v->reserve((std::max)(v->capacity() * 2, position + length + max_reserve_size));
-        }
-        v->insert(v->end(), s, s + length);
-        position = v->size();
-    }
-
-    std::vector<CharType, AllocatorType>* v;
-    /// number of characters of *v written so far
-    std::size_t position;
-};
-
-/// output adapter for byte vectors
-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
         : v(vec)
     {}
 
-    void write_character(CharType c) override
+    void write_character(CharType c)
     {
         v.push_back(c);
     }
 
     // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; appending an empty
-    // range is a no-op
-    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);
     }
@@ -223,6 +82,33 @@ 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);
+    }
+
+    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>
@@ -302,24 +188,8 @@ class output_adapter_sink
         oa->write_characters(s, length);
     }
 
-    /// space for writing up to @a length characters (see
-    /// output_vector_sink::reserve)
-    CharType* reserve(const std::size_t length) noexcept
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        static_cast<void>(length);
-        return reserved.data();
-    }
-
-    /// write the first @a length characters written to the space from reserve()
-    void commit(const std::size_t length)
-    {
-        oa->write_characters(reserved.data(), length);
-    }
-
   private:
     output_adapter_t<CharType> oa;
-    std::array<CharType, max_reserve_size> reserved{};
 };
 
 /// @brief whether std::basic_string<CharType> has a non-deprecated std::char_traits

single_include/nlohmann/json.hpp

@@ -22634,8 +22634,6 @@ NLOHMANN_JSON_NAMESPACE_END
     #include <cstdlib> // _byteswap_ushort, _byteswap_ulong, _byteswap_uint64
 #endif
 
-// #include <nlohmann/detail/bit_ops.hpp>
-
 // #include <nlohmann/detail/input/binary_reader.hpp>
 
 // #include <nlohmann/detail/input/string_scan.hpp>
@@ -22655,10 +22653,7 @@ NLOHMANN_JSON_NAMESPACE_END
 
 
 
-#include <algorithm> // max
-#include <array> // array
 #include <cstddef> // size_t
-#include <cstring> // memcpy
 #include <memory> // shared_ptr, make_shared
 #include <string> // basic_string
 #include <type_traits> // conditional, integral_constant, is_same
@@ -22699,170 +22694,32 @@ template<typename CharType> struct output_adapter_protocol
 template<typename CharType>
 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
 
-/// the largest number of characters a writer may reserve() from a sink at once;
-/// output_vector_sink also appends writes of at least this size with insert()
-constexpr std::size_t max_reserve_size = 256;
-
 /// @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.
-///
-/// Most writes are a few bytes - a type marker, or a number of 1, 2, 4, or 8
-/// bytes - and appending those with push_back() or insert() cost more than
-/// encoding them: insert() is an out-of-line call into a routine that can insert
-/// anywhere, and resize() is one as well with libstdc++. The sink therefore keeps
-/// its own write position: it grows the vector geometrically ahead of the
-/// position and copies each write to it, so a write is a capacity check and a
-/// short copy. The destructor shrinks the vector to the bytes actually written,
-/// also when a write throws; shrinking a vector never allocates. The sink owns
-/// that trim, so it can be moved but not copied, and the vector must not be used
-/// while the sink is alive.
+/// `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_sink
 {
   public:
     explicit output_vector_sink(std::vector<CharType, AllocatorType>& vec) noexcept
-        : v(&vec), position(vec.size())
-    {}
-
-    output_vector_sink(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(const output_vector_sink&) = delete;
-    output_vector_sink& operator=(output_vector_sink&&) = delete;
-
-    output_vector_sink(output_vector_sink&& other) noexcept
-        : v(other.v), position(other.position)
-    {
-        other.v = nullptr;
-    }
-
-    ~output_vector_sink()
-    {
-        if (v != nullptr)
-        {
-            v->resize(position);
-        }
-    }
-
-    // always inlined: GCC otherwise keeps these out of line in a large
-    // translation unit, and a call per byte or number costs more than the write
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_character(CharType c)
-    {
-        if (JSON_HEDLEY_UNLIKELY(position == v->size()))
-        {
-            grow(1);
-        }
-        (*v)[position++] = c;
-    }
-
-    // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; memcpy must not
-    // see it.
-    JSON_HEDLEY_ALWAYS_INLINE
-    void write_characters(const CharType* s, std::size_t length)
-    {
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            if (length >= max_reserve_size)
-            {
-                append(s, length);
-                return;
-            }
-            grow(length);
-        }
-        if (length != 0)
-        {
-            std::memcpy(v->data() + position, s, length * sizeof(CharType));
-            position += length;
-        }
-    }
-
-    /// @brief space for writing up to @a length characters directly
-    ///
-    /// Returns a pointer to at least @a length (at most @ref max_reserve_size)
-    /// writable characters at the write position; @ref commit then keeps the
-    /// first ones of them. A writer can store whole words there and keep only
-    /// the bytes it needs, and keep its write pointer in a register across many
-    /// values instead of updating the sink after each.
-    JSON_HEDLEY_ALWAYS_INLINE
-    CharType* reserve(const std::size_t length)
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        if (JSON_HEDLEY_UNLIKELY(v->size() - position < length))
-        {
-            grow(length);
-        }
-        return v->data() + position;
-    }
-
-    /// keep the first @a length characters written to the space from reserve()
-    JSON_HEDLEY_ALWAYS_INLINE
-    void commit(const std::size_t length) noexcept
-    {
-        position += length;
-    }
-
-  private:
-    /// make room for at least @a length more characters after the position;
-    /// kept out of line so that the write functions stay small enough for
-    /// GCC to inline them into the writer
-    JSON_HEDLEY_NEVER_INLINE
-    void grow(const std::size_t length)
-    {
-        // use the capacity the vector already has, else at least double it;
-        // never less than 64 characters, so that a small value does not
-        // reallocate for every few bytes
-        const std::size_t needed = position + length;
-        v->resize((std::max)(std::size_t{64}, needed <= v->capacity()
-                             ? v->capacity()
-                             : (std::max)(needed, v->capacity() * 2)));
-    }
-
-    /// append @a length (at least max_reserve_size) characters that do not fit
-    /// the space ahead of the position: insert() copies them once into the
-    /// grown vector, where grow() would first zero the new space and then copy
-    /// over it - noticeable for a large string or binary value
-    JSON_HEDLEY_NEVER_INLINE
-    void append(const CharType* s, const std::size_t length)
-    {
-        v->resize(position);
-        if (v->capacity() - position < length)
-        {
-            // grow geometrically, with room for the writes that follow, so
-            // that the next grow() need not reallocate right away
-            v->reserve((std::max)(v->capacity() * 2, position + length + max_reserve_size));
-        }
-        v->insert(v->end(), s, s + length);
-        position = v->size();
-    }
-
-    std::vector<CharType, AllocatorType>* v;
-    /// number of characters of *v written so far
-    std::size_t position;
-};
-
-/// output adapter for byte vectors
-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
         : v(vec)
     {}
 
-    void write_character(CharType c) override
+    void write_character(CharType c)
     {
         v.push_back(c);
     }
 
     // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values; appending an empty
-    // range is a no-op
-    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);
     }
@@ -22871,6 +22728,33 @@ 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);
+    }
+
+    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>
@@ -22950,24 +22834,8 @@ class output_adapter_sink
         oa->write_characters(s, length);
     }
 
-    /// space for writing up to @a length characters (see
-    /// output_vector_sink::reserve)
-    CharType* reserve(const std::size_t length) noexcept
-    {
-        JSON_ASSERT(length <= max_reserve_size);
-        static_cast<void>(length);
-        return reserved.data();
-    }
-
-    /// write the first @a length characters written to the space from reserve()
-    void commit(const std::size_t length)
-    {
-        oa->write_characters(reserved.data(), length);
-    }
-
   private:
     output_adapter_t<CharType> oa;
-    std::array<CharType, max_reserve_size> reserved{};
 };
 
 /// @brief whether std::basic_string<CharType> has a non-deprecated std::char_traits
@@ -23252,12 +23120,24 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers
+                    write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    // a negative integer n is encoded as -1 - n
+                    write_cbor_head(0x20, static_cast<std::uint64_t>(-1 - j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_cbor_integer(j);
+                write_cbor_head(0x00, conditional_static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -23292,7 +23172,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_cbor_array(j, depth);
+                // step 1: write control byte and the array size
+                write_cbor_head(0x80, j.m_data.m_value.array->size());
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el, depth + 1);
+                }
                 break;
             }
 
@@ -23450,12 +23336,54 @@ class binary_writer
             }
 
             case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers.
+                    write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa.write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa.write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa.write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        // int 64
+                        oa.write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
             case value_t::number_unsigned:
             {
-                // one case for both, so that an array mixing negative
-                // (number_integer) and non-negative (number_unsigned) values
-                // does not mispredict the switch
-                write_msgpack_integer(j, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
+                write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
 
@@ -23473,7 +23401,13 @@ class binary_writer
 
             case value_t::array:
             {
-                write_msgpack_array(j, depth);
+                // step 1: write control byte and the array size
+                write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el, depth + 1);
+                }
                 break;
             }
 
@@ -24933,316 +24867,6 @@ class binary_writer
         }
     }
 
-    /*!
-    @brief size class of an unsigned integer from its bit length
-
-    1, 2, 3, or 4 if @a x fits 1, 2, 4, or 8 bytes. Looked up from the number
-    of leading zero bits instead of found by branches: the sizes of a stream
-    of numbers are hard to predict, and a mispredicted branch costs more than
-    writing the number. (A table, as comparisons are vectorized by clang into
-    slower code.)
-    */
-    static unsigned integer_size_class(const std::uint64_t x) noexcept
-    {
-        static constexpr std::array<std::uint8_t, 64> size_class_by_leading_zeros =
-        {
-            {
-                4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-                3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-                2, 2, 2, 2, 2, 2, 2, 2,
-                1, 1, 1, 1, 1, 1, 1, 1
-            }
-        };
-        // x | 1 keeps count_leading_zeros() away from 0
-        return size_class_by_leading_zeros[static_cast<std::size_t>(count_leading_zeros(x | 1u))];
-    }
-
-    /*!
-    @brief encode @a first_byte and the low-order bytes of @a value that
-           @a size_class calls for (none, or 1, 2, 4, or 8) in network order
-           to @a out
-    @return the number of characters of the encoding; up to
-            @ref integer_encoding_space characters at @a out are overwritten
-
-    The bytes are written as one byte and one 8-byte word whose bytes after
-    the value are scratch that the caller drops, so that writing them does not
-    depend on the size class. For class 0 the word is all scratch; it is
-    shifted by 60 bits rather than 64, which would be undefined.
-    */
-    std::size_t encode_first_byte_and_tail(CharType* out, const std::uint8_t first_byte, const unsigned size_class, const std::uint64_t value) const noexcept
-    {
-        out[0] = to_char_type(first_byte);
-        const unsigned unused_bits = 64u - ((8u << size_class) >> 1u);
-        const std::uint64_t tail = is_little_endian ? byte_swap(value) >> unused_bits : value << unused_bits;
-        std::memcpy(out + 1, &tail, sizeof(tail));
-        return ((std::size_t{1} << size_class) >> 1u) + 1;
-    }
-
-    /// characters encode_first_byte_and_tail() may overwrite: the first byte
-    /// and one 8-byte word
-    static constexpr std::size_t integer_encoding_space = 9;
-
-    /*!
-    @brief the 64 bits of a number_integer or number_unsigned value, and a mask
-           that is all ones if it is negative, else zero
-
-    Selected through masks rather than branches, as the type and the sign of
-    the values in an array of mixed signs alternate unpredictably (non-negative
-    integers are number_unsigned after parsing). Up to 64 bits, the sign is bit
-    63 of the result (a narrower integer is sign-extended); computing it with
-    masks keeps GCC from branching on the type. A wider integer has to be
-    compared.
-    */
-    static std::uint64_t integer_bits(const BasicJsonType& j, std::uint64_t& sign_mask) noexcept
-    {
-        const bool is_signed = j.m_data.m_type == value_t::number_integer;
-        const std::uint64_t raw = is_signed
-                                  ? static_cast<std::uint64_t>(j.m_data.m_value.number_integer)
-                                  : static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned);
-        sign_mask = sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-                    ? (std::uint64_t{0} - static_cast<std::uint64_t>(is_signed)) & (std::uint64_t{0} - (raw >> 63u))
-                    : std::uint64_t{0} - static_cast<std::uint64_t>(is_signed && j.m_data.m_value.number_integer < 0);
-        return raw;
-    }
-
-    /*!
-    @brief encode the head of a CBOR integer to @a out without branching on its
-           size
-    @return the number of characters of the head
-
-    Same output as @ref write_cbor_head. The lengths of strings and containers
-    are mostly predictable, so their heads keep the branches; the sizes of a
-    run of integers are not, so an integer's head is assembled without them.
-    */
-    std::size_t encode_cbor_integer_head(CharType* out, const std::uint8_t major_type, const std::uint64_t argument) const noexcept
-    {
-        // an argument of at most 23 is in size class 1 (one byte) and is moved
-        // to class 0, the first byte, by subtracting 1
-        const auto is_immediate = static_cast<unsigned>(argument <= 0x17u);
-        const unsigned size_class = integer_size_class(argument) - is_immediate;
-
-        // the first byte: the argument itself if it is immediate, else
-        // 0x17 + size_class, selected through a mask
-        const std::uint64_t immediate_mask = std::uint64_t{0} - is_immediate;
-        const auto first_byte = static_cast<std::uint8_t>(major_type + ((argument & immediate_mask) | ((0x17u + size_class) & ~immediate_mask)));
-        return encode_first_byte_and_tail(out, first_byte, size_class, argument);
-    }
-
-    /*!
-    @brief write an array value (head and elements) as CBOR
-
-    Integer elements, the most common scalar, are written without a call to
-    @ref write_cbor. The loop is kept out of line: inlined into write_cbor, its
-    registers would be saved and restored on every call of write_cbor, which
-    is one call per value nested in an object.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_cbor_head(0x80, j.m_data.m_value.array->size());
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_cbor_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_cbor(el, depth + 1);
-        });
-    }
-
-    /*!
-    @brief write the elements of the array @a j, runs of integers with
-           @a encode_integer and all other values with @a write_value
-
-    Runs of integers are encoded straight into space reserved from the sink
-    for a whole run: the write pointer stays a local, where it would otherwise
-    be reloaded from the sink for every value, as a store of a character may
-    alias it.
-    */
-    template<typename EncodeInteger, typename WriteValue>
-    void write_array_elements(const BasicJsonType& j, EncodeInteger encode_integer, WriteValue write_value)
-    {
-        constexpr std::size_t max_run = max_reserve_size / integer_encoding_space;
-        auto it = j.m_data.m_value.array->begin();
-        const auto end = j.m_data.m_value.array->end();
-        while (it != end)
-        {
-            if (it->is_number_integer())
-            {
-                CharType* const start = oa.reserve(max_run * integer_encoding_space);
-                CharType* out = start;
-                for (std::size_t n = 0; n < max_run && it != end && it->is_number_integer(); ++n, ++it)
-                {
-                    out += encode_integer(out, *it);
-                }
-                oa.commit(static_cast<std::size_t>(out - start));
-            }
-            else
-            {
-                write_value(*it);
-                ++it;
-            }
-        }
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a CBOR integer
-
-    A negative integer n has major type 1 and the argument -1 - n, which is ~n.
-    Kept out of line, like the other per-value paths, so that write_cbor stays
-    small (runs of integers in an array are encoded inline instead).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_cbor_integer(const BasicJsonType& j)
-    {
-        oa.commit(encode_cbor_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_cbor_integer) and return the number of characters
-    std::size_t encode_cbor_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-        // ~raw is -1 - n in the 64 bits that are written
-        return encode_cbor_integer_head(out, static_cast<std::uint8_t>(sign_mask & 0x20u), raw ^ sign_mask);
-    }
-
-    /*!
-    @brief whether the MessagePack integers of BasicJsonType are written by
-           @ref encode_msgpack_integer
-
-    It picks the format from the low 64 bits; a wider number type keeps the
-    range checks of @ref write_msgpack on the whole value.
-    */
-    static constexpr bool msgpack_integers_fit_64_bits() noexcept
-    {
-        return sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-               && sizeof(typename BasicJsonType::number_unsigned_t) <= sizeof(std::uint64_t);
-    }
-
-    /*!
-    @brief write a number_integer or number_unsigned value as a MessagePack
-           integer without branching on its sign or size
-
-    Same output as @ref write_msgpack: a non-negative integer as positive fixint
-    (< 128) or uint 8/16/32/64, a negative one as negative fixint (>= -32) or
-    int 8/16/32/64. Kept out of line (see @ref write_cbor_integer).
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_integer(const BasicJsonType& j, std::true_type /*fits_64_bits*/)
-    {
-        oa.commit(encode_msgpack_integer(oa.reserve(integer_encoding_space), j));
-    }
-
-    /// encode a number_integer or number_unsigned value to @a out (see
-    /// @ref write_msgpack_integer) and return the number of characters
-    std::size_t encode_msgpack_integer(CharType* out, const BasicJsonType& j) const noexcept
-    {
-        std::uint64_t sign_mask = 0;
-        const std::uint64_t raw = integer_bits(j, sign_mask);
-
-        // A negative n fits int 8/16/32 exactly if 2 * (-1 - n) + 1 fits
-        // uint 8/16/32, so x gives the size class of either sign.
-        const std::uint64_t is_negative = sign_mask & 1u;
-        const std::uint64_t x = ((raw ^ sign_mask) << is_negative) | is_negative;
-
-        // A fixint is at most 127, or at least -32 (x at most 63). It is in
-        // size class 1 and is moved to class 0, the first byte, by subtracting 1.
-        const auto is_fixint = static_cast<unsigned>(x <= (127u ^ (sign_mask & 64u)));
-        const unsigned size_class = integer_size_class(x) - is_fixint;
-
-        // the first byte: the low byte of the integer for a fixint, else the
-        // marker 0xCC..0xCF (uint) or 0xD0..0xD3 (int), selected through a mask
-        const std::uint64_t fixint_mask = std::uint64_t{0} - is_fixint;
-        const std::uint64_t marker = 0xCBu + size_class + (sign_mask & 4u);
-        const auto first_byte = static_cast<std::uint8_t>((raw & fixint_mask) | (marker & ~fixint_mask));
-        return encode_first_byte_and_tail(out, first_byte, size_class, raw);
-    }
-
-    /// write a number_integer or number_unsigned value of a number type wider
-    /// than 64 bits as a MessagePack integer, with range checks on the whole value
-    void write_msgpack_integer(const BasicJsonType& j, std::false_type /*fits_64_bits*/)
-    {
-        if (j.m_data.m_type == value_t::number_unsigned)
-        {
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
-            return;
-        }
-
-        if (j.m_data.m_value.number_integer >= 0)
-        {
-            // MessagePack does not differentiate between positive
-            // signed integers and unsigned integers.
-            write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
-        }
-        else
-        {
-            if (j.m_data.m_value.number_integer >= -32)
-            {
-                // negative fixnum
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
-            {
-                // int 8
-                oa.write_character(to_char_type(0xD0));
-                write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
-            {
-                // int 16
-                oa.write_character(to_char_type(0xD1));
-                write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
-            }
-            else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
-                     j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
-            {
-                // int 32
-                oa.write_character(to_char_type(0xD2));
-                write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
-            }
-            else
-            {
-                // int 64
-                oa.write_character(to_char_type(0xD3));
-                write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
-            }
-        }
-    }
-
-    /*!
-    @brief write an array value (head and elements) as MessagePack
-
-    See @ref write_cbor_array.
-    */
-    JSON_HEDLEY_NEVER_INLINE
-    void write_msgpack_array(const BasicJsonType& j, const std::size_t depth)
-    {
-        write_msgpack_array_prefix(j.m_data.m_value.array->size(), j);
-        write_msgpack_array_elements(j, depth, std::integral_constant<bool, msgpack_integers_fit_64_bits()>());
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::true_type /*fits_64_bits*/)
-    {
-        write_array_elements(j, [this](CharType * out, const BasicJsonType & el)
-        {
-            return encode_msgpack_integer(out, el);
-        }, [this, depth](const BasicJsonType & el)
-        {
-            write_msgpack(el, depth + 1);
-        });
-    }
-
-    void write_msgpack_array_elements(const BasicJsonType& j, const std::size_t depth, std::false_type /*fits_64_bits*/)
-    {
-        for (const auto& el : *j.m_data.m_value.array)
-        {
-            write_msgpack(el, depth + 1);
-        }
-    }
-
     /*!
     @brief write an object key as a CBOR text string
 

tests/benchmarks/README.md

@@ -16,6 +16,15 @@ Micro-benchmarks for parsing, serialization and the binary formats, written with
 | `FromBinaryBuffer`, `FromBinaryFile` | read CBOR, MessagePack, UBJSON, BJData and BSON from a buffer or a `FILE*` |
 | `FromBinaryShape` | read deeply nested, container-heavy and scalar-heavy documents in every binary format |
 | `FromCborChunkedString` | read CBOR strings split into indefinite-length chunks |
+| `SaxParse` | parse with a SAX handler that only counts events, so no values are built |
+| `Copy`, `CopyAssign`, `CopyRing` | copy a parsed document and destroy a copy, both timed: a temporary copy, an assignment over an earlier copy, and replacing the oldest of eight live copies |
+| `CopyOnly`, `DestroyOnly` | only the copy or only the destruction, the other half untimed; a fast destructor can leave work to the next allocations, so these tell the halves apart but do not compare versions |
+| `Equal`, `Iterate` | compare a parsed document with a copy, or visit every value with range-based `for` loops |
+| `Flatten`, `FlattenOrdered`, `Unflatten` | `flatten()` for `json` and `ordered_json`, and `unflatten()` |
+| `Diff`, `Patch` | `diff()` against the document with every eighth scalar changed, and applying that patch |
+| `JsonPointerParse`, `JsonPointerToString`, `JsonPointerAt`, `JsonPointerContains` | the JSON pointers of every scalar in a document: parse them from strings, turn them back into strings, look them up with `at()` and `contains()` |
+| `GetVectorInt`, `GetVectorDouble`, `GetMap` | `get<std::vector<std::int64_t>>()`, `get<std::vector<double>>()` and `get<std::map<std::string, json>>()` on large arrays and a large flat object |
+| `ToJsonStrings` | create a `json` array from a `std::vector` of 100,000 strings, copied or moved |
 
 The input files are those of [nativejson-benchmark](https://github.com/miloyip/nativejson-benchmark) (`canada`,
 `citm_catalog`, `twitter`), a large `jeopardy` file, and number-heavy files (`floats`, `signed_ints`, ...).

tests/benchmarks/src/benchmarks.cpp

@@ -8,11 +8,14 @@
 
 #include <benchmark/benchmark.h>
 #include <nlohmann/json.hpp>
-#include <fstream>
 #include <array>
+#include <cstdint>
 #include <deque>
+#include <fstream>
+#include <map>
 #include <numeric>
 #include <set>
+#include <string>
 #include <vector>
 #include <test_data.hpp>
 
@@ -624,6 +627,586 @@ static void FromCborChunkedString(benchmark::State& state, const std::size_t chu
 
 BENCHMARK_CAPTURE(FromCborChunkedString, 10000 chunks, 10000);
 
+//////////////////////////////////////////////////////////////////////////////
+// SAX-parse JSON from string
+//
+// sax_parse() with a handler that does next to nothing runs the lexer and
+// parser without building values, so the gap to ParseString above is the cost
+// of building the DOM.
+//////////////////////////////////////////////////////////////////////////////
+
+static std::string read_file(const char* filename)
+{
+    std::ifstream f(filename);
+    return std::string((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+}
+
+static json load_json(const char* filename)
+{
+    return json::parse(read_file(filename));
+}
+
+/// SAX handler that only counts the events, so that the handler costs next to nothing
+class counting_sax : public nlohmann::json_sax<json>
+{
+  public:
+    std::size_t events = 0;
+
+    bool null() override
+    {
+        return count();
+    }
+    bool boolean(bool /*val*/) override
+    {
+        return count();
+    }
+    bool number_integer(number_integer_t /*val*/) override
+    {
+        return count();
+    }
+    bool number_unsigned(number_unsigned_t /*val*/) override
+    {
+        return count();
+    }
+    bool number_float(number_float_t /*val*/, const string_t& /*s*/) override
+    {
+        return count();
+    }
+    bool string(string_t& /*val*/) override
+    {
+        return count();
+    }
+    bool binary(binary_t& /*val*/) override
+    {
+        return count();
+    }
+    bool start_object(std::size_t /*elements*/) override
+    {
+        return count();
+    }
+    bool key(string_t& /*val*/) override
+    {
+        return count();
+    }
+    bool end_object() override
+    {
+        return count();
+    }
+    bool start_array(std::size_t /*elements*/) override
+    {
+        return count();
+    }
+    bool end_array() override
+    {
+        return count();
+    }
+    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const json::exception& /*ex*/) override
+    {
+        return false;
+    }
+
+  private:
+    bool count()
+    {
+        ++events;
+        return true;
+    }
+};
+
+static void SaxParse(benchmark::State& state, const char* filename)
+{
+    const std::string str = read_file(filename);
+
+    for (auto _ : state)
+    {
+        counting_sax sax;
+        bool result = json::sax_parse(str, &sax);
+        benchmark::DoNotOptimize(result);
+        benchmark::DoNotOptimize(sax.events);
+    }
+
+    state.SetBytesProcessed(state.iterations() * str.size());
+}
+BENCHMARK_CAPTURE(SaxParse, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(SaxParse, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(SaxParse, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+//////////////////////////////////////////////////////////////////////////////
+// work with values: copy, destroy, compare, iterate
+//
+// The parsed test files stand in for a document an application keeps around.
+// Each benchmark times one whole-document operation; setup and cleanup run
+// outside the timed section.
+//
+// A copy is always destroyed again, and how a document is freed shapes the
+// heap the next copy allocates from: a destructor that frees quickly can leave
+// work to the allocator's next calls. Copy, CopyAssign and CopyRing therefore
+// time the copy together with the destruction of a copy; CopyOnly and
+// DestroyOnly time one half each and are meant for telling the halves apart,
+// not for comparing versions.
+//////////////////////////////////////////////////////////////////////////////
+
+/// copy a document and destroy the copy again, as a temporary copy is used
+static void Copy(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+
+    for (auto _ : state)
+    {
+        json copy = j;
+        benchmark::DoNotOptimize(copy);
+    }
+}
+BENCHMARK_CAPTURE(Copy, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(Copy, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(Copy, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+/// copy-assign a document over an earlier copy of it, which is freed in the process
+static void CopyAssign(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+    json target = j;
+
+    for (auto _ : state)
+    {
+        target = j;
+        benchmark::DoNotOptimize(target);
+    }
+}
+BENCHMARK_CAPTURE(CopyAssign, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(CopyAssign, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(CopyAssign, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+/// keep eight copies alive and replace the oldest one, as a cache or an undo
+/// history does, so that the copy is not made from memory just freed by an
+/// identical document
+static void CopyRing(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+    std::vector<json> ring(8, j);
+    std::size_t oldest = 0;
+
+    for (auto _ : state)
+    {
+        ring[oldest] = j;
+        benchmark::DoNotOptimize(ring[oldest]);
+        oldest = (oldest + 1) % ring.size();
+    }
+}
+BENCHMARK_CAPTURE(CopyRing, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(CopyRing, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(CopyRing, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+/// only the copy; the copy is destroyed with the timer paused (diagnostic)
+static void CopyOnly(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+
+    for (auto _ : state)
+    {
+        auto* copy = new json(j);
+
+        state.PauseTiming();
+        delete copy;
+        state.ResumeTiming();
+    }
+}
+BENCHMARK_CAPTURE(CopyOnly, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(CopyOnly, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(CopyOnly, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+/// only the destruction; the copy is made with the timer paused (diagnostic)
+static void DestroyOnly(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+
+    for (auto _ : state)
+    {
+        state.PauseTiming();
+        auto* copy = new json(j);
+        state.ResumeTiming();
+
+        delete copy;
+    }
+}
+BENCHMARK_CAPTURE(DestroyOnly, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(DestroyOnly, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(DestroyOnly, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+static void Equal(benchmark::State& state, const char* filename)
+{
+    // two separate values, so that the comparison cannot stop at identical addresses
+    const json j = load_json(filename);
+    const json copy = j;
+
+    for (auto _ : state)
+    {
+        bool result = (j == copy);
+        benchmark::DoNotOptimize(result);
+    }
+}
+BENCHMARK_CAPTURE(Equal, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(Equal, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(Equal, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+/// visit every value with range-based for loops, as client code walks a document
+static std::size_t count_values(const json& j)
+{
+    std::size_t result = 1;
+    if (j.is_structured())
+    {
+        for (const auto& element : j)
+        {
+            result += count_values(element);
+        }
+    }
+    return result;
+}
+
+static void Iterate(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+
+    for (auto _ : state)
+    {
+        std::size_t result = count_values(j);
+        benchmark::DoNotOptimize(result);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(count_values(j)));
+}
+BENCHMARK_CAPTURE(Iterate, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(Iterate, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(Iterate, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+//////////////////////////////////////////////////////////////////////////////
+// flatten and unflatten
+//////////////////////////////////////////////////////////////////////////////
+
+static void Flatten(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+
+    for (auto _ : state)
+    {
+        json flat = j.flatten();
+        benchmark::DoNotOptimize(flat);
+    }
+}
+BENCHMARK_CAPTURE(Flatten, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(Flatten, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(Flatten, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+// ordered_json objects look keys up linearly, which flatten() used to do for
+// every value; canada (330,000 values in one flat object) is left out, as it
+// would take minutes with such versions
+static void FlattenOrdered(benchmark::State& state, const char* filename)
+{
+    const nlohmann::ordered_json j = nlohmann::ordered_json::parse(read_file(filename));
+
+    for (auto _ : state)
+    {
+        nlohmann::ordered_json flat = j.flatten();
+        benchmark::DoNotOptimize(flat);
+    }
+}
+BENCHMARK_CAPTURE(FlattenOrdered, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(FlattenOrdered, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+static void Unflatten(benchmark::State& state, const char* filename)
+{
+    const json flat = load_json(filename).flatten();
+
+    for (auto _ : state)
+    {
+        json j = flat.unflatten();
+        benchmark::DoNotOptimize(j);
+    }
+}
+BENCHMARK_CAPTURE(Unflatten, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(Unflatten, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(Unflatten, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+//////////////////////////////////////////////////////////////////////////////
+// diff and patch
+//
+// The target is the document with every eighth scalar changed, so the patch
+// has one "replace" operation per changed value and the structure stays the
+// same.
+//////////////////////////////////////////////////////////////////////////////
+
+static void change_every_eighth_scalar(json& j, std::size_t& counter)
+{
+    if (j.is_structured())
+    {
+        for (auto& element : j)
+        {
+            change_every_eighth_scalar(element, counter);
+        }
+        return;
+    }
+
+    if (++counter % 8 != 0)
+    {
+        return;
+    }
+
+    switch (j.type())
+    {
+        case json::value_t::number_integer:
+            j = j.get<json::number_integer_t>() + 1;
+            break;
+        case json::value_t::number_unsigned:
+            j = j.get<json::number_unsigned_t>() + 1;
+            break;
+        case json::value_t::number_float:
+            j = j.get<json::number_float_t>() + 0.5;
+            break;
+        case json::value_t::string:
+            j = j.get<std::string>() + "!";
+            break;
+        case json::value_t::boolean:
+            j = !j.get<bool>();
+            break;
+        case json::value_t::null:
+        case json::value_t::object:
+        case json::value_t::array:
+        case json::value_t::binary:
+        case json::value_t::discarded:
+        default:
+            j = 0;
+            break;
+    }
+}
+
+static json changed_copy(const json& j)
+{
+    json result = j;
+    std::size_t counter = 0;
+    change_every_eighth_scalar(result, counter);
+    return result;
+}
+
+static void Diff(benchmark::State& state, const char* filename)
+{
+    const json source = load_json(filename);
+    const json target = changed_copy(source);
+
+    for (auto _ : state)
+    {
+        json patch = json::diff(source, target);
+        benchmark::DoNotOptimize(patch);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(json::diff(source, target).size()));
+}
+BENCHMARK_CAPTURE(Diff, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(Diff, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(Diff, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+static void Patch(benchmark::State& state, const char* filename)
+{
+    const json source = load_json(filename);
+    const json patch = json::diff(source, changed_copy(source));
+
+    for (auto _ : state)
+    {
+        json result = source.patch(patch);
+        benchmark::DoNotOptimize(result);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(patch.size()));
+}
+BENCHMARK_CAPTURE(Patch, canada,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json");
+BENCHMARK_CAPTURE(Patch, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(Patch, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+//////////////////////////////////////////////////////////////////////////////
+// JSON Pointer
+//
+// The pointers are those of every scalar in the document, i.e., the keys of
+// its flattened form.
+//////////////////////////////////////////////////////////////////////////////
+
+static std::vector<std::string> pointer_strings(const json& j)
+{
+    std::vector<std::string> result;
+    const json flat = j.flatten();
+    result.reserve(flat.size());
+    for (auto it = flat.begin(); it != flat.end(); ++it)
+    {
+        result.push_back(it.key());
+    }
+    return result;
+}
+
+static std::vector<json::json_pointer> pointers(const json& j)
+{
+    const std::vector<std::string> strings = pointer_strings(j);
+    std::vector<json::json_pointer> result;
+    result.reserve(strings.size());
+    for (const auto& s : strings)
+    {
+        result.emplace_back(s);
+    }
+    return result;
+}
+
+static void JsonPointerParse(benchmark::State& state, const char* filename)
+{
+    const std::vector<std::string> strings = pointer_strings(load_json(filename));
+
+    for (auto _ : state)
+    {
+        for (const auto& s : strings)
+        {
+            json::json_pointer ptr(s);
+            benchmark::DoNotOptimize(ptr);
+        }
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(strings.size()));
+}
+BENCHMARK_CAPTURE(JsonPointerParse, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(JsonPointerParse, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+static void JsonPointerToString(benchmark::State& state, const char* filename)
+{
+    const std::vector<json::json_pointer> ptrs = pointers(load_json(filename));
+
+    for (auto _ : state)
+    {
+        for (const auto& ptr : ptrs)
+        {
+            std::string s = ptr.to_string();
+            benchmark::DoNotOptimize(s);
+        }
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(ptrs.size()));
+}
+BENCHMARK_CAPTURE(JsonPointerToString, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(JsonPointerToString, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+static void JsonPointerAt(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+    const std::vector<json::json_pointer> ptrs = pointers(j);
+
+    for (auto _ : state)
+    {
+        for (const auto& ptr : ptrs)
+        {
+            const json& value = j.at(ptr);
+            benchmark::DoNotOptimize(&value);
+        }
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(ptrs.size()));
+}
+BENCHMARK_CAPTURE(JsonPointerAt, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(JsonPointerAt, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+static void JsonPointerContains(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+    const std::vector<json::json_pointer> ptrs = pointers(j);
+
+    for (auto _ : state)
+    {
+        for (const auto& ptr : ptrs)
+        {
+            bool result = j.contains(ptr);
+            benchmark::DoNotOptimize(result);
+        }
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(ptrs.size()));
+}
+BENCHMARK_CAPTURE(JsonPointerContains, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+BENCHMARK_CAPTURE(JsonPointerContains, twitter,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json");
+
+//////////////////////////////////////////////////////////////////////////////
+// conversions from and to C++ containers
+//////////////////////////////////////////////////////////////////////////////
+
+static void GetVectorInt(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+
+    for (auto _ : state)
+    {
+        auto v = j.get<std::vector<std::int64_t>>();
+        benchmark::DoNotOptimize(v);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(j.size()));
+}
+BENCHMARK_CAPTURE(GetVectorInt, signed_ints, TEST_DATA_DIRECTORY "/regression/signed_ints.json");
+
+static void GetVectorDouble(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename);
+
+    for (auto _ : state)
+    {
+        auto v = j.get<std::vector<double>>();
+        benchmark::DoNotOptimize(v);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(j.size()));
+}
+BENCHMARK_CAPTURE(GetVectorDouble, floats, TEST_DATA_DIRECTORY "/regression/floats.json");
+
+// a large flat object: the flattened document, one member per scalar
+static void GetMap(benchmark::State& state, const char* filename)
+{
+    const json j = load_json(filename).flatten();
+
+    for (auto _ : state)
+    {
+        auto m = j.get<std::map<std::string, json>>();
+        benchmark::DoNotOptimize(m);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(j.size()));
+}
+BENCHMARK_CAPTURE(GetMap, citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json");
+
+/// 100,000 strings, each too long for the small string optimization
+static std::vector<std::string> make_strings()
+{
+    std::vector<std::string> result;
+    result.reserve(100000);
+    for (std::size_t i = 0; i < 100000; ++i)
+    {
+        result.push_back("a string that does not fit in place: " + std::to_string(i));
+    }
+    return result;
+}
+
+static void ToJsonStrings(benchmark::State& state, const bool move)
+{
+    const std::vector<std::string> strings = make_strings();
+
+    for (auto _ : state)
+    {
+        state.PauseTiming();
+        std::vector<std::string> input = strings;
+        state.ResumeTiming();
+
+        auto* j = move ? new json(std::move(input)) : new json(input);
+
+        state.PauseTiming();
+        delete j;
+        state.ResumeTiming();
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(strings.size()));
+}
+BENCHMARK_CAPTURE(ToJsonStrings, copy, false);
+BENCHMARK_CAPTURE(ToJsonStrings, move, true);
+
 // conversion of a JSON array into standard containers
 template<typename Container>
 static void GetArray(benchmark::State& state)

tests/src/unit-binary_writer_sinks.cpp

@@ -11,10 +11,8 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
-#include <array>
 #include <cstdint>
 #include <limits>
-#include <sstream>
 #include <string>
 #include <vector>
 
@@ -37,17 +35,6 @@ std::vector<json> test_values()
         big_object[std::to_string(i)] = i;
     }
 
-    // large strings and binary values between small ones: a write too large
-    // for the space the vector sink has ahead takes a different path than a
-    // small one, and the small writes after it must still land behind it
-    json large_payloads = json::array();
-    for (int i = 0; i < 50; ++i)
-    {
-        large_payloads.push_back(std::string(300, static_cast<char>('a' + (i % 26))));
-        large_payloads.push_back(i);
-        large_payloads.push_back(json::binary(std::vector<std::uint8_t>(static_cast<std::size_t>(100 * i), static_cast<std::uint8_t>(i))));
-    }
-
     return
     {
         json(nullptr), json(true), json(false),
@@ -59,8 +46,7 @@ std::vector<json> test_values()
         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, large_payloads,
-        json::binary(std::vector<std::uint8_t>(5000, 0x42))
+        big_array, big_object
     };
 }
 
@@ -184,258 +170,6 @@ TEST_CASE("binary writer output sinks")
     }
 }
 
-namespace
-{
-
-// the CBOR head of an integer, encoded independently of binary_writer
-void reference_cbor_head(std::vector<std::uint8_t>& out, const std::uint8_t major_type, const std::uint64_t argument)
-{
-    if (argument <= 23)
-    {
-        out.push_back(static_cast<std::uint8_t>(major_type + argument));
-        return;
-    }
-
-    int length = 8;
-    std::uint8_t additional = 27;
-    if (argument <= 0xFF)
-    {
-        length = 1;
-        additional = 24;
-    }
-    else if (argument <= 0xFFFF)
-    {
-        length = 2;
-        additional = 25;
-    }
-    else if (argument <= 0xFFFFFFFF)
-    {
-        length = 4;
-        additional = 26;
-    }
-
-    out.push_back(static_cast<std::uint8_t>(major_type + additional));
-    for (int i = length - 1; i >= 0; --i)
-    {
-        out.push_back(static_cast<std::uint8_t>(argument >> (8 * i)));
-    }
-}
-
-// the CBOR encoding of an integer value
-void reference_cbor_integer(std::vector<std::uint8_t>& out, const json& j)
-{
-    if (j.is_number_unsigned())
-    {
-        reference_cbor_head(out, 0x00, j.get<std::uint64_t>());
-        return;
-    }
-
-    const auto n = j.get<std::int64_t>();
-    if (n >= 0)
-    {
-        reference_cbor_head(out, 0x00, static_cast<std::uint64_t>(n));
-    }
-    else
-    {
-        reference_cbor_head(out, 0x20, static_cast<std::uint64_t>(-1 - n));
-    }
-}
-
-// the MessagePack encoding of an integer value, encoded independently of
-// binary_writer
-void reference_msgpack_integer(std::vector<std::uint8_t>& out, const json& j)
-{
-    const auto put = [&out](const std::uint8_t marker, const std::uint64_t bits, const int length)
-    {
-        out.push_back(marker);
-        for (int i = length - 1; i >= 0; --i)
-        {
-            out.push_back(static_cast<std::uint8_t>(bits >> (8 * i)));
-        }
-    };
-
-    if (j.is_number_unsigned() || j.get<std::int64_t>() >= 0)
-    {
-        const auto u = j.get<std::uint64_t>();
-        if (u < 128)
-        {
-            out.push_back(static_cast<std::uint8_t>(u));
-        }
-        else if (u <= 0xFF)
-        {
-            put(0xCC, u, 1);
-        }
-        else if (u <= 0xFFFF)
-        {
-            put(0xCD, u, 2);
-        }
-        else if (u <= 0xFFFFFFFF)
-        {
-            put(0xCE, u, 4);
-        }
-        else
-        {
-            put(0xCF, u, 8);
-        }
-        return;
-    }
-
-    const auto n = j.get<std::int64_t>();
-    const auto bits = static_cast<std::uint64_t>(n);
-    if (n >= -32)
-    {
-        out.push_back(static_cast<std::uint8_t>(bits));
-    }
-    else if (n >= -128)
-    {
-        put(0xD0, bits, 1);
-    }
-    else if (n >= -32768)
-    {
-        put(0xD1, bits, 2);
-    }
-    else if (n >= -2147483648LL)
-    {
-        put(0xD2, bits, 4);
-    }
-    else
-    {
-        put(0xD3, bits, 8);
-    }
-}
-
-// integers at every boundary of the CBOR and MessagePack sizes, signed and
-// unsigned
-std::vector<json> boundary_integers()
-{
-    std::vector<json> result;
-    const std::array<std::uint64_t, 38> boundaries =
-    {
-        {
-            0, 1, 22, 23, 24, 25, 31, 32, 33, 126, 127, 128, 129, 254, 255, 256, 257,
-            32766, 32767, 32768, 32769, 65534, 65535, 65536, 65537,
-            2147483646ULL, 2147483647ULL, 2147483648ULL, 2147483649ULL,
-            4294967294ULL, 4294967295ULL, 4294967296ULL, 4294967297ULL,
-            9223372036854775806ULL, 9223372036854775807ULL, 9223372036854775808ULL,
-            18446744073709551614ULL, 18446744073709551615ULL
-        }
-    };
-    for (const std::uint64_t u : boundaries)
-    {
-        result.emplace_back(u);
-        if (u <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
-        {
-            const auto n = static_cast<std::int64_t>(u);
-            result.emplace_back(n);
-            result.emplace_back(-n);
-            result.emplace_back(-n - 1);
-        }
-    }
-    return result;
-}
-
-} // namespace
-
-// Arrays of integers are written in runs straight into space reserved from the
-// sink, with branch-free encodings; check them against independent encoders for
-// runs shorter and longer than one reservation, broken up by other values, and
-// through each sink.
-TEST_CASE("CBOR and MessagePack integer arrays")
-{
-    const std::vector<json> integers = boundary_integers();
-
-    for (const std::size_t length :
-            {
-                std::size_t{1}, std::size_t{27}, std::size_t{28}, std::size_t{29}, std::size_t{57}, std::size_t{1000}
-            })
-    {
-        for (const std::size_t break_every :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{7}, std::size_t{28}
-                })
-        {
-            CAPTURE(length)
-            CAPTURE(break_every)
-
-            json array = json::array();
-            std::vector<std::uint8_t> expected_cbor;
-            std::vector<std::uint8_t> expected_msgpack;
-            for (std::size_t i = 0; i < length; ++i)
-            {
-                if (break_every != 0 && i % (break_every + 1) == break_every)
-                {
-                    array.push_back("x");
-                    expected_cbor.push_back(0x61);
-                    expected_cbor.push_back('x');
-                    expected_msgpack.push_back(0xA1);
-                    expected_msgpack.push_back('x');
-                }
-                else
-                {
-                    const json& value = integers[(i * 7) % integers.size()];
-                    array.push_back(value);
-                    reference_cbor_integer(expected_cbor, value);
-                    reference_msgpack_integer(expected_msgpack, value);
-                }
-            }
-
-            std::vector<std::uint8_t> head;
-            reference_cbor_head(head, 0x80, length);
-            expected_cbor.insert(expected_cbor.begin(), head.begin(), head.end());
-
-            head.clear();
-            if (length <= 15)
-            {
-                head.push_back(static_cast<std::uint8_t>(0x90 + length));
-            }
-            else
-            {
-                head = {0xDC, static_cast<std::uint8_t>(length >> 8), static_cast<std::uint8_t>(length)};
-            }
-            expected_msgpack.insert(expected_msgpack.begin(), head.begin(), head.end());
-
-            CHECK(json::to_cbor(array) == expected_cbor);
-            CHECK(json::to_msgpack(array) == expected_msgpack);
-
-            std::vector<std::uint8_t> through_adapter = {0xAA};
-            json::to_cbor(array, through_adapter);
-            CHECK(std::vector<std::uint8_t>(through_adapter.begin() + 1, through_adapter.end()) == expected_cbor);
-            through_adapter = {0xAA};
-            json::to_msgpack(array, through_adapter);
-            CHECK(std::vector<std::uint8_t>(through_adapter.begin() + 1, through_adapter.end()) == expected_msgpack);
-
-            std::ostringstream stream;
-            json::to_cbor(array, stream);
-            std::string streamed = stream.str();
-            CHECK(std::vector<std::uint8_t>(streamed.begin(), streamed.end()) == expected_cbor);
-            stream.str("");
-            json::to_msgpack(array, stream);
-            streamed = stream.str();
-            CHECK(std::vector<std::uint8_t>(streamed.begin(), streamed.end()) == expected_msgpack);
-
-            CHECK(json::from_cbor(expected_cbor) == array);
-            CHECK(json::from_msgpack(expected_msgpack) == array);
-
-            // the same array as object members
-            const json object = {{"a", array}, {"b", array}};
-            CHECK(json::from_cbor(json::to_cbor(object)) == object);
-            CHECK(json::from_msgpack(json::to_msgpack(object)) == object);
-        }
-    }
-
-    // single values, outside an array
-    for (const auto& value : integers)
-    {
-        CAPTURE(value)
-        std::vector<std::uint8_t> expected;
-        reference_cbor_integer(expected, value);
-        CHECK(json::to_cbor(value) == expected);
-        expected.clear();
-        reference_msgpack_integer(expected, value);
-        CHECK(json::to_msgpack(value) == 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.