Address review comments on operator[](json_pointer) rollback

- undo() shrinks the array with resize() instead of erase()
- comments say what "will be" done in get_unchecked_create
- tests: avoid a clang-tidy performance-unnecessary-copy-initialization
  hit (unit-alt-string) and the word "access" in section names, which
  Flawfinder flags as race/access

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

docs/mkdocs/docs/api/basic_json/at.md

@@ -90,7 +90,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Constant.
 2. Logarithmic in the size of the container.
 3. Logarithmic in the size of the container.
-4. Logarithmic in the size of the container.
+4. Linear in the number of reference tokens of `ptr`; for each of them, logarithmic in the size of the object, or
+   constant for an array.
 
 ## Notes
 

docs/mkdocs/docs/api/basic_json/operator[].md

@@ -92,12 +92,20 @@ Strong exception safety: if an exception occurs, the original value stays intact
     For the **const** version, an object key or array index in `ptr` that does not exist is not reported by an
     exception, but is undefined behavior (see the notes below). Use [`at`](at.md) for checked access.
 
+    If the **non-const** version throws, the value is left unchanged: values it created for earlier reference tokens
+    of `ptr` are removed again. This also holds for exceptions such as `#!cpp std::bad_alloc` or
+    `#!cpp std::length_error` thrown while padding an array up to a very large index. With custom
+    [template parameters](../../features/types/template_parameters.md), this requires that `erase()` of the object and
+    array types and the move operations of the custom base class do not throw.
+
 ## Complexity
 
 1. Constant if `idx` is in the range of the array. Otherwise, linear in `idx - size()`.
 2. Logarithmic in the size of the container.
 3. Logarithmic in the size of the container.
-4. Logarithmic in the size of the container.
+4. Linear in the number of reference tokens of `ptr`; for each of them, logarithmic in the size of the object, or
+   constant for an array. When the non-const version pads an array with `#!json null` values, it is additionally
+   linear in `idx - size()` for that array.
 
 ## Notes
 
@@ -145,6 +153,14 @@ Strong exception safety: if an exception occurs, the original value stays intact
         specified by the JSON Pointer RFC; it is this library's own, intentional disambiguation rule. See also
         [JSON Pointer](../../features/json_pointer.md).
 
+    !!! warning "Large array indices"
+
+        As the array is filled up with `#!json null` values to the given index, the memory used grows with the index
+        and not with the size of the pointer: on a 64-bit platform, the index `10000000` allocates about 160 MB.
+        The library does not limit the index, so check the array indices of a JSON pointer from untrusted input
+        before using it with the non-const version. See
+        [Parsing untrusted input](../../features/parsing/untrusted_input.md#json-pointers-and-flattened-keys).
+
 !!! warning "Deprecation"
 
     Overload (4) also accepts a [`json_pointer`](../json_pointer/index.md) whose template argument is a `basic_json`
@@ -294,4 +310,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
 4. Added in version 2.0.0. A missing array index in the const version is guarded by a runtime assertion since
    version 3.13.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
 [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is not
-a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
+a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones. Fixed in version 3.13.0 to leave the value
+unchanged if the non-const version throws (strong exception safety, as documented); before, values created for earlier
+reference tokens of `ptr` were kept.

docs/mkdocs/docs/features/parsing/untrusted_input.md

@@ -130,6 +130,17 @@ parameters of [`parse()`](../../api/basic_json/parse.md) or [`accept()`](../../a
 enable either for input whose conformance you cannot otherwise control, since interoperability with strictly
 conforming JSON consumers is exactly what the default rejects.
 
+## JSON Pointers and flattened keys
+
+A [JSON Pointer](../json_pointer.md) can come from untrusted input as well, for instance as a path in a request or as a
+key of a flattened object. The non-const [`operator[]`](../../api/basic_json/operator%5B%5D.md) with a JSON Pointer and
+[`unflatten`](../../api/basic_json/unflatten.md) create missing values, and when an array index lies beyond the end of
+an array, they fill the array with `#!json null` values up to that index. The memory used therefore grows with the
+index, not with the size of the pointer: on a 64-bit platform, the index `10000000` allocates about 160 MB, the index
+`100000000` about 1.6 GB. The library does not limit the index. For pointers from untrusted input, check the array
+indices (or the pointer as a whole) before using them, or use [`at`](../../api/basic_json/at.md) or
+[`contains`](../../api/basic_json/contains.md), which never add values.
+
 ## Checklist
 
 - Wrap parsing in a `#!cpp try`/`#!cpp catch` block, or use `allow_exceptions=false`/`accept()` if your environment
@@ -145,6 +156,8 @@ conforming JSON consumers is exactly what the default rejects.
   `JSON_STRICT_NUL_HANDLING`.
 - Decide whether duplicate object keys should be an error for your application, and add a callback if so.
 - Do not enable `ignore_comments` or `ignore_trailing_commas` for input that must be strictly conforming JSON.
+- Check the array indices of untrusted JSON Pointers and flattened keys before passing them to the non-const
+  `operator[]` or `unflatten()`, which fill arrays with `#!json null` values up to the index.
 
 For the broader design rationale and how it is tested (fuzzing, sanitizers, static analysis), see the
 [assurance case](../../community/assurance_case.md) and [quality assurance](../../community/quality_assurance.md). To

include/nlohmann/detail/json_pointer.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <algorithm> // all_of, copy
+#include <algorithm> // copy
 #include <array> // array
 #include <cctype> // isdigit
 #include <cerrno> // errno, ERANGE
@@ -16,9 +16,11 @@
 #include <cstdint> // uint64_t
 #include <cstdlib> // strtoull
 #include <cstring> // memchr, memcmp, memcpy
+#include <functional> // less
 #ifndef JSON_NO_IO
     #include <iosfwd> // ostream
 #endif  // JSON_NO_IO
+#include <iterator> // next
 #include <limits> // max
 #include <string> // string
 #include <utility> // move
@@ -28,6 +30,7 @@
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/meta/void_t.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 #include <nlohmann/detail/string_escape.hpp>
 #include <nlohmann/detail/string_utils.hpp>
@@ -134,6 +137,26 @@ JSON_HEDLEY_ALWAYS_INLINE array_index_status parse_array_index(const StringType&
     return array_index_status::ok;
 }
 
+/// whether two keys of type @a StringType are equivalent under @a Compare
+/// exactly if they are equal: std::less<StringType> and std::less<>
+template<typename Compare, typename StringType>
+struct is_less_comparator : std::false_type {};
+
+template<typename StringType>
+struct is_less_comparator<std::less<StringType>, StringType> : std::true_type {};
+
+template<typename StringType>
+struct is_less_comparator<std::less<void>, StringType> : std::true_type {};
+
+/// whether the objects of type @a ObjectType find a key of type @a StringType
+/// exactly if it equals a stored key
+template<typename ObjectType, typename StringType, typename = void>
+struct finds_equal_keys : std::false_type {};
+
+template<typename ObjectType, typename StringType>
+struct finds_equal_keys<ObjectType, StringType, void_t<typename ObjectType::key_compare, typename ObjectType::key_type>>
+    : conjunction<is_less_comparator<typename ObjectType::key_compare, StringType>, std::is_same<typename ObjectType::key_type, StringType>> {};
+
 }  // namespace detail
 
 /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
@@ -589,6 +612,228 @@ class json_pointer
         return object_member_impl(object, key, detail::priority_tag<1> {});
     }
 
+    /// @brief append a null value to @a array, like operator[] with the size of @a array
+    template<typename BasicJsonType>
+    static BasicJsonType& array_append(BasicJsonType& array)
+    {
+        auto& elements = *array.m_data.m_value.array;
+        const auto old_capacity = array.container_capacity();
+        elements.emplace_back();
+        return array.set_parent_after_insert(elements.back(), old_capacity);
+    }
+
+    /// @brief add @a key, which is missing, to @a object
+    template<typename BasicJsonType>
+    static auto object_add_impl(BasicJsonType& object, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(object.m_data.m_value.object->emplace(key, nullptr), std::declval<BasicJsonType&>())
+    {
+        const auto old_capacity = object.container_capacity();
+        const auto it = object.m_data.m_value.object->emplace(key, nullptr).first;
+        return object.set_parent_after_insert(it->second, old_capacity);
+    }
+
+    template<typename BasicJsonType>
+    static BasicJsonType& object_add_impl(BasicJsonType& object, const string_t& key, detail::priority_tag<0> /*unused*/)
+    {
+        return object.operator[](key);
+    }
+
+    template<typename BasicJsonType>
+    static BasicJsonType& object_add(BasicJsonType& object, const string_t& key)
+    {
+        return object_add_impl(object, key, detail::priority_tag<1> {});
+    }
+
+    /// @brief search @a key in @a members: the result is where the key is or,
+    /// for objects that can insert at a position (std::map), where it belongs
+    template<typename ObjectType>
+    static auto object_search_impl(ObjectType& members, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(members.key_comp()(key, members.lower_bound(key)->first), members.lower_bound(key))
+    {
+        return members.lower_bound(key);
+    }
+
+    template<typename ObjectType>
+    static auto object_search_impl(ObjectType& members, const string_t& key, detail::priority_tag<0> /*unused*/)
+    -> decltype(members.find(key))
+    {
+        return members.find(key);
+    }
+
+    template<typename ObjectType>
+    static auto object_search(ObjectType& members, const string_t& key)
+    -> decltype(object_search_impl(members, key, detail::priority_tag<1> {}))
+    {
+        return object_search_impl(members, key, detail::priority_tag<1> {});
+    }
+
+    /// @brief whether @a it, the result of @ref object_search for @a key, points to @a key
+    ///
+    /// With std::less, the key at the lower bound is equivalent to @a key
+    /// exactly if it is equal to it, and comparing for equality is cheaper.
+    template<typename ObjectType, typename Iterator,
+             detail::enable_if_t<detail::finds_equal_keys<ObjectType, string_t>::value, int> = 0>
+    static auto object_search_found_impl(ObjectType& members, const Iterator& it, const string_t& key, detail::priority_tag<2> /*unused*/)
+    -> decltype(members.lower_bound(key), it->first == key)
+    {
+        return it != members.end() && it->first == key;
+    }
+
+    template<typename ObjectType, typename Iterator>
+    static auto object_search_found_impl(ObjectType& members, const Iterator& it, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(members.key_comp()(key, it->first), members.lower_bound(key), bool())
+    {
+        return it != members.end() && !members.key_comp()(key, it->first);
+    }
+
+    template<typename ObjectType, typename Iterator>
+    static bool object_search_found_impl(ObjectType& members, const Iterator& it, const string_t& /*key*/, detail::priority_tag<0> /*unused*/)
+    {
+        return it != members.end();
+    }
+
+    template<typename ObjectType, typename Iterator>
+    static bool object_search_found(ObjectType& members, const Iterator& it, const string_t& key)
+    {
+        return object_search_found_impl(members, it, key, detail::priority_tag<2> {});
+    }
+
+    /// @brief insert @a key, which is missing, into @a object at @a it, the
+    /// result of @ref object_search for @a key
+    template<typename BasicJsonType, typename Iterator>
+    static auto object_insert_impl(BasicJsonType& object, const Iterator& it, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(object.m_data.m_value.object->emplace_hint(it, key, nullptr), std::declval<BasicJsonType&>())
+    {
+        const auto old_capacity = object.container_capacity();
+        const auto pos = object.m_data.m_value.object->emplace_hint(it, key, nullptr);
+        return object.set_parent_after_insert(pos->second, old_capacity);
+    }
+
+    template<typename BasicJsonType, typename Iterator>
+    static BasicJsonType& object_insert_impl(BasicJsonType& object, const Iterator& /*it*/, const string_t& key, detail::priority_tag<0> /*unused*/)
+    {
+        return object_add(object, key);
+    }
+
+    template<typename BasicJsonType, typename Iterator>
+    static BasicJsonType& object_insert(BasicJsonType& object, const Iterator& it, const string_t& key)
+    {
+        return object_insert_impl(object, it, key, detail::priority_tag<1> {});
+    }
+
+    /*!
+    @brief undoes the change @ref get_unchecked_create made to an existing value
+
+    @ref get_unchecked walks existing values without changing them. At the
+    first reference token that does not select an existing value, @ref
+    get_unchecked_create makes exactly one change to an existing value: it
+    converts a null value, inserts a key into an object, or grows an array.
+    Everything it creates afterwards lies below that change. If a later step
+    throws, the destructor of this guard reverts that one change, which
+    removes everything created after it, so the value is left as it was
+    (strong exception safety). The guard needs no try/catch and therefore also
+    compiles with JSON_NOEXCEPTION.
+
+    Reverting the change must not throw, as it happens in a destructor. It
+    erases the inserted member by its iterator (no key is converted or
+    compared, nothing is allocated), erases the added elements at the end of
+    the array, or swaps the null value back. This holds for std::map,
+    std::vector, ordered_map, and every object_t, array_t, and
+    json_base_class_t whose erase() and move operations do not throw.
+    Between recording and reverting, nothing is inserted into or erased from
+    the object or array, so the iterator stays valid.
+    */
+    template<typename BasicJsonType>
+    class get_unchecked_rollback
+    {
+      public:
+        using object_iterator = typename BasicJsonType::object_t::iterator;
+
+        /// record that @a member was inserted into the object @a value
+        get_unchecked_rollback(BasicJsonType* value, const object_iterator& member)
+            : m_value(value)
+            , m_member(member)
+            , m_change(change::key_inserted)
+        {}
+
+        /// record the change that the next reference token makes to the null value or array @a value
+        explicit get_unchecked_rollback(BasicJsonType* value)
+            : m_value(value)
+        {
+            if (value->is_null())
+            {
+                // keep the null value (with its base class and positions) and
+                // continue with a fresh null value in its place, which is what
+                // assigning an array or object to it would have left there
+                m_saved_null.swap(*value);
+                m_change = change::null_converted;
+            }
+            else
+            {
+                JSON_ASSERT(value->is_array());
+                m_old_size = value->m_data.m_value.array->size();
+                m_change = change::array_grown;
+            }
+        }
+
+        get_unchecked_rollback(const get_unchecked_rollback&) = delete;
+        get_unchecked_rollback(get_unchecked_rollback&&) = delete;
+        get_unchecked_rollback& operator=(const get_unchecked_rollback&) = delete;
+        get_unchecked_rollback& operator=(get_unchecked_rollback&&) = delete;
+
+        ~get_unchecked_rollback()
+        {
+            if (JSON_HEDLEY_UNLIKELY(m_change != change::none))
+            {
+                undo();
+            }
+        }
+
+        /// keep the change
+        void commit() noexcept
+        {
+            m_change = change::none;
+        }
+
+      private:
+        JSON_HEDLEY_NEVER_INLINE void undo() noexcept
+        {
+            switch (m_change)
+            {
+                case change::null_converted:
+                    // the values created since go away with m_saved_null
+                    m_value->swap(m_saved_null);
+                    break;
+                case change::key_inserted:
+                    m_value->m_data.m_value.object->erase(m_member);
+                    break;
+                case change::array_grown:
+                {
+                    auto& elements = *m_value->m_data.m_value.array;
+                    elements.resize(m_old_size);
+                    break;
+                }
+                case change::none:
+                default:
+                    break;
+            }
+        }
+
+        enum class change
+        {
+            none,
+            null_converted,
+            key_inserted,
+            array_grown
+        };
+
+        BasicJsonType* m_value;
+        object_iterator m_member {};
+        typename BasicJsonType::size_type m_old_size = 0;
+        change m_change = change::none;
+        BasicJsonType m_saved_null {};
+    };
+
   JSON_PRIVATE_UNLESS_TESTED:
     json_pointer top() const
     {
@@ -972,47 +1217,245 @@ class json_pointer
 
     Complexity: Linear in the length of the JSON pointer.
 
-    @throw parse_error.106   if an array index begins with '0'
+    Exception safety: Strong guarantee. This function walks existing values
-    @throw parse_error.109   if an array index was not a number
+    until the first reference token that does not select one. If that is the
-    @throw out_of_range.404  if the JSON pointer can not be resolved
+    last reference token, inserting the key into the object or growing the
+    array is strongly exception safe by itself; any other change is made by
+    @ref get_unchecked_create, which undoes it if a later step throws.
+
+    @throw parse_error.106   if an array index of an existing array begins with '0'
+    @throw parse_error.109   if an array index of an existing array was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved, or if an
+                             array index is too large for strtoull
+    @throw out_of_range.410  if an array index exceeds size_type
+    @throw std::length_error if padding an array exceeds its maximal size
+    @throw std::bad_alloc    if an allocation fails
     */
     template<typename BasicJsonType>
     BasicJsonType& get_unchecked(BasicJsonType* ptr) const
     {
-        for (const auto& reference_token : reference_tokens)
+        const auto* token = reference_tokens.data();
+        const auto* const end = token + reference_tokens.size();
+        if (token == end)
         {
+            return *ptr;
+        }
+        if (ptr->is_null())
+        {
+            // the null value is converted to an array or an object
+            return get_unchecked_create(ptr, token, end);
+        }
+
+        // walk existing values; the walk itself inserts nothing, which keeps
+        // the loop fast (insertions are done below or in get_unchecked_create)
+        typename BasicJsonType::object_t::iterator it;
+        do
+        {
+            if (ptr->is_object())
+            {
+                auto& members = *ptr->m_data.m_value.object;
+                it = object_search(members, *token);
+                if (!object_search_found(members, it, *token))
+                {
+                    // the key is inserted below or in get_unchecked_create
+                    break;
+                }
+                ptr = &it->second;
+            }
+            else if (ptr->is_array())
+            {
+                if (is_dash(*token))
+                {
+                    if (token + 1 == end)
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        return array_append(*ptr);
+                    }
+                    // an element will be appended in get_unchecked_create
+                    break;
+                }
+                if (token + 1 == end)
+                {
+                    // convert array index to number; unchecked access
+                    return ptr->operator[](array_index<BasicJsonType>(*token));
+                }
+                const auto idx = array_index<BasicJsonType>(*token);
+                if (idx >= ptr->m_data.m_value.array->size())
+                {
+                    // the array will be padded in get_unchecked_create
+                    break;
+                }
+                ptr = &(*ptr->m_data.m_value.array)[idx];
+            }
+            else if (ptr->is_null())
+            {
+                // the null value will be converted in get_unchecked_create
+                break;
+            }
+            else
+            {
+                // primitive value with a reference token left
+                throw_unresolved(*token, ptr);
+            }
+        }
+        while (++token != end);
+
+        if (token == end)
+        {
+            return *ptr;
+        }
+        if (token + 1 == end && ptr->is_object())
+        {
+            // insert the missing key where the walk found it belongs
+            return object_insert(*ptr, it, *token);
+        }
+        return get_unchecked_create(ptr, token, end);
+    }
+
+    /*!
+    @brief create the values for the reference tokens from @a first on
+
+    Continues @ref get_unchecked at the first reference token that does not
+    select an existing value. That token changes @a ptr, an existing value (see
+    @ref get_unchecked_rollback); all later tokens only change values created
+    here.
+
+    If the emplace() of the object type finds a member that the lookup in @ref
+    get_unchecked did not find (the two disagree, e.g. for fifo_map), nothing
+    is inserted, and the walk continues with that member as in @ref
+    get_unchecked, which is what basic_json::operator[] does.
+
+    @param[in] ptr    the value the reference token @a first is applied to
+    @param[in] first  the first reference token to resolve (an element of
+                      @ref reference_tokens)
+    @param[in] end    the end of @ref reference_tokens
+
+    @throw parse_error.106   if an array index of an existing array begins with
+                             '0' (only after emplace() found a member, see above)
+    @throw parse_error.109   if an array index of an existing array was not a
+                             number (only after emplace() found a member)
+    @throw out_of_range.404  if an array index is too large for strtoull, or (only
+                             after emplace() found a member) if the JSON pointer
+                             can not be resolved
+    @throw out_of_range.410  if an array index exceeds size_type
+    @throw std::length_error if padding an array exceeds its maximal size
+    @throw std::bad_alloc    if an allocation fails
+    */
+    template<typename BasicJsonType>
+    JSON_HEDLEY_NEVER_INLINE static BasicJsonType& get_unchecked_create(BasicJsonType* ptr, const string_t* first, const string_t* end)
+    {
+        const auto* token = first;
+        while (ptr->is_object())
+        {
+            const auto old_capacity = ptr->container_capacity();
+            const auto inserted = ptr->m_data.m_value.object->emplace(*token, nullptr);
+            if (JSON_HEDLEY_LIKELY(inserted.second))
+            {
+                get_unchecked_rollback<BasicJsonType> rollback(ptr, inserted.first);
+                BasicJsonType& result = create_values(&ptr->set_parent_after_insert(inserted.first->second, old_capacity), token + 1, end);
+                rollback.commit();
+                return result;
+            }
+
+            // nothing was inserted: walk existing values from the member
+            // emplace() found on, like get_unchecked
+            ptr = &inserted.first->second;
+            while (++token != end)
+            {
+                if (ptr->is_object())
+                {
+                    auto& members = *ptr->m_data.m_value.object;
+                    const auto it = object_search(members, *token);
+                    if (!object_search_found(members, it, *token))
+                    {
+                        break;
+                    }
+                    ptr = &it->second;
+                }
+                else if (ptr->is_array())
+                {
+                    if (is_dash(*token))
+                    {
+                        break;
+                    }
+                    const auto idx = array_index<BasicJsonType>(*token);
+                    if (idx >= ptr->m_data.m_value.array->size())
+                    {
+                        break;
+                    }
+                    ptr = &(*ptr->m_data.m_value.array)[idx];
+                }
+                else if (ptr->is_null())
+                {
+                    break;
+                }
+                else
+                {
+                    // primitive value with a reference token left
+                    throw_unresolved(*token, ptr);
+                }
+            }
+            if (token == end)
+            {
+                return *ptr;
+            }
+        }
+
+        get_unchecked_rollback<BasicJsonType> rollback(ptr);
+        BasicJsonType& result = create_values(ptr, token, end);
+        rollback.commit();
+        return result;
+    }
+
+    /*!
+    @brief the loop of @ref get_unchecked_create
+
+    @a ptr is a null value or an array. Every value created here is a fresh
+    one, so every object a key is added to is empty.
+
+    @throw out_of_range.404  if an array index is too large for strtoull
+    @throw out_of_range.410  if an array index exceeds size_type
+    @throw std::length_error if padding an array exceeds its maximal size
+    @throw std::bad_alloc    if an allocation fails
+    */
+    template<typename BasicJsonType>
+    static BasicJsonType& create_values(BasicJsonType* ptr, const string_t* first, const string_t* end)
+    {
+        for (const auto* token = first; token != end; ++token)
+        {
+            const auto& reference_token = *token;
+
             // convert null values to arrays or objects before continuing
             if (ptr->is_null())
             {
-                // check if the reference token is a valid array index, that is
+                // change value to an array for array indices or "-" or to an
-                // a nonempty sequence of digits without a leading '0'
+                // object otherwise; every null value here is a fresh one (see
-                // (cf. RFC 6901, Sect. 4); tokens that could never be a valid
+                // get_unchecked_rollback), so converting it in place leaves
-                // array index (such as "01" or "") are treated as object keys
+                // the same value as assigning an array or object to it
-                const bool nums = !reference_token.empty()
+                if (is_array_index_token(reference_token) || is_dash(reference_token))
-                                  && (reference_token.size() == 1 || reference_token[0] != '0')
-                                  && std::all_of(reference_token.begin(), reference_token.end(),
-                                                 [](const unsigned char x)
                 {
-                    return std::isdigit(x);
+                    ptr->template convert_null_to<typename BasicJsonType::array_t>();
-                });
+                }
-
+                else
-                // change value to an array for array indices or "-" or to object otherwise
+                {
-                *ptr = (nums || reference_token == "-")
+                    ptr->template convert_null_to<typename BasicJsonType::object_t>();
-                       ? detail::value_t::array
+                }
-                       : detail::value_t::object;
             }
 
             if (ptr->is_object())
             {
-                // use unchecked object access
+                // the object is new and empty
-                ptr = &object_member(*ptr, reference_token);
+                ptr = &object_add(*ptr, reference_token);
             }
-            else if (ptr->is_array())
+            else
             {
-                if (reference_token == "-")
+                // only the first value is not created here, and it is a null
+                // value or an array (see get_unchecked_create)
+                JSON_ASSERT(ptr->is_array());
+                if (is_dash(reference_token))
                 {
                     // explicitly treat "-" as index beyond the end
-                    ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
+                    ptr = &array_append(*ptr);
                 }
                 else
                 {
@@ -1020,16 +1463,31 @@ class json_pointer
                     ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
                 }
             }
-            else
-            {
-                // primitive value with a reference token left
-                throw_unresolved(reference_token, ptr);
-            }
         }
 
         return *ptr;
     }
 
+    /// whether @a s is a valid array index, that is a nonempty sequence of
+    /// digits without a leading '0' (cf. RFC 6901, Sect. 4); tokens that could
+    /// never be a valid array index (such as "01" or "") are object keys
+    static bool is_array_index_token(const string_t& s)
+    {
+        const std::size_t size = s.size();
+        if (size == 0 || (size > 1 && s[0] == '0'))
+        {
+            return false;
+        }
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            if (std::isdigit(static_cast<unsigned char>(s[i])) == 0)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /*!
     @throw parse_error.106   if an array index begins with '0'
     @throw parse_error.109   if an array index was not a number

include/nlohmann/detail/view/number.hpp

@@ -19,7 +19,6 @@
 #include <nlohmann/detail/view/macro_scope.hpp>
 #include <nlohmann/detail/view/node.hpp>
 #include <nlohmann/detail/view/scan.hpp>
-#include <nlohmann/detail/view/simd.hpp>
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -104,56 +103,12 @@ NLOHMANN_VIEW_NOINLINE FloatType float_value(const char* first, const node& n)
     return convert_float<FloatType>(first, last, dot, mantissa_end);
 }
 
-#if NLOHMANN_VIEW_VECTOR
-/*!
-@brief the value of the first 16 digits of a run of digits with a point after
-int_digits of them (or none, if int_digits >= 16)
-
-The 17 bytes at p are read at once: the bytes after the point move down by one,
-then pairs, quadruples, and octets of digits are combined by multiplications
-(after simdjson). The bytes [p, p + 32) must be readable. Bytes that are not
-digits (only in a damaged image loaded with image_check::bounds) give a wrong
-value, but no undefined behavior.
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t sixteen_digits(const unsigned char* p, unsigned int_digits) noexcept
-{
-#if NLOHMANN_VIEW_NEON
-    const uint8x16_t low = vld1q_u8(p);
-    const uint8x16_t index = vcombine_u8(vcreate_u8(0x0706050403020100u), vcreate_u8(0x0F0E0D0C0B0A0908u));
-    const uint8x16_t before_point = vcltq_u8(index, vdupq_n_u8(static_cast<std::uint8_t>(int_digits)));
-    const uint8x16_t digits = vsubq_u8(vbslq_u8(before_point, low, vextq_u8(low, vld1q_u8(p + 16), 1)), vdupq_n_u8('0'));
-    const uint16x8_t twos = vpaddlq_u8(vmulq_u8(digits, vreinterpretq_u8_u16(vdupq_n_u16(0x010A))));
-    const uint32x4_t fours = vpaddlq_u16(vmulq_u16(twos, vreinterpretq_u16_u32(vdupq_n_u32(0x00010064))));
-    const uint64x2_t eights = vpaddlq_u32(vmulq_u32(fours, vreinterpretq_u32_u64(vdupq_n_u64(0x0000000100002710u))));
-    return (vgetq_lane_u64(eights, 0) * 100000000u) + vgetq_lane_u64(eights, 1);
-#else
-    // NOLINTBEGIN(portability-simd-intrinsics)
-    const __m128i low = _mm_loadu_si128(static_cast<const __m128i*>(static_cast<const void*>(p))); // NOLINT(bugprone-casting-through-void)
-    const __m128i high = _mm_loadu_si128(static_cast<const __m128i*>(static_cast<const void*>(p + 16))); // NOLINT(bugprone-casting-through-void)
-    const __m128i before_point = _mm_cmpgt_epi8(_mm_set1_epi8(static_cast<char>(int_digits)), _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15));
-    const __m128i moved = _mm_or_si128(_mm_srli_si128(low, 1), _mm_slli_si128(high, 15));
-    const __m128i digits = _mm_sub_epi8(_mm_or_si128(_mm_and_si128(before_point, low), _mm_andnot_si128(before_point, moved)), _mm_set1_epi8('0'));
-    // (16-bit lanes: SSE2 has no multiply-add of bytes)
-    const __m128i tens = _mm_setr_epi16(10, 1, 10, 1, 10, 1, 10, 1);
-    const __m128i twos = _mm_packs_epi32(_mm_madd_epi16(_mm_unpacklo_epi8(digits, _mm_setzero_si128()), tens),
-                                         _mm_madd_epi16(_mm_unpackhi_epi8(digits, _mm_setzero_si128()), tens));
-    const __m128i fours = _mm_madd_epi16(twos, _mm_setr_epi16(100, 1, 100, 1, 100, 1, 100, 1));
-    const __m128i eights = _mm_madd_epi16(_mm_packs_epi32(fours, fours), _mm_setr_epi16(10000, 1, 10000, 1, 10000, 1, 10000, 1));
-    const auto upper = static_cast<std::uint32_t>(_mm_cvtsi128_si32(eights));
-    const auto lower = static_cast<std::uint32_t>(_mm_cvtsi128_si32(_mm_srli_si128(eights, 4)));
-    // NOLINTEND(portability-simd-intrinsics)
-    return (std::uint64_t{upper} * 100000000u) + lower;
-#endif
-}
-#endif
-
 /*!
 @brief the digits of a float token with at most 19 digits, from its layout
 
 The digit layout recorded while parsing says where the integer digits, the
 fraction digits, and the exponent are, so the digits are read eight at a
-time without scanning (with SIMD, a token of 16 to 19 digits sixteen at a
+time without scanning.
-time).
 
 @param[in] p  first character of the token
 @param[in] e  end of the token
@@ -163,34 +118,15 @@ NLOHMANN_VIEW_ALWAYS_INLINE float_significand layout_decimal(const unsigned char
 {
     const bool negative = *p == '-';
     p += negative ? 1 : 0;
-    std::uint64_t w = 0;
+    std::uint64_t w = parse_upto19(p, int_digits, limit);
+    p += int_digits;
     std::int64_t q = 0;
-#if NLOHMANN_VIEW_VECTOR
+    if (frac_digits != 0)
-    const unsigned count = int_digits + frac_digits;
-    if (count >= 16 && limit - p >= 32)
     {
-        // (the point, if any, follows the integer digits; the digits after
+        w = (w * int_pow10(frac_digits)) + parse_upto19(p + 1, frac_digits, limit);
-        // the first 16 are at most three)
+        p += 1 + frac_digits;
-        w = sixteen_digits(p, int_digits);
-        for (unsigned i = 16; i < count; ++i)
-        {
-            w = (w * 10) + static_cast<std::uint64_t>(p[i + (i >= int_digits ? 1 : 0)] - '0');
-        }
-        p += count + (frac_digits != 0 ? 1 : 0);
         q = -static_cast<std::int64_t>(frac_digits);
     }
-    else /* NOLINT(readability/braces) */
-#endif
-    {
-        w = parse_upto19(p, int_digits, limit);
-        p += int_digits;
-        if (frac_digits != 0)
-        {
-            w = (w * int_pow10(frac_digits)) + parse_upto19(p + 1, frac_digits, limit);
-            p += 1 + frac_digits;
-            q = -static_cast<std::int64_t>(frac_digits);
-        }
-    }
     if (p != e)
     {
         // [eE][+-]digits; huge exponents saturate (the parser rejected
@@ -225,22 +161,12 @@ NLOHMANN_VIEW_ALWAYS_INLINE float_significand layout_decimal(const unsigned char
 The result is correctly rounded by the lexer's conversion
 (detail::decimal_to_float(): Clinger's fast path where both operands are
 exact, else the Eisel-Lemire algorithm, which needs no fallback for up to 19
-digits), so it is the value parse() produces. Tokens of 16 or more digits go
+digits), so it is the value parse() produces.
-to Eisel-Lemire directly: the fast path takes few of them (none of 17 digits),
-and its check is a branch that data like GeoJSON coordinates mispredicts.
 */
 template<typename FloatType>
 NLOHMANN_VIEW_ALWAYS_INLINE FloatType layout_float(const unsigned char* p, const unsigned char* e, unsigned int_digits, unsigned frac_digits, const unsigned char* limit) noexcept
 {
-    const float_significand d = layout_decimal(p, e, int_digits, frac_digits, limit);
+    return decimal_to_float<FloatType>(layout_decimal(p, e, int_digits, frac_digits, limit));
-    if (int_digits + frac_digits >= 16)
-    {
-        using format = ieee_binary_format<std::numeric_limits<FloatType>::digits>;
-        native_float_t<FloatType> value{};
-        float_from_bits(eisel_lemire<format>(d.exponent, d.w) | (d.negative ? (std::uint64_t{1} << format::sign_bit()) : 0u), value);
-        return value;
-    }
-    return decimal_to_float<FloatType>(d);
 }
 
 /// the value of a float set by an edit: its token (the shortest round-trip
@@ -259,80 +185,6 @@ NLOHMANN_VIEW_NOINLINE FloatType edited_float(const char* token, const node& n)
     return float_value<FloatType>(token, n);
 }
 
-#if NLOHMANN_VIEW_VECTOR
-/// eisel_lemire() for the token w * 10^q of coordinate_float()
-template<typename Format>
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t coordinate_bits(std::int64_t q, std::uint64_t w, Format /*format*/) noexcept
-{
-    return eisel_lemire<Format>(q, w);
-}
-
-/*!
-@brief (binary64) eisel_lemire() without the cases that tokens of 16 or 17
-digits with 5 or more after the point cannot reach: a value of 0, a
-subnormal, an infinity, or a tie (q < -4)
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t coordinate_bits(std::int64_t q, std::uint64_t w, ieee_binary_format<53> format) noexcept
-{
-    if (NLOHMANN_VIEW_UNLIKELY(w == 0 || q > -5))
-    {
-        return eisel_lemire<ieee_binary_format<53>>(q, w);
-    }
-    static_cast<void>(format);
-    const int lz = count_leading_zeros(w);
-    const std::uint64_t normalized = w << static_cast<unsigned>(lz);
-    const auto index = static_cast<std::size_t>(2 * (q - pow5_128_smallest_power));
-    const uint128_parts product = full_multiplication(normalized, pow5_128()[index]);
-    std::uint64_t high = product.high;
-    if (NLOHMANN_VIEW_UNLIKELY((high & 0x1FFu) == 0x1FFu))
-    {
-        // (the lower bits may carry into the result)
-        const std::uint64_t second = full_multiplication(normalized, pow5_128()[index + 1]).high;
-        high += product.low + second < product.low ? 1u : 0u;
-    }
-    const auto upperbit = static_cast<unsigned>(high >> 63u);
-    std::uint64_t mantissa = high >> (upperbit + 9);
-    auto power2 = static_cast<std::uint64_t>(((217706 * q) >> 16) + 63 + static_cast<std::int64_t>(upperbit) - lz + 1023);
-    mantissa = (mantissa + (mantissa & 1u)) >> 1u;
-    const bool carry = mantissa >= (std::uint64_t{2} << 52u);
-    mantissa = carry ? (std::uint64_t{1} << 52u) : mantissa;
-    power2 += carry ? 1u : 0u;
-    return (mantissa & ~(std::uint64_t{1} << 52u)) | (power2 << 52u);
-}
-
-/*!
-@brief (binary32 and binary64) the value of a float token of the source with
-16 or 17 digits, a point, and no exponent, the shape of most coordinates
-written with full precision; whether the token of n has this shape
-
-These tokens skip the general layout of layout_decimal(): no digits beyond
-the 17th, no exponent (and Eisel-Lemire directly, as in layout_float()).
-*/
-template<typename FloatType>
-NLOHMANN_VIEW_ALWAYS_INLINE bool coordinate_float(const document_data& d, const node& n, FloatType& value) noexcept
-{
-    const unsigned int_digits = n.extra & 0xFFu;
-    const unsigned frac_digits = n.extra >> 8u;
-    const unsigned count = int_digits + frac_digits;
-    const auto* const first = reinterpret_cast<const unsigned char*>(d.src + n.off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
-    const unsigned negative = first[0] == '-' ? 1u : 0u;
-    if (count - 16u > 1u || frac_digits == 0 || n.len != negative + count + 1 || d.size - n.off < 33)
-    {
-        return false;
-    }
-    const unsigned char* const digits = first + negative;
-    const std::uint64_t w = sixteen_digits(digits, int_digits);
-    // (the 17th digit follows the point)
-    const std::uint64_t w17 = (w * 10) + static_cast<std::uint64_t>(digits[17] - '0');
-    using format = ieee_binary_format<std::numeric_limits<FloatType>::digits>;
-    native_float_t<FloatType> result{};
-    float_from_bits(coordinate_bits(-static_cast<std::int64_t>(frac_digits), count == 17 ? w17 : w, format{}) | (static_cast<std::uint64_t>(negative) << format::sign_bit()), result);
-    value = result;
-    return true;
-}
-
-#endif
-
 /// the value of the float token of a node, as parse() converts it; floats and
 /// doubles with at most 19 digits are converted from the digit layout
 template<typename FloatType>
@@ -348,13 +200,6 @@ FloatType float_value(const document_data& d, const node& n)
 template<typename FloatType>
 FloatType float_value(const document_data& d, const node& n, std::true_type /*binary32 or binary64*/)
 {
-#if NLOHMANN_VIEW_VECTOR
-    FloatType value {};
-    if (coordinate_float(d, n, value))
-    {
-        return value;
-    }
-#endif
     const unsigned int_digits = n.extra & 0xFFu;
     const unsigned frac_digits = n.extra >> 8u;
     if (NLOHMANN_VIEW_LIKELY(int_digits + frac_digits <= 19)) // (255 marks "many")

include/nlohmann/detail/view/serializer.hpp

@@ -14,9 +14,7 @@
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <cstring> // memcpy, memset
-#include <functional> // less
 #include <limits> // numeric_limits
-#include <memory> // unique_ptr
 #include <type_traits> // integral_constant
 #include <vector> // vector
 
@@ -386,127 +384,6 @@ struct depth_counter<false>
     }
 };
 
-/*!
-@brief where the double x nearest to a token w * 10^q lies, for 10^15 <= w <
-10^17 and -17 <= q <= -1 (Eisel-Lemire, then a fixed-point position)
-
-dump() writes the shortest decimal in the rounding interval of x (the closest
-one if there are several, see zmij::to_shortest()). Its digits are those of a
-multiple of 10^g of the token's last digit, with g = dec_exp + 1 - q for x's
-decimal exponent dec_exp: the multiple of 10^g nearest to x if it lies in the
-interval (at most one does), else the multiple of 10^(g - 1) nearest to x
-(see token_digits_1() and token_digits_2()). For g <= 0, the token itself is
-in the interval.
-
-The position is exact in a 64-bit fixed-point number with 56 bits after the
-point (of the token's last digit): x / 10^q = 2c * 5^-q / 2^t for x = c * 2^e2
-and t = q + 1 - e2, with at most 56 bits after the point here, and |x / 10^q -
-w| is at most half the spacing of the doubles, below 12 units. So only the low
-64 bits of 2c * 5^-q are needed. c and e2 come from Eisel-Lemire's product
-directly (as eisel_lemire() rounds it: no tie is possible for q < -4, and its
-second product is added where it can carry into the result).
-
-@param[out] offset  x / 10^q - w + 32, with 56 bits after the point
-@param[out] radius  half the spacing of the doubles at x, likewise (+ 1 if
-                    the interval is closed)
-@return g; 3 if the digits are not decided here (a power of two, whose
-        interval is not symmetric, or out of range)
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE int locate_token(std::uint64_t w, int q, std::uint64_t& offset, std::uint64_t& radius) noexcept
-{
-    const int lz = count_leading_zeros(w);
-    const std::uint64_t normalized = w << static_cast<unsigned>(lz);
-    const auto index = static_cast<std::size_t>(2 * (q - pow5_128_smallest_power));
-    const uint128_parts product = full_multiplication(normalized, pow5_128()[index]);
-    std::uint64_t high = product.high;
-    if (NLOHMANN_VIEW_UNLIKELY((high & 0x1FFu) == 0x1FFu))
-    {
-        // (as eisel_lemire(): the lower bits may carry into the result)
-        const std::uint64_t second = full_multiplication(normalized, pow5_128()[index + 1]).high;
-        high += product.low + second < product.low ? 1u : 0u;
-    }
-    const auto upperbit = static_cast<unsigned>(high >> 63u);
-    const std::uint64_t mantissa = high >> (upperbit + 9);
-    const std::uint64_t c = (mantissa + (mantissa & 1u)) >> 1u;
-    // e2 as eisel_lemire() computes the exponent (log2(10) ~ 217706 / 2^16)
-    const int e2 = static_cast<int>((217706 * static_cast<std::int64_t>(q)) >> 16) + 63 + static_cast<int>(upperbit) - lz - 52;
-    const int t = q + 1 - e2;
-    const int g = ((e2 * 315653) >> 20) + 1 - q; // (dec_exp as in zmij::to_shortest(), for a regular x)
-    static const std::array<std::uint64_t, 17> fives = {{1u, 5u, 25u, 125u, 625u, 3125u, 15625u, 78125u, 390625u, 1953125u, 9765625u, 48828125u, 244140625u, 1220703125u, 6103515625u, 30517578125u, 152587890625u}};
-    const std::uint64_t five = fives[static_cast<std::size_t>(-q)]; // 5^-q
-    const unsigned s = static_cast<unsigned>(56 - t) & 63u;
-    offset = ((2 * c * five) << s) - (w << 56u) + (std::uint64_t{32} << 56u);
-    radius = (five << s) + ((c & 1u) == 0 ? 1u : 0u);
-    // (c = 2^52: a power of two; c = 2^53: rounded up to one. With 8 to 16
-    // fraction digits, as the batch's tokens have, t is in [15, 40] and g at
-    // most 2. x lies halfway between two candidates only if its distance from
-    // the token is a whole unit (g == 2) or a half (g == 1): such tokens are
-    // left to the full conversion)
-    const bool decided = c - ((std::uint64_t{1} << 52u) + 1) < (std::uint64_t{1} << 52u) - 1
-                         && (offset & ((std::uint64_t{1} << 55u) - 1)) != 0;
-    return decided ? g : 3;
-}
-
-/// the distance of a position (see locate_token()) from the biased point 32
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t biased_distance(std::uint64_t position) noexcept
-{
-    constexpr std::uint64_t center = std::uint64_t{32} << 56u;
-    return position >= center ? position - center : center - position;
-}
-
-/*!
-@brief (g == 1) the digits dump() writes for a token, from the position of its
-double (see locate_token()): the multiple of 10 nearest to x if it is in the
-interval, else w rounded to x (an exact tie between two candidates, like
-754570942.33984373, whose double is 754570942.33984375, is excluded by
-locate_token())
-
-With |x - w| at most the radius, which is below half the spacing of the
-candidates, the multiple of 10 nearest to x is w - r10 or the one above it.
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t token_digits_1(std::uint64_t w, std::uint64_t offset, std::uint64_t radius, std::uint64_t r10) noexcept
-{
-    constexpr std::uint64_t one = std::uint64_t{1} << 56u;
-    const std::uint64_t from = offset + (r10 * one); // x - (w - r10) (+ 32)
-    const bool up = from > 37 * one;                  // (nearer to the multiple above)
-    const bool shorter = biased_distance(from - (up ? 10 * one : 0)) < radius;
-    const std::uint64_t a = w - r10 + (up ? 10u : 0u);
-    const std::uint64_t b = w + ((offset + (one / 2)) >> 56u) - 32;                // w rounded to x
-    return shorter ? a : b;
-}
-
-/*!
-@brief (g == 2) the digits dump() writes for a token, as token_digits_1(): the
-multiple of 100 nearest to x if it is in the interval, else the multiple of 10
-nearest to x
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t token_digits_2(std::uint64_t w, std::uint64_t offset, std::uint64_t radius, std::uint64_t r10, std::uint64_t r100) noexcept
-{
-    constexpr std::uint64_t one = std::uint64_t{1} << 56u;
-    const std::uint64_t from = offset + (r100 * one);
-    const bool up = from > 82 * one;
-    const bool shorter = biased_distance(from - (up ? 100 * one : 0)) < radius;
-    const std::uint64_t a = w - r100 + (up ? 100u : 0u);
-    // x - (w - r10), in [-12, 21]: the multiple of 10 nearest to x is that one,
-    // or one or two above, or one below
-    const std::uint64_t y = offset + (r10 * one);
-    const std::uint64_t steps = (y > 37 * one ? 1u : 0u) + (y > 47 * one ? 1u : 0u);
-    const bool down = y < 27 * one;
-    const std::uint64_t b = w - r10 + (10 * steps) - (down ? 10u : 0u);
-    return shorter ? a : b;
-}
-
-/// the four ASCII digits of x < 10^4, the first in the lowest byte (as
-/// little-endian memory holds them)
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t four_digit_text(std::uint32_t x) noexcept
-{
-    const std::uint32_t ab = (x * 5243u) >> 19u; // x / 100
-    std::uint32_t v = ab | ((x - (ab * 100u)) << 16u);
-    const std::uint32_t a = ((v * 103u) >> 10u) & 0x000F000Fu; // / 10 per 16-bit lane
-    v = a | ((v - (a * 10u)) << 8u);
-    return v + 0x30303030u;
-}
-
 /// how the view's dump() writes a value
 struct dump_style
 {
@@ -834,7 +711,6 @@ class view_serializer
         std::array<frame, 32> buffer; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
         std::vector<frame> heap;
         small_stack<frame> stack(buffer.data(), buffer.size(), heap);
-        float_batch batch;
         const char* const src = m_doc.src;
         const char* const src_end = src + m_doc.size;
         char* w = m_out.cursor();
@@ -974,7 +850,7 @@ class view_serializer
                     else if (enabled(fast_double::value))
                     {
                         room(64);
-                        w = write_double_ahead(w, src, n, batch);
+                        w = write_double_at(w, *n);
                     }
                     else
                     {
@@ -999,20 +875,6 @@ class view_serializer
                 case value_t::array:
                 {
                     const bool object = n->kind == node_kind::object;
-                    // (read-only documents, compact output) a pair of floats,
-                    // like the coordinates of GeoJSON, without a frame
-                    if (enabled(!Editable && !Pretty && !SourceNumbers && fast_double::value) && n->next == 3 && n->len == 2
-                            && n[1].kind == node_kind::number_float && n[2].kind == node_kind::number_float)
-                    {
-                        room(2 * 64);
-                        *w++ = '[';
-                        w = write_double_ahead(w, src, n + 1, batch);
-                        *w++ = ',';
-                        w = write_double_ahead(w, src, n + 2, batch);
-                        *w++ = ']';
-                        n += 2; // (the element before the next node)
-                        break;
-                    }
                     room(8);
                     if (n->len == 0)
                     {
@@ -1122,254 +984,6 @@ class view_serializer
         }
     }
 
-    /// (float_batch) the mark of digits whose rounding carried beyond the
-    /// token's last four (see mark())
-    static constexpr std::uint64_t carried() noexcept
-    {
-        return std::uint64_t{1} << 63u;
-    }
-
-    /// floats of 16 or 17 digits ahead of the walk, converted together (see
-    /// convert_ahead()), with their digits as mark() keeps them
-    struct float_batch
-    {
-        static constexpr std::size_t capacity() noexcept
-        {
-            return 256;
-        }
-        /// (on the heap, allocated by the first conversion: a frame of more
-        /// than a page made every dump of a small document slower)
-        struct entries
-        {
-            std::array<const node*, 256> at; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-            std::array<std::uint64_t, 256> digits; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        };
-        std::unique_ptr<entries> storage{};
-        const node** at = nullptr;
-        std::uint64_t* digits = nullptr;
-        std::size_t count = 0;
-        std::size_t next = 0;
-        const node* scanned = nullptr; ///< where the last scan of the node array ended
-    };
-
-    /// (doubles) the float at n as dump() writes it, at w (64 bytes of room):
-    /// from the batch if it holds n
-    NLOHMANN_VIEW_ALWAYS_INLINE char* write_double_ahead(char* w, const char* src, const node* n, float_batch& batch)
-    {
-#if NLOHMANN_VIEW_VECTOR && NLOHMANN_VIEW_LITTLE_ENDIAN
-        // (digits 0: not written by the batch; carried(): rounding carried
-        // beyond the last four digits)
-        if (batch.next != batch.count && batch.at[batch.next] == n && batch.digits[batch.next] - 1 < carried() - 1)
-        {
-            return write_token_digits(w, src, *n, batch.digits[batch.next++]);
-        }
-        return write_double_beside(w, n, batch);
-#else
-        static_cast<void>(src);
-        static_cast<void>(batch);
-        return write_double_at(w, *n);
-#endif
-    }
-
-#if NLOHMANN_VIEW_VECTOR && NLOHMANN_VIEW_LITTLE_ENDIAN
-    /// write_double_ahead() for a float that is not the batch's next one (out
-    /// of line: the walk is faster with less code in its loop)
-    NLOHMANN_VIEW_NOINLINE char* write_double_beside(char* w, const node* n, float_batch& batch)
-    {
-        // (an editable document's walk can skip nodes of the array)
-        const std::less<const node*> before{}; // NOLINT(modernize-use-transparent-functors) C++11 has no std::less<>
-        while (batch.next != batch.count && before(batch.at[batch.next], n))
-        {
-            ++batch.next;
-        }
-        if ((batch.next != batch.count && batch.at[batch.next] == n) || convert_ahead(n, batch))
-        {
-            const std::uint64_t digits = batch.digits[batch.next++];
-            if ((digits & carried()) != 0)
-            {
-                return write_carried_digits(w, *n, digits & ~carried());
-            }
-            if (digits != 0)
-            {
-                return write_token_digits(w, m_doc.src, *n, digits);
-            }
-        }
-        return write_double_at(w, *n);
-    }
-
-    /*!
-    @brief convert the floats of 16 or 17 digits among the next nodes of the
-    array at once; whether n is the first of them
-
-    Such tokens (like the coordinates of GeoJSON, written with 17 digits) are
-    written as the token with its last four digits replaced
-    (write_token_digits()). Each step (the digits, locate_token(),
-    token_digits_1/2()) is a long chain of dependent operations; one loop per
-    step over many floats lets the processor overlap the floats, which it does
-    not across the steps of one float (on Apple M1, one loop for the digits and
-    locate_token() made the dump of canada.json 12 % slower). Each node of the array
-    is scanned once; a node that the walk does not reach in order (in an
-    editable document) is written without the batch.
-    */
-    NLOHMANN_VIEW_NOINLINE bool convert_ahead(const node* n, float_batch& batch)
-    {
-        const std::less<const node*> before{}; // NOLINT(modernize-use-transparent-functors) C++11 has no std::less<>
-        const node* const last = m_doc.nodes + m_doc.node_count;
-        if (before(n, batch.scanned) || before(n, m_doc.nodes) || !before(n, last))
-        {
-            return false;
-        }
-        const char* const src = m_doc.src;
-        const char* const src_end = src + m_doc.size;
-        const node* const stop = last - n > 1024 ? n + 1024 : last;
-        batch.count = 0;
-        batch.next = 0;
-        // the digits of each token (and its last four from the text)
-        std::array<std::uint64_t, 256> digits;     // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<int, 256> exponent;             // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint32_t, 256> last_four;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        const node* p = n;
-        if (!batch.storage)
-        {
-            batch.storage.reset(new typename float_batch::entries); // NOLINT(cppcoreguidelines-owning-memory,modernize-make-unique): C++11
-            batch.at = batch.storage->at.data();
-            batch.digits = batch.storage->digits.data();
-        }
-        for (; p != stop && batch.count != float_batch::capacity(); ++p)
-        {
-            // a token of the source: 16 or 17 digits, at least 8 after the
-            // point, no exponent, 32 bytes to read
-            const unsigned frac_digits = p->extra >> 8u;
-            const unsigned int_digits = p->extra & 0xFFu;
-            const unsigned count = int_digits + frac_digits;
-            if (p->kind == node_kind::number_float && (p->flags & node_flags::storage) == 0
-                    && count - 16u <= 1u && frac_digits >= 8 && src_end - (src + p->off) >= 33)
-            {
-                const auto* const token = reinterpret_cast<const unsigned char*>(src + p->off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
-                const unsigned sign = token[0] == '-' ? 1 : 0;
-                const unsigned char* const first = token + sign;
-                const std::uint64_t w = sixteen_digits(first, int_digits);
-                // (the 17th digit follows the point; a token with an exponent
-                // gets digits outside the range of locate_token(), and is not
-                // written by the batch. A token 0.xxx with 16 significant
-                // digits is: its double is written as "0." and its digits too)
-                const std::uint64_t w17 = (w * 10) + static_cast<std::uint64_t>(first[17] - '0');
-                const std::size_t i = batch.count++;
-                batch.at[i] = p;
-                if (p->len != sign + count + 1)
-                {
-                    digits[i] = 0;
-                }
-                else
-                {
-                    digits[i] = count == 17 ? w17 : w;
-                }
-                exponent[i] = -static_cast<int>(frac_digits);
-                // (byte 0: the last digit, byte 1: the last two, bits 16-29: the last four)
-                std::uint32_t four = 0;
-                std::memcpy(&four, token + p->len - 4, 4);
-                four -= 0x30303030u;
-                const std::uint32_t pairs = ((four & 0x0F0F0F0Fu) * 2561u) >> 8u; // (byte 0, 2: the pairs)
-                last_four[i] = (four >> 24u) | ((pairs >> 16u & 0xFFu) << 8u) | ((((pairs & 0x00FF00FFu) * 6553601u) >> 16u) << 16u);
-            }
-        }
-        batch.scanned = p;
-        // the position of each double, and the floats of either kind
-        std::array<std::uint64_t, 256> offset; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint64_t, 256> radius; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint8_t, 256> kind_1;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint8_t, 256> kind_2;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::size_t count_1 = 0;
-        std::size_t count_2 = 0;
-        for (std::size_t i = 0; i != batch.count; ++i)
-        {
-            const std::uint64_t w = digits[i];
-            // (the range excludes the values of bytes that are not digits, only
-            // in a damaged image loaded with image_check::bounds)
-            const int g = w - 1000000000000000u < 99000000000000000u ? locate_token(w, exponent[i], offset[i], radius[i]) : 3;
-            batch.digits[i] = g <= 0 ? (last_four[i] >> 16u) + 1 : 0;
-            kind_1[count_1] = static_cast<std::uint8_t>(i);
-            count_1 += g == 1 ? 1 : 0;
-            kind_2[count_2] = static_cast<std::uint8_t>(i);
-            count_2 += g == 2 ? 1 : 0;
-        }
-        // the digits to write, in one loop per kind (see mark())
-        for (std::size_t k = 0; k != count_1; ++k)
-        {
-            const std::size_t i = kind_1[k];
-            const std::uint64_t s = token_digits_1(digits[i], offset[i], radius[i], last_four[i] & 0xFFu);
-            batch.digits[i] = mark(digits[i], s, last_four[i] >> 16u);
-        }
-        for (std::size_t k = 0; k != count_2; ++k)
-        {
-            const std::size_t i = kind_2[k];
-            const std::uint64_t s = token_digits_2(digits[i], offset[i], radius[i], last_four[i] & 0xFFu, (last_four[i] >> 8u) & 0xFFu);
-            batch.digits[i] = mark(digits[i], s, last_four[i] >> 16u);
-        }
-        return batch.count != 0 && batch.at[0] == n;
-    }
-
-    /*!
-    @brief a float token of 16 or 17 digits as dump() writes it, at w (64 bytes
-    of room), from the digits of its double (see locate_token()) whose
-    rounding carried beyond the token's last four digits
-
-    (like 43.42027299999999 -> 43.420273): the digits go to the writer of
-    Zmij's results as its 15 or 16 leading digits and one more, which omits
-    the trailing zeros.
-    */
-    NLOHMANN_VIEW_NOINLINE char* write_carried_digits(char* w, const node& n, std::uint64_t digits) const noexcept
-    {
-        const int exponent = -(n.extra >> 8u);
-        const std::uint64_t leading = digits / 10;
-        const auto last = static_cast<unsigned char>(digits - (leading * 10));
-        const bool seventeen = digits >= 10000000000000000u;
-        *w = '-';
-        w += m_doc.src[n.off] == '-' ? 1 : 0;
-        return ::nlohmann::detail::dtoa_impl::write_shortest(w, seventeen ? ::nlohmann::detail::zmij::shortest_decimal{leading, exponent, last, last != 0}
-                : ::nlohmann::detail::zmij::shortest_decimal{digits, exponent - 1, 0, false});
-    }
-
-    /// the digits s of a token with the digits w and the last four digits
-    /// r4, as the batch keeps them: the new last four digits + 1 (only those
-    /// are written over the token's), or s marked if it differs from w beyond
-    /// them (0 stays for a float the batch does not write)
-    static std::uint64_t mark(std::uint64_t w, std::uint64_t s, std::uint64_t r4) noexcept
-    {
-        const std::uint64_t last = s - (w - r4);
-        return last < 10000 ? last + 1 : s | carried();
-    }
-
-    /*!
-    @brief a float token of 16 or 17 digits as dump() writes it, at w (64 bytes
-    of room): the token with its last four digits replaced by digits - 1 (see
-    mark(); the others are the token's), and without trailing zeros after the
-    point, but one
-    */
-    char* write_token_digits(char* w, const char* src, const node& n, std::uint64_t digits)
-    {
-        const char* const token = src + n.off;
-        std::memcpy(w, token, 32);
-        char* const end = w + n.len;
-        const std::uint32_t last = four_digit_text(static_cast<std::uint32_t>(digits - 1));
-        std::memcpy(end - 4, &last, 4);
-        // (the token's text before the new digits, from the source: reading
-        // the output back would wait for the stores)
-        std::uint64_t before = 0;
-        std::memcpy(&before, token + n.len - 12, 8);
-        const std::uint32_t last_zeros = last ^ 0x30303030u;
-        const std::uint64_t before_zeros = before ^ 0x3030303030303030u;
-        if (NLOHMANN_VIEW_UNLIKELY(last_zeros == 0 && before_zeros == 0))
-        {
-            return write_double_at(w, n); // (twelve or more trailing zeros)
-        }
-        const unsigned zeros = last_zeros != 0 ? (static_cast<unsigned>(count_leading_zeros(last_zeros)) / 8) - 4
-                               : 4 + (static_cast<unsigned>(count_leading_zeros(before_zeros)) / 8);
-        const unsigned frac_digits = n.extra >> 8u;
-        return end - (zeros < frac_digits ? zeros : frac_digits - 1);
-    }
-#endif
-
     /// a float node as dump() writes it
     void write_float_node(const node& n)
     {

single_include/nlohmann/json.hpp

@@ -24064,7 +24064,7 @@ NLOHMANN_JSON_NAMESPACE_END
 
 
 
-#include <algorithm> // all_of, copy
+#include <algorithm> // copy
 #include <array> // array
 #include <cctype> // isdigit
 #include <cerrno> // errno, ERANGE
@@ -24072,9 +24072,11 @@ NLOHMANN_JSON_NAMESPACE_END
 #include <cstdint> // uint64_t
 #include <cstdlib> // strtoull
 #include <cstring> // memchr, memcmp, memcpy
+#include <functional> // less
 #ifndef JSON_NO_IO
     #include <iosfwd> // ostream
 #endif  // JSON_NO_IO
+#include <iterator> // next
 #include <limits> // max
 #include <string> // string
 #include <utility> // move
@@ -24088,6 +24090,8 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/meta/type_traits.hpp>
 
+// #include <nlohmann/detail/meta/void_t.hpp>
+
 // #include <nlohmann/detail/string_concat.hpp>
 
 // #include <nlohmann/detail/string_escape.hpp>
@@ -24198,6 +24202,26 @@ JSON_HEDLEY_ALWAYS_INLINE array_index_status parse_array_index(const StringType&
     return array_index_status::ok;
 }
 
+/// whether two keys of type @a StringType are equivalent under @a Compare
+/// exactly if they are equal: std::less<StringType> and std::less<>
+template<typename Compare, typename StringType>
+struct is_less_comparator : std::false_type {};
+
+template<typename StringType>
+struct is_less_comparator<std::less<StringType>, StringType> : std::true_type {};
+
+template<typename StringType>
+struct is_less_comparator<std::less<void>, StringType> : std::true_type {};
+
+/// whether the objects of type @a ObjectType find a key of type @a StringType
+/// exactly if it equals a stored key
+template<typename ObjectType, typename StringType, typename = void>
+struct finds_equal_keys : std::false_type {};
+
+template<typename ObjectType, typename StringType>
+struct finds_equal_keys<ObjectType, StringType, void_t<typename ObjectType::key_compare, typename ObjectType::key_type>>
+    : conjunction<is_less_comparator<typename ObjectType::key_compare, StringType>, std::is_same<typename ObjectType::key_type, StringType>> {};
+
 }  // namespace detail
 
 /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
@@ -24653,6 +24677,228 @@ class json_pointer
         return object_member_impl(object, key, detail::priority_tag<1> {});
     }
 
+    /// @brief append a null value to @a array, like operator[] with the size of @a array
+    template<typename BasicJsonType>
+    static BasicJsonType& array_append(BasicJsonType& array)
+    {
+        auto& elements = *array.m_data.m_value.array;
+        const auto old_capacity = array.container_capacity();
+        elements.emplace_back();
+        return array.set_parent_after_insert(elements.back(), old_capacity);
+    }
+
+    /// @brief add @a key, which is missing, to @a object
+    template<typename BasicJsonType>
+    static auto object_add_impl(BasicJsonType& object, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(object.m_data.m_value.object->emplace(key, nullptr), std::declval<BasicJsonType&>())
+    {
+        const auto old_capacity = object.container_capacity();
+        const auto it = object.m_data.m_value.object->emplace(key, nullptr).first;
+        return object.set_parent_after_insert(it->second, old_capacity);
+    }
+
+    template<typename BasicJsonType>
+    static BasicJsonType& object_add_impl(BasicJsonType& object, const string_t& key, detail::priority_tag<0> /*unused*/)
+    {
+        return object.operator[](key);
+    }
+
+    template<typename BasicJsonType>
+    static BasicJsonType& object_add(BasicJsonType& object, const string_t& key)
+    {
+        return object_add_impl(object, key, detail::priority_tag<1> {});
+    }
+
+    /// @brief search @a key in @a members: the result is where the key is or,
+    /// for objects that can insert at a position (std::map), where it belongs
+    template<typename ObjectType>
+    static auto object_search_impl(ObjectType& members, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(members.key_comp()(key, members.lower_bound(key)->first), members.lower_bound(key))
+    {
+        return members.lower_bound(key);
+    }
+
+    template<typename ObjectType>
+    static auto object_search_impl(ObjectType& members, const string_t& key, detail::priority_tag<0> /*unused*/)
+    -> decltype(members.find(key))
+    {
+        return members.find(key);
+    }
+
+    template<typename ObjectType>
+    static auto object_search(ObjectType& members, const string_t& key)
+    -> decltype(object_search_impl(members, key, detail::priority_tag<1> {}))
+    {
+        return object_search_impl(members, key, detail::priority_tag<1> {});
+    }
+
+    /// @brief whether @a it, the result of @ref object_search for @a key, points to @a key
+    ///
+    /// With std::less, the key at the lower bound is equivalent to @a key
+    /// exactly if it is equal to it, and comparing for equality is cheaper.
+    template<typename ObjectType, typename Iterator,
+             detail::enable_if_t<detail::finds_equal_keys<ObjectType, string_t>::value, int> = 0>
+    static auto object_search_found_impl(ObjectType& members, const Iterator& it, const string_t& key, detail::priority_tag<2> /*unused*/)
+    -> decltype(members.lower_bound(key), it->first == key)
+    {
+        return it != members.end() && it->first == key;
+    }
+
+    template<typename ObjectType, typename Iterator>
+    static auto object_search_found_impl(ObjectType& members, const Iterator& it, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(members.key_comp()(key, it->first), members.lower_bound(key), bool())
+    {
+        return it != members.end() && !members.key_comp()(key, it->first);
+    }
+
+    template<typename ObjectType, typename Iterator>
+    static bool object_search_found_impl(ObjectType& members, const Iterator& it, const string_t& /*key*/, detail::priority_tag<0> /*unused*/)
+    {
+        return it != members.end();
+    }
+
+    template<typename ObjectType, typename Iterator>
+    static bool object_search_found(ObjectType& members, const Iterator& it, const string_t& key)
+    {
+        return object_search_found_impl(members, it, key, detail::priority_tag<2> {});
+    }
+
+    /// @brief insert @a key, which is missing, into @a object at @a it, the
+    /// result of @ref object_search for @a key
+    template<typename BasicJsonType, typename Iterator>
+    static auto object_insert_impl(BasicJsonType& object, const Iterator& it, const string_t& key, detail::priority_tag<1> /*unused*/)
+    -> decltype(object.m_data.m_value.object->emplace_hint(it, key, nullptr), std::declval<BasicJsonType&>())
+    {
+        const auto old_capacity = object.container_capacity();
+        const auto pos = object.m_data.m_value.object->emplace_hint(it, key, nullptr);
+        return object.set_parent_after_insert(pos->second, old_capacity);
+    }
+
+    template<typename BasicJsonType, typename Iterator>
+    static BasicJsonType& object_insert_impl(BasicJsonType& object, const Iterator& /*it*/, const string_t& key, detail::priority_tag<0> /*unused*/)
+    {
+        return object_add(object, key);
+    }
+
+    template<typename BasicJsonType, typename Iterator>
+    static BasicJsonType& object_insert(BasicJsonType& object, const Iterator& it, const string_t& key)
+    {
+        return object_insert_impl(object, it, key, detail::priority_tag<1> {});
+    }
+
+    /*!
+    @brief undoes the change @ref get_unchecked_create made to an existing value
+
+    @ref get_unchecked walks existing values without changing them. At the
+    first reference token that does not select an existing value, @ref
+    get_unchecked_create makes exactly one change to an existing value: it
+    converts a null value, inserts a key into an object, or grows an array.
+    Everything it creates afterwards lies below that change. If a later step
+    throws, the destructor of this guard reverts that one change, which
+    removes everything created after it, so the value is left as it was
+    (strong exception safety). The guard needs no try/catch and therefore also
+    compiles with JSON_NOEXCEPTION.
+
+    Reverting the change must not throw, as it happens in a destructor. It
+    erases the inserted member by its iterator (no key is converted or
+    compared, nothing is allocated), erases the added elements at the end of
+    the array, or swaps the null value back. This holds for std::map,
+    std::vector, ordered_map, and every object_t, array_t, and
+    json_base_class_t whose erase() and move operations do not throw.
+    Between recording and reverting, nothing is inserted into or erased from
+    the object or array, so the iterator stays valid.
+    */
+    template<typename BasicJsonType>
+    class get_unchecked_rollback
+    {
+      public:
+        using object_iterator = typename BasicJsonType::object_t::iterator;
+
+        /// record that @a member was inserted into the object @a value
+        get_unchecked_rollback(BasicJsonType* value, const object_iterator& member)
+            : m_value(value)
+            , m_member(member)
+            , m_change(change::key_inserted)
+        {}
+
+        /// record the change that the next reference token makes to the null value or array @a value
+        explicit get_unchecked_rollback(BasicJsonType* value)
+            : m_value(value)
+        {
+            if (value->is_null())
+            {
+                // keep the null value (with its base class and positions) and
+                // continue with a fresh null value in its place, which is what
+                // assigning an array or object to it would have left there
+                m_saved_null.swap(*value);
+                m_change = change::null_converted;
+            }
+            else
+            {
+                JSON_ASSERT(value->is_array());
+                m_old_size = value->m_data.m_value.array->size();
+                m_change = change::array_grown;
+            }
+        }
+
+        get_unchecked_rollback(const get_unchecked_rollback&) = delete;
+        get_unchecked_rollback(get_unchecked_rollback&&) = delete;
+        get_unchecked_rollback& operator=(const get_unchecked_rollback&) = delete;
+        get_unchecked_rollback& operator=(get_unchecked_rollback&&) = delete;
+
+        ~get_unchecked_rollback()
+        {
+            if (JSON_HEDLEY_UNLIKELY(m_change != change::none))
+            {
+                undo();
+            }
+        }
+
+        /// keep the change
+        void commit() noexcept
+        {
+            m_change = change::none;
+        }
+
+      private:
+        JSON_HEDLEY_NEVER_INLINE void undo() noexcept
+        {
+            switch (m_change)
+            {
+                case change::null_converted:
+                    // the values created since go away with m_saved_null
+                    m_value->swap(m_saved_null);
+                    break;
+                case change::key_inserted:
+                    m_value->m_data.m_value.object->erase(m_member);
+                    break;
+                case change::array_grown:
+                {
+                    auto& elements = *m_value->m_data.m_value.array;
+                    elements.resize(m_old_size);
+                    break;
+                }
+                case change::none:
+                default:
+                    break;
+            }
+        }
+
+        enum class change
+        {
+            none,
+            null_converted,
+            key_inserted,
+            array_grown
+        };
+
+        BasicJsonType* m_value;
+        object_iterator m_member {};
+        typename BasicJsonType::size_type m_old_size = 0;
+        change m_change = change::none;
+        BasicJsonType m_saved_null {};
+    };
+
   JSON_PRIVATE_UNLESS_TESTED:
     json_pointer top() const
     {
@@ -25036,47 +25282,245 @@ class json_pointer
 
     Complexity: Linear in the length of the JSON pointer.
 
-    @throw parse_error.106   if an array index begins with '0'
+    Exception safety: Strong guarantee. This function walks existing values
-    @throw parse_error.109   if an array index was not a number
+    until the first reference token that does not select one. If that is the
-    @throw out_of_range.404  if the JSON pointer can not be resolved
+    last reference token, inserting the key into the object or growing the
+    array is strongly exception safe by itself; any other change is made by
+    @ref get_unchecked_create, which undoes it if a later step throws.
+
+    @throw parse_error.106   if an array index of an existing array begins with '0'
+    @throw parse_error.109   if an array index of an existing array was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved, or if an
+                             array index is too large for strtoull
+    @throw out_of_range.410  if an array index exceeds size_type
+    @throw std::length_error if padding an array exceeds its maximal size
+    @throw std::bad_alloc    if an allocation fails
     */
     template<typename BasicJsonType>
     BasicJsonType& get_unchecked(BasicJsonType* ptr) const
     {
-        for (const auto& reference_token : reference_tokens)
+        const auto* token = reference_tokens.data();
+        const auto* const end = token + reference_tokens.size();
+        if (token == end)
         {
+            return *ptr;
+        }
+        if (ptr->is_null())
+        {
+            // the null value is converted to an array or an object
+            return get_unchecked_create(ptr, token, end);
+        }
+
+        // walk existing values; the walk itself inserts nothing, which keeps
+        // the loop fast (insertions are done below or in get_unchecked_create)
+        typename BasicJsonType::object_t::iterator it;
+        do
+        {
+            if (ptr->is_object())
+            {
+                auto& members = *ptr->m_data.m_value.object;
+                it = object_search(members, *token);
+                if (!object_search_found(members, it, *token))
+                {
+                    // the key is inserted below or in get_unchecked_create
+                    break;
+                }
+                ptr = &it->second;
+            }
+            else if (ptr->is_array())
+            {
+                if (is_dash(*token))
+                {
+                    if (token + 1 == end)
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        return array_append(*ptr);
+                    }
+                    // an element will be appended in get_unchecked_create
+                    break;
+                }
+                if (token + 1 == end)
+                {
+                    // convert array index to number; unchecked access
+                    return ptr->operator[](array_index<BasicJsonType>(*token));
+                }
+                const auto idx = array_index<BasicJsonType>(*token);
+                if (idx >= ptr->m_data.m_value.array->size())
+                {
+                    // the array will be padded in get_unchecked_create
+                    break;
+                }
+                ptr = &(*ptr->m_data.m_value.array)[idx];
+            }
+            else if (ptr->is_null())
+            {
+                // the null value will be converted in get_unchecked_create
+                break;
+            }
+            else
+            {
+                // primitive value with a reference token left
+                throw_unresolved(*token, ptr);
+            }
+        }
+        while (++token != end);
+
+        if (token == end)
+        {
+            return *ptr;
+        }
+        if (token + 1 == end && ptr->is_object())
+        {
+            // insert the missing key where the walk found it belongs
+            return object_insert(*ptr, it, *token);
+        }
+        return get_unchecked_create(ptr, token, end);
+    }
+
+    /*!
+    @brief create the values for the reference tokens from @a first on
+
+    Continues @ref get_unchecked at the first reference token that does not
+    select an existing value. That token changes @a ptr, an existing value (see
+    @ref get_unchecked_rollback); all later tokens only change values created
+    here.
+
+    If the emplace() of the object type finds a member that the lookup in @ref
+    get_unchecked did not find (the two disagree, e.g. for fifo_map), nothing
+    is inserted, and the walk continues with that member as in @ref
+    get_unchecked, which is what basic_json::operator[] does.
+
+    @param[in] ptr    the value the reference token @a first is applied to
+    @param[in] first  the first reference token to resolve (an element of
+                      @ref reference_tokens)
+    @param[in] end    the end of @ref reference_tokens
+
+    @throw parse_error.106   if an array index of an existing array begins with
+                             '0' (only after emplace() found a member, see above)
+    @throw parse_error.109   if an array index of an existing array was not a
+                             number (only after emplace() found a member)
+    @throw out_of_range.404  if an array index is too large for strtoull, or (only
+                             after emplace() found a member) if the JSON pointer
+                             can not be resolved
+    @throw out_of_range.410  if an array index exceeds size_type
+    @throw std::length_error if padding an array exceeds its maximal size
+    @throw std::bad_alloc    if an allocation fails
+    */
+    template<typename BasicJsonType>
+    JSON_HEDLEY_NEVER_INLINE static BasicJsonType& get_unchecked_create(BasicJsonType* ptr, const string_t* first, const string_t* end)
+    {
+        const auto* token = first;
+        while (ptr->is_object())
+        {
+            const auto old_capacity = ptr->container_capacity();
+            const auto inserted = ptr->m_data.m_value.object->emplace(*token, nullptr);
+            if (JSON_HEDLEY_LIKELY(inserted.second))
+            {
+                get_unchecked_rollback<BasicJsonType> rollback(ptr, inserted.first);
+                BasicJsonType& result = create_values(&ptr->set_parent_after_insert(inserted.first->second, old_capacity), token + 1, end);
+                rollback.commit();
+                return result;
+            }
+
+            // nothing was inserted: walk existing values from the member
+            // emplace() found on, like get_unchecked
+            ptr = &inserted.first->second;
+            while (++token != end)
+            {
+                if (ptr->is_object())
+                {
+                    auto& members = *ptr->m_data.m_value.object;
+                    const auto it = object_search(members, *token);
+                    if (!object_search_found(members, it, *token))
+                    {
+                        break;
+                    }
+                    ptr = &it->second;
+                }
+                else if (ptr->is_array())
+                {
+                    if (is_dash(*token))
+                    {
+                        break;
+                    }
+                    const auto idx = array_index<BasicJsonType>(*token);
+                    if (idx >= ptr->m_data.m_value.array->size())
+                    {
+                        break;
+                    }
+                    ptr = &(*ptr->m_data.m_value.array)[idx];
+                }
+                else if (ptr->is_null())
+                {
+                    break;
+                }
+                else
+                {
+                    // primitive value with a reference token left
+                    throw_unresolved(*token, ptr);
+                }
+            }
+            if (token == end)
+            {
+                return *ptr;
+            }
+        }
+
+        get_unchecked_rollback<BasicJsonType> rollback(ptr);
+        BasicJsonType& result = create_values(ptr, token, end);
+        rollback.commit();
+        return result;
+    }
+
+    /*!
+    @brief the loop of @ref get_unchecked_create
+
+    @a ptr is a null value or an array. Every value created here is a fresh
+    one, so every object a key is added to is empty.
+
+    @throw out_of_range.404  if an array index is too large for strtoull
+    @throw out_of_range.410  if an array index exceeds size_type
+    @throw std::length_error if padding an array exceeds its maximal size
+    @throw std::bad_alloc    if an allocation fails
+    */
+    template<typename BasicJsonType>
+    static BasicJsonType& create_values(BasicJsonType* ptr, const string_t* first, const string_t* end)
+    {
+        for (const auto* token = first; token != end; ++token)
+        {
+            const auto& reference_token = *token;
+
             // convert null values to arrays or objects before continuing
             if (ptr->is_null())
             {
-                // check if the reference token is a valid array index, that is
+                // change value to an array for array indices or "-" or to an
-                // a nonempty sequence of digits without a leading '0'
+                // object otherwise; every null value here is a fresh one (see
-                // (cf. RFC 6901, Sect. 4); tokens that could never be a valid
+                // get_unchecked_rollback), so converting it in place leaves
-                // array index (such as "01" or "") are treated as object keys
+                // the same value as assigning an array or object to it
-                const bool nums = !reference_token.empty()
+                if (is_array_index_token(reference_token) || is_dash(reference_token))
-                                  && (reference_token.size() == 1 || reference_token[0] != '0')
-                                  && std::all_of(reference_token.begin(), reference_token.end(),
-                                                 [](const unsigned char x)
                 {
-                    return std::isdigit(x);
+                    ptr->template convert_null_to<typename BasicJsonType::array_t>();
-                });
+                }
-
+                else
-                // change value to an array for array indices or "-" or to object otherwise
+                {
-                *ptr = (nums || reference_token == "-")
+                    ptr->template convert_null_to<typename BasicJsonType::object_t>();
-                       ? detail::value_t::array
+                }
-                       : detail::value_t::object;
             }
 
             if (ptr->is_object())
             {
-                // use unchecked object access
+                // the object is new and empty
-                ptr = &object_member(*ptr, reference_token);
+                ptr = &object_add(*ptr, reference_token);
             }
-            else if (ptr->is_array())
+            else
             {
-                if (reference_token == "-")
+                // only the first value is not created here, and it is a null
+                // value or an array (see get_unchecked_create)
+                JSON_ASSERT(ptr->is_array());
+                if (is_dash(reference_token))
                 {
                     // explicitly treat "-" as index beyond the end
-                    ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
+                    ptr = &array_append(*ptr);
                 }
                 else
                 {
@@ -25084,16 +25528,31 @@ class json_pointer
                     ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
                 }
             }
-            else
-            {
-                // primitive value with a reference token left
-                throw_unresolved(reference_token, ptr);
-            }
         }
 
         return *ptr;
     }
 
+    /// whether @a s is a valid array index, that is a nonempty sequence of
+    /// digits without a leading '0' (cf. RFC 6901, Sect. 4); tokens that could
+    /// never be a valid array index (such as "01" or "") are object keys
+    static bool is_array_index_token(const string_t& s)
+    {
+        const std::size_t size = s.size();
+        if (size == 0 || (size > 1 && s[0] == '0'))
+        {
+            return false;
+        }
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            if (std::isdigit(static_cast<unsigned char>(s[i])) == 0)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /*!
     @throw parse_error.106   if an array index begins with '0'
     @throw parse_error.109   if an array index was not a number

single_include/nlohmann/json_view.hpp

@@ -4682,8 +4682,6 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/view/scan.hpp>
 
-// #include <nlohmann/detail/view/simd.hpp>
-
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -4768,56 +4766,12 @@ NLOHMANN_VIEW_NOINLINE FloatType float_value(const char* first, const node& n)
     return convert_float<FloatType>(first, last, dot, mantissa_end);
 }
 
-#if NLOHMANN_VIEW_VECTOR
-/*!
-@brief the value of the first 16 digits of a run of digits with a point after
-int_digits of them (or none, if int_digits >= 16)
-
-The 17 bytes at p are read at once: the bytes after the point move down by one,
-then pairs, quadruples, and octets of digits are combined by multiplications
-(after simdjson). The bytes [p, p + 32) must be readable. Bytes that are not
-digits (only in a damaged image loaded with image_check::bounds) give a wrong
-value, but no undefined behavior.
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t sixteen_digits(const unsigned char* p, unsigned int_digits) noexcept
-{
-#if NLOHMANN_VIEW_NEON
-    const uint8x16_t low = vld1q_u8(p);
-    const uint8x16_t index = vcombine_u8(vcreate_u8(0x0706050403020100u), vcreate_u8(0x0F0E0D0C0B0A0908u));
-    const uint8x16_t before_point = vcltq_u8(index, vdupq_n_u8(static_cast<std::uint8_t>(int_digits)));
-    const uint8x16_t digits = vsubq_u8(vbslq_u8(before_point, low, vextq_u8(low, vld1q_u8(p + 16), 1)), vdupq_n_u8('0'));
-    const uint16x8_t twos = vpaddlq_u8(vmulq_u8(digits, vreinterpretq_u8_u16(vdupq_n_u16(0x010A))));
-    const uint32x4_t fours = vpaddlq_u16(vmulq_u16(twos, vreinterpretq_u16_u32(vdupq_n_u32(0x00010064))));
-    const uint64x2_t eights = vpaddlq_u32(vmulq_u32(fours, vreinterpretq_u32_u64(vdupq_n_u64(0x0000000100002710u))));
-    return (vgetq_lane_u64(eights, 0) * 100000000u) + vgetq_lane_u64(eights, 1);
-#else
-    // NOLINTBEGIN(portability-simd-intrinsics)
-    const __m128i low = _mm_loadu_si128(static_cast<const __m128i*>(static_cast<const void*>(p))); // NOLINT(bugprone-casting-through-void)
-    const __m128i high = _mm_loadu_si128(static_cast<const __m128i*>(static_cast<const void*>(p + 16))); // NOLINT(bugprone-casting-through-void)
-    const __m128i before_point = _mm_cmpgt_epi8(_mm_set1_epi8(static_cast<char>(int_digits)), _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15));
-    const __m128i moved = _mm_or_si128(_mm_srli_si128(low, 1), _mm_slli_si128(high, 15));
-    const __m128i digits = _mm_sub_epi8(_mm_or_si128(_mm_and_si128(before_point, low), _mm_andnot_si128(before_point, moved)), _mm_set1_epi8('0'));
-    // (16-bit lanes: SSE2 has no multiply-add of bytes)
-    const __m128i tens = _mm_setr_epi16(10, 1, 10, 1, 10, 1, 10, 1);
-    const __m128i twos = _mm_packs_epi32(_mm_madd_epi16(_mm_unpacklo_epi8(digits, _mm_setzero_si128()), tens),
-                                         _mm_madd_epi16(_mm_unpackhi_epi8(digits, _mm_setzero_si128()), tens));
-    const __m128i fours = _mm_madd_epi16(twos, _mm_setr_epi16(100, 1, 100, 1, 100, 1, 100, 1));
-    const __m128i eights = _mm_madd_epi16(_mm_packs_epi32(fours, fours), _mm_setr_epi16(10000, 1, 10000, 1, 10000, 1, 10000, 1));
-    const auto upper = static_cast<std::uint32_t>(_mm_cvtsi128_si32(eights));
-    const auto lower = static_cast<std::uint32_t>(_mm_cvtsi128_si32(_mm_srli_si128(eights, 4)));
-    // NOLINTEND(portability-simd-intrinsics)
-    return (std::uint64_t{upper} * 100000000u) + lower;
-#endif
-}
-#endif
-
 /*!
 @brief the digits of a float token with at most 19 digits, from its layout
 
 The digit layout recorded while parsing says where the integer digits, the
 fraction digits, and the exponent are, so the digits are read eight at a
-time without scanning (with SIMD, a token of 16 to 19 digits sixteen at a
+time without scanning.
-time).
 
 @param[in] p  first character of the token
 @param[in] e  end of the token
@@ -4827,34 +4781,15 @@ NLOHMANN_VIEW_ALWAYS_INLINE float_significand layout_decimal(const unsigned char
 {
     const bool negative = *p == '-';
     p += negative ? 1 : 0;
-    std::uint64_t w = 0;
+    std::uint64_t w = parse_upto19(p, int_digits, limit);
+    p += int_digits;
     std::int64_t q = 0;
-#if NLOHMANN_VIEW_VECTOR
+    if (frac_digits != 0)
-    const unsigned count = int_digits + frac_digits;
-    if (count >= 16 && limit - p >= 32)
     {
-        // (the point, if any, follows the integer digits; the digits after
+        w = (w * int_pow10(frac_digits)) + parse_upto19(p + 1, frac_digits, limit);
-        // the first 16 are at most three)
+        p += 1 + frac_digits;
-        w = sixteen_digits(p, int_digits);
-        for (unsigned i = 16; i < count; ++i)
-        {
-            w = (w * 10) + static_cast<std::uint64_t>(p[i + (i >= int_digits ? 1 : 0)] - '0');
-        }
-        p += count + (frac_digits != 0 ? 1 : 0);
         q = -static_cast<std::int64_t>(frac_digits);
     }
-    else /* NOLINT(readability/braces) */
-#endif
-    {
-        w = parse_upto19(p, int_digits, limit);
-        p += int_digits;
-        if (frac_digits != 0)
-        {
-            w = (w * int_pow10(frac_digits)) + parse_upto19(p + 1, frac_digits, limit);
-            p += 1 + frac_digits;
-            q = -static_cast<std::int64_t>(frac_digits);
-        }
-    }
     if (p != e)
     {
         // [eE][+-]digits; huge exponents saturate (the parser rejected
@@ -4889,22 +4824,12 @@ NLOHMANN_VIEW_ALWAYS_INLINE float_significand layout_decimal(const unsigned char
 The result is correctly rounded by the lexer's conversion
 (detail::decimal_to_float(): Clinger's fast path where both operands are
 exact, else the Eisel-Lemire algorithm, which needs no fallback for up to 19
-digits), so it is the value parse() produces. Tokens of 16 or more digits go
+digits), so it is the value parse() produces.
-to Eisel-Lemire directly: the fast path takes few of them (none of 17 digits),
-and its check is a branch that data like GeoJSON coordinates mispredicts.
 */
 template<typename FloatType>
 NLOHMANN_VIEW_ALWAYS_INLINE FloatType layout_float(const unsigned char* p, const unsigned char* e, unsigned int_digits, unsigned frac_digits, const unsigned char* limit) noexcept
 {
-    const float_significand d = layout_decimal(p, e, int_digits, frac_digits, limit);
+    return decimal_to_float<FloatType>(layout_decimal(p, e, int_digits, frac_digits, limit));
-    if (int_digits + frac_digits >= 16)
-    {
-        using format = ieee_binary_format<std::numeric_limits<FloatType>::digits>;
-        native_float_t<FloatType> value{};
-        float_from_bits(eisel_lemire<format>(d.exponent, d.w) | (d.negative ? (std::uint64_t{1} << format::sign_bit()) : 0u), value);
-        return value;
-    }
-    return decimal_to_float<FloatType>(d);
 }
 
 /// the value of a float set by an edit: its token (the shortest round-trip
@@ -4923,80 +4848,6 @@ NLOHMANN_VIEW_NOINLINE FloatType edited_float(const char* token, const node& n)
     return float_value<FloatType>(token, n);
 }
 
-#if NLOHMANN_VIEW_VECTOR
-/// eisel_lemire() for the token w * 10^q of coordinate_float()
-template<typename Format>
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t coordinate_bits(std::int64_t q, std::uint64_t w, Format /*format*/) noexcept
-{
-    return eisel_lemire<Format>(q, w);
-}
-
-/*!
-@brief (binary64) eisel_lemire() without the cases that tokens of 16 or 17
-digits with 5 or more after the point cannot reach: a value of 0, a
-subnormal, an infinity, or a tie (q < -4)
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t coordinate_bits(std::int64_t q, std::uint64_t w, ieee_binary_format<53> format) noexcept
-{
-    if (NLOHMANN_VIEW_UNLIKELY(w == 0 || q > -5))
-    {
-        return eisel_lemire<ieee_binary_format<53>>(q, w);
-    }
-    static_cast<void>(format);
-    const int lz = count_leading_zeros(w);
-    const std::uint64_t normalized = w << static_cast<unsigned>(lz);
-    const auto index = static_cast<std::size_t>(2 * (q - pow5_128_smallest_power));
-    const uint128_parts product = full_multiplication(normalized, pow5_128()[index]);
-    std::uint64_t high = product.high;
-    if (NLOHMANN_VIEW_UNLIKELY((high & 0x1FFu) == 0x1FFu))
-    {
-        // (the lower bits may carry into the result)
-        const std::uint64_t second = full_multiplication(normalized, pow5_128()[index + 1]).high;
-        high += product.low + second < product.low ? 1u : 0u;
-    }
-    const auto upperbit = static_cast<unsigned>(high >> 63u);
-    std::uint64_t mantissa = high >> (upperbit + 9);
-    auto power2 = static_cast<std::uint64_t>(((217706 * q) >> 16) + 63 + static_cast<std::int64_t>(upperbit) - lz + 1023);
-    mantissa = (mantissa + (mantissa & 1u)) >> 1u;
-    const bool carry = mantissa >= (std::uint64_t{2} << 52u);
-    mantissa = carry ? (std::uint64_t{1} << 52u) : mantissa;
-    power2 += carry ? 1u : 0u;
-    return (mantissa & ~(std::uint64_t{1} << 52u)) | (power2 << 52u);
-}
-
-/*!
-@brief (binary32 and binary64) the value of a float token of the source with
-16 or 17 digits, a point, and no exponent, the shape of most coordinates
-written with full precision; whether the token of n has this shape
-
-These tokens skip the general layout of layout_decimal(): no digits beyond
-the 17th, no exponent (and Eisel-Lemire directly, as in layout_float()).
-*/
-template<typename FloatType>
-NLOHMANN_VIEW_ALWAYS_INLINE bool coordinate_float(const document_data& d, const node& n, FloatType& value) noexcept
-{
-    const unsigned int_digits = n.extra & 0xFFu;
-    const unsigned frac_digits = n.extra >> 8u;
-    const unsigned count = int_digits + frac_digits;
-    const auto* const first = reinterpret_cast<const unsigned char*>(d.src + n.off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
-    const unsigned negative = first[0] == '-' ? 1u : 0u;
-    if (count - 16u > 1u || frac_digits == 0 || n.len != negative + count + 1 || d.size - n.off < 33)
-    {
-        return false;
-    }
-    const unsigned char* const digits = first + negative;
-    const std::uint64_t w = sixteen_digits(digits, int_digits);
-    // (the 17th digit follows the point)
-    const std::uint64_t w17 = (w * 10) + static_cast<std::uint64_t>(digits[17] - '0');
-    using format = ieee_binary_format<std::numeric_limits<FloatType>::digits>;
-    native_float_t<FloatType> result{};
-    float_from_bits(coordinate_bits(-static_cast<std::int64_t>(frac_digits), count == 17 ? w17 : w, format{}) | (static_cast<std::uint64_t>(negative) << format::sign_bit()), result);
-    value = result;
-    return true;
-}
-
-#endif
-
 /// the value of the float token of a node, as parse() converts it; floats and
 /// doubles with at most 19 digits are converted from the digit layout
 template<typename FloatType>
@@ -5012,13 +4863,6 @@ FloatType float_value(const document_data& d, const node& n)
 template<typename FloatType>
 FloatType float_value(const document_data& d, const node& n, std::true_type /*binary32 or binary64*/)
 {
-#if NLOHMANN_VIEW_VECTOR
-    FloatType value {};
-    if (coordinate_float(d, n, value))
-    {
-        return value;
-    }
-#endif
     const unsigned int_digits = n.extra & 0xFFu;
     const unsigned frac_digits = n.extra >> 8u;
     if (NLOHMANN_VIEW_LIKELY(int_digits + frac_digits <= 19)) // (255 marks "many")
@@ -6588,9 +6432,7 @@ NLOHMANN_JSON_NAMESPACE_END
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <cstring> // memcpy, memset
-#include <functional> // less
 #include <limits> // numeric_limits
-#include <memory> // unique_ptr
 #include <type_traits> // integral_constant
 #include <vector> // vector
 
@@ -6965,127 +6807,6 @@ struct depth_counter<false>
     }
 };
 
-/*!
-@brief where the double x nearest to a token w * 10^q lies, for 10^15 <= w <
-10^17 and -17 <= q <= -1 (Eisel-Lemire, then a fixed-point position)
-
-dump() writes the shortest decimal in the rounding interval of x (the closest
-one if there are several, see zmij::to_shortest()). Its digits are those of a
-multiple of 10^g of the token's last digit, with g = dec_exp + 1 - q for x's
-decimal exponent dec_exp: the multiple of 10^g nearest to x if it lies in the
-interval (at most one does), else the multiple of 10^(g - 1) nearest to x
-(see token_digits_1() and token_digits_2()). For g <= 0, the token itself is
-in the interval.
-
-The position is exact in a 64-bit fixed-point number with 56 bits after the
-point (of the token's last digit): x / 10^q = 2c * 5^-q / 2^t for x = c * 2^e2
-and t = q + 1 - e2, with at most 56 bits after the point here, and |x / 10^q -
-w| is at most half the spacing of the doubles, below 12 units. So only the low
-64 bits of 2c * 5^-q are needed. c and e2 come from Eisel-Lemire's product
-directly (as eisel_lemire() rounds it: no tie is possible for q < -4, and its
-second product is added where it can carry into the result).
-
-@param[out] offset  x / 10^q - w + 32, with 56 bits after the point
-@param[out] radius  half the spacing of the doubles at x, likewise (+ 1 if
-                    the interval is closed)
-@return g; 3 if the digits are not decided here (a power of two, whose
-        interval is not symmetric, or out of range)
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE int locate_token(std::uint64_t w, int q, std::uint64_t& offset, std::uint64_t& radius) noexcept
-{
-    const int lz = count_leading_zeros(w);
-    const std::uint64_t normalized = w << static_cast<unsigned>(lz);
-    const auto index = static_cast<std::size_t>(2 * (q - pow5_128_smallest_power));
-    const uint128_parts product = full_multiplication(normalized, pow5_128()[index]);
-    std::uint64_t high = product.high;
-    if (NLOHMANN_VIEW_UNLIKELY((high & 0x1FFu) == 0x1FFu))
-    {
-        // (as eisel_lemire(): the lower bits may carry into the result)
-        const std::uint64_t second = full_multiplication(normalized, pow5_128()[index + 1]).high;
-        high += product.low + second < product.low ? 1u : 0u;
-    }
-    const auto upperbit = static_cast<unsigned>(high >> 63u);
-    const std::uint64_t mantissa = high >> (upperbit + 9);
-    const std::uint64_t c = (mantissa + (mantissa & 1u)) >> 1u;
-    // e2 as eisel_lemire() computes the exponent (log2(10) ~ 217706 / 2^16)
-    const int e2 = static_cast<int>((217706 * static_cast<std::int64_t>(q)) >> 16) + 63 + static_cast<int>(upperbit) - lz - 52;
-    const int t = q + 1 - e2;
-    const int g = ((e2 * 315653) >> 20) + 1 - q; // (dec_exp as in zmij::to_shortest(), for a regular x)
-    static const std::array<std::uint64_t, 17> fives = {{1u, 5u, 25u, 125u, 625u, 3125u, 15625u, 78125u, 390625u, 1953125u, 9765625u, 48828125u, 244140625u, 1220703125u, 6103515625u, 30517578125u, 152587890625u}};
-    const std::uint64_t five = fives[static_cast<std::size_t>(-q)]; // 5^-q
-    const unsigned s = static_cast<unsigned>(56 - t) & 63u;
-    offset = ((2 * c * five) << s) - (w << 56u) + (std::uint64_t{32} << 56u);
-    radius = (five << s) + ((c & 1u) == 0 ? 1u : 0u);
-    // (c = 2^52: a power of two; c = 2^53: rounded up to one. With 8 to 16
-    // fraction digits, as the batch's tokens have, t is in [15, 40] and g at
-    // most 2. x lies halfway between two candidates only if its distance from
-    // the token is a whole unit (g == 2) or a half (g == 1): such tokens are
-    // left to the full conversion)
-    const bool decided = c - ((std::uint64_t{1} << 52u) + 1) < (std::uint64_t{1} << 52u) - 1
-                         && (offset & ((std::uint64_t{1} << 55u) - 1)) != 0;
-    return decided ? g : 3;
-}
-
-/// the distance of a position (see locate_token()) from the biased point 32
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t biased_distance(std::uint64_t position) noexcept
-{
-    constexpr std::uint64_t center = std::uint64_t{32} << 56u;
-    return position >= center ? position - center : center - position;
-}
-
-/*!
-@brief (g == 1) the digits dump() writes for a token, from the position of its
-double (see locate_token()): the multiple of 10 nearest to x if it is in the
-interval, else w rounded to x (an exact tie between two candidates, like
-754570942.33984373, whose double is 754570942.33984375, is excluded by
-locate_token())
-
-With |x - w| at most the radius, which is below half the spacing of the
-candidates, the multiple of 10 nearest to x is w - r10 or the one above it.
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t token_digits_1(std::uint64_t w, std::uint64_t offset, std::uint64_t radius, std::uint64_t r10) noexcept
-{
-    constexpr std::uint64_t one = std::uint64_t{1} << 56u;
-    const std::uint64_t from = offset + (r10 * one); // x - (w - r10) (+ 32)
-    const bool up = from > 37 * one;                  // (nearer to the multiple above)
-    const bool shorter = biased_distance(from - (up ? 10 * one : 0)) < radius;
-    const std::uint64_t a = w - r10 + (up ? 10u : 0u);
-    const std::uint64_t b = w + ((offset + (one / 2)) >> 56u) - 32;                // w rounded to x
-    return shorter ? a : b;
-}
-
-/*!
-@brief (g == 2) the digits dump() writes for a token, as token_digits_1(): the
-multiple of 100 nearest to x if it is in the interval, else the multiple of 10
-nearest to x
-*/
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t token_digits_2(std::uint64_t w, std::uint64_t offset, std::uint64_t radius, std::uint64_t r10, std::uint64_t r100) noexcept
-{
-    constexpr std::uint64_t one = std::uint64_t{1} << 56u;
-    const std::uint64_t from = offset + (r100 * one);
-    const bool up = from > 82 * one;
-    const bool shorter = biased_distance(from - (up ? 100 * one : 0)) < radius;
-    const std::uint64_t a = w - r100 + (up ? 100u : 0u);
-    // x - (w - r10), in [-12, 21]: the multiple of 10 nearest to x is that one,
-    // or one or two above, or one below
-    const std::uint64_t y = offset + (r10 * one);
-    const std::uint64_t steps = (y > 37 * one ? 1u : 0u) + (y > 47 * one ? 1u : 0u);
-    const bool down = y < 27 * one;
-    const std::uint64_t b = w - r10 + (10 * steps) - (down ? 10u : 0u);
-    return shorter ? a : b;
-}
-
-/// the four ASCII digits of x < 10^4, the first in the lowest byte (as
-/// little-endian memory holds them)
-NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t four_digit_text(std::uint32_t x) noexcept
-{
-    const std::uint32_t ab = (x * 5243u) >> 19u; // x / 100
-    std::uint32_t v = ab | ((x - (ab * 100u)) << 16u);
-    const std::uint32_t a = ((v * 103u) >> 10u) & 0x000F000Fu; // / 10 per 16-bit lane
-    v = a | ((v - (a * 10u)) << 8u);
-    return v + 0x30303030u;
-}
-
 /// how the view's dump() writes a value
 struct dump_style
 {
@@ -7413,7 +7134,6 @@ class view_serializer
         std::array<frame, 32> buffer; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
         std::vector<frame> heap;
         small_stack<frame> stack(buffer.data(), buffer.size(), heap);
-        float_batch batch;
         const char* const src = m_doc.src;
         const char* const src_end = src + m_doc.size;
         char* w = m_out.cursor();
@@ -7553,7 +7273,7 @@ class view_serializer
                     else if (enabled(fast_double::value))
                     {
                         room(64);
-                        w = write_double_ahead(w, src, n, batch);
+                        w = write_double_at(w, *n);
                     }
                     else
                     {
@@ -7578,20 +7298,6 @@ class view_serializer
                 case value_t::array:
                 {
                     const bool object = n->kind == node_kind::object;
-                    // (read-only documents, compact output) a pair of floats,
-                    // like the coordinates of GeoJSON, without a frame
-                    if (enabled(!Editable && !Pretty && !SourceNumbers && fast_double::value) && n->next == 3 && n->len == 2
-                            && n[1].kind == node_kind::number_float && n[2].kind == node_kind::number_float)
-                    {
-                        room(2 * 64);
-                        *w++ = '[';
-                        w = write_double_ahead(w, src, n + 1, batch);
-                        *w++ = ',';
-                        w = write_double_ahead(w, src, n + 2, batch);
-                        *w++ = ']';
-                        n += 2; // (the element before the next node)
-                        break;
-                    }
                     room(8);
                     if (n->len == 0)
                     {
@@ -7701,254 +7407,6 @@ class view_serializer
         }
     }
 
-    /// (float_batch) the mark of digits whose rounding carried beyond the
-    /// token's last four (see mark())
-    static constexpr std::uint64_t carried() noexcept
-    {
-        return std::uint64_t{1} << 63u;
-    }
-
-    /// floats of 16 or 17 digits ahead of the walk, converted together (see
-    /// convert_ahead()), with their digits as mark() keeps them
-    struct float_batch
-    {
-        static constexpr std::size_t capacity() noexcept
-        {
-            return 256;
-        }
-        /// (on the heap, allocated by the first conversion: a frame of more
-        /// than a page made every dump of a small document slower)
-        struct entries
-        {
-            std::array<const node*, 256> at; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-            std::array<std::uint64_t, 256> digits; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        };
-        std::unique_ptr<entries> storage{};
-        const node** at = nullptr;
-        std::uint64_t* digits = nullptr;
-        std::size_t count = 0;
-        std::size_t next = 0;
-        const node* scanned = nullptr; ///< where the last scan of the node array ended
-    };
-
-    /// (doubles) the float at n as dump() writes it, at w (64 bytes of room):
-    /// from the batch if it holds n
-    NLOHMANN_VIEW_ALWAYS_INLINE char* write_double_ahead(char* w, const char* src, const node* n, float_batch& batch)
-    {
-#if NLOHMANN_VIEW_VECTOR && NLOHMANN_VIEW_LITTLE_ENDIAN
-        // (digits 0: not written by the batch; carried(): rounding carried
-        // beyond the last four digits)
-        if (batch.next != batch.count && batch.at[batch.next] == n && batch.digits[batch.next] - 1 < carried() - 1)
-        {
-            return write_token_digits(w, src, *n, batch.digits[batch.next++]);
-        }
-        return write_double_beside(w, n, batch);
-#else
-        static_cast<void>(src);
-        static_cast<void>(batch);
-        return write_double_at(w, *n);
-#endif
-    }
-
-#if NLOHMANN_VIEW_VECTOR && NLOHMANN_VIEW_LITTLE_ENDIAN
-    /// write_double_ahead() for a float that is not the batch's next one (out
-    /// of line: the walk is faster with less code in its loop)
-    NLOHMANN_VIEW_NOINLINE char* write_double_beside(char* w, const node* n, float_batch& batch)
-    {
-        // (an editable document's walk can skip nodes of the array)
-        const std::less<const node*> before{}; // NOLINT(modernize-use-transparent-functors) C++11 has no std::less<>
-        while (batch.next != batch.count && before(batch.at[batch.next], n))
-        {
-            ++batch.next;
-        }
-        if ((batch.next != batch.count && batch.at[batch.next] == n) || convert_ahead(n, batch))
-        {
-            const std::uint64_t digits = batch.digits[batch.next++];
-            if ((digits & carried()) != 0)
-            {
-                return write_carried_digits(w, *n, digits & ~carried());
-            }
-            if (digits != 0)
-            {
-                return write_token_digits(w, m_doc.src, *n, digits);
-            }
-        }
-        return write_double_at(w, *n);
-    }
-
-    /*!
-    @brief convert the floats of 16 or 17 digits among the next nodes of the
-    array at once; whether n is the first of them
-
-    Such tokens (like the coordinates of GeoJSON, written with 17 digits) are
-    written as the token with its last four digits replaced
-    (write_token_digits()). Each step (the digits, locate_token(),
-    token_digits_1/2()) is a long chain of dependent operations; one loop per
-    step over many floats lets the processor overlap the floats, which it does
-    not across the steps of one float (on Apple M1, one loop for the digits and
-    locate_token() made the dump of canada.json 12 % slower). Each node of the array
-    is scanned once; a node that the walk does not reach in order (in an
-    editable document) is written without the batch.
-    */
-    NLOHMANN_VIEW_NOINLINE bool convert_ahead(const node* n, float_batch& batch)
-    {
-        const std::less<const node*> before{}; // NOLINT(modernize-use-transparent-functors) C++11 has no std::less<>
-        const node* const last = m_doc.nodes + m_doc.node_count;
-        if (before(n, batch.scanned) || before(n, m_doc.nodes) || !before(n, last))
-        {
-            return false;
-        }
-        const char* const src = m_doc.src;
-        const char* const src_end = src + m_doc.size;
-        const node* const stop = last - n > 1024 ? n + 1024 : last;
-        batch.count = 0;
-        batch.next = 0;
-        // the digits of each token (and its last four from the text)
-        std::array<std::uint64_t, 256> digits;     // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<int, 256> exponent;             // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint32_t, 256> last_four;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        const node* p = n;
-        if (!batch.storage)
-        {
-            batch.storage.reset(new typename float_batch::entries); // NOLINT(cppcoreguidelines-owning-memory,modernize-make-unique): C++11
-            batch.at = batch.storage->at.data();
-            batch.digits = batch.storage->digits.data();
-        }
-        for (; p != stop && batch.count != float_batch::capacity(); ++p)
-        {
-            // a token of the source: 16 or 17 digits, at least 8 after the
-            // point, no exponent, 32 bytes to read
-            const unsigned frac_digits = p->extra >> 8u;
-            const unsigned int_digits = p->extra & 0xFFu;
-            const unsigned count = int_digits + frac_digits;
-            if (p->kind == node_kind::number_float && (p->flags & node_flags::storage) == 0
-                    && count - 16u <= 1u && frac_digits >= 8 && src_end - (src + p->off) >= 33)
-            {
-                const auto* const token = reinterpret_cast<const unsigned char*>(src + p->off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
-                const unsigned sign = token[0] == '-' ? 1 : 0;
-                const unsigned char* const first = token + sign;
-                const std::uint64_t w = sixteen_digits(first, int_digits);
-                // (the 17th digit follows the point; a token with an exponent
-                // gets digits outside the range of locate_token(), and is not
-                // written by the batch. A token 0.xxx with 16 significant
-                // digits is: its double is written as "0." and its digits too)
-                const std::uint64_t w17 = (w * 10) + static_cast<std::uint64_t>(first[17] - '0');
-                const std::size_t i = batch.count++;
-                batch.at[i] = p;
-                if (p->len != sign + count + 1)
-                {
-                    digits[i] = 0;
-                }
-                else
-                {
-                    digits[i] = count == 17 ? w17 : w;
-                }
-                exponent[i] = -static_cast<int>(frac_digits);
-                // (byte 0: the last digit, byte 1: the last two, bits 16-29: the last four)
-                std::uint32_t four = 0;
-                std::memcpy(&four, token + p->len - 4, 4);
-                four -= 0x30303030u;
-                const std::uint32_t pairs = ((four & 0x0F0F0F0Fu) * 2561u) >> 8u; // (byte 0, 2: the pairs)
-                last_four[i] = (four >> 24u) | ((pairs >> 16u & 0xFFu) << 8u) | ((((pairs & 0x00FF00FFu) * 6553601u) >> 16u) << 16u);
-            }
-        }
-        batch.scanned = p;
-        // the position of each double, and the floats of either kind
-        std::array<std::uint64_t, 256> offset; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint64_t, 256> radius; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint8_t, 256> kind_1;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::array<std::uint8_t, 256> kind_2;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::size_t count_1 = 0;
-        std::size_t count_2 = 0;
-        for (std::size_t i = 0; i != batch.count; ++i)
-        {
-            const std::uint64_t w = digits[i];
-            // (the range excludes the values of bytes that are not digits, only
-            // in a damaged image loaded with image_check::bounds)
-            const int g = w - 1000000000000000u < 99000000000000000u ? locate_token(w, exponent[i], offset[i], radius[i]) : 3;
-            batch.digits[i] = g <= 0 ? (last_four[i] >> 16u) + 1 : 0;
-            kind_1[count_1] = static_cast<std::uint8_t>(i);
-            count_1 += g == 1 ? 1 : 0;
-            kind_2[count_2] = static_cast<std::uint8_t>(i);
-            count_2 += g == 2 ? 1 : 0;
-        }
-        // the digits to write, in one loop per kind (see mark())
-        for (std::size_t k = 0; k != count_1; ++k)
-        {
-            const std::size_t i = kind_1[k];
-            const std::uint64_t s = token_digits_1(digits[i], offset[i], radius[i], last_four[i] & 0xFFu);
-            batch.digits[i] = mark(digits[i], s, last_four[i] >> 16u);
-        }
-        for (std::size_t k = 0; k != count_2; ++k)
-        {
-            const std::size_t i = kind_2[k];
-            const std::uint64_t s = token_digits_2(digits[i], offset[i], radius[i], last_four[i] & 0xFFu, (last_four[i] >> 8u) & 0xFFu);
-            batch.digits[i] = mark(digits[i], s, last_four[i] >> 16u);
-        }
-        return batch.count != 0 && batch.at[0] == n;
-    }
-
-    /*!
-    @brief a float token of 16 or 17 digits as dump() writes it, at w (64 bytes
-    of room), from the digits of its double (see locate_token()) whose
-    rounding carried beyond the token's last four digits
-
-    (like 43.42027299999999 -> 43.420273): the digits go to the writer of
-    Zmij's results as its 15 or 16 leading digits and one more, which omits
-    the trailing zeros.
-    */
-    NLOHMANN_VIEW_NOINLINE char* write_carried_digits(char* w, const node& n, std::uint64_t digits) const noexcept
-    {
-        const int exponent = -(n.extra >> 8u);
-        const std::uint64_t leading = digits / 10;
-        const auto last = static_cast<unsigned char>(digits - (leading * 10));
-        const bool seventeen = digits >= 10000000000000000u;
-        *w = '-';
-        w += m_doc.src[n.off] == '-' ? 1 : 0;
-        return ::nlohmann::detail::dtoa_impl::write_shortest(w, seventeen ? ::nlohmann::detail::zmij::shortest_decimal{leading, exponent, last, last != 0}
-                : ::nlohmann::detail::zmij::shortest_decimal{digits, exponent - 1, 0, false});
-    }
-
-    /// the digits s of a token with the digits w and the last four digits
-    /// r4, as the batch keeps them: the new last four digits + 1 (only those
-    /// are written over the token's), or s marked if it differs from w beyond
-    /// them (0 stays for a float the batch does not write)
-    static std::uint64_t mark(std::uint64_t w, std::uint64_t s, std::uint64_t r4) noexcept
-    {
-        const std::uint64_t last = s - (w - r4);
-        return last < 10000 ? last + 1 : s | carried();
-    }
-
-    /*!
-    @brief a float token of 16 or 17 digits as dump() writes it, at w (64 bytes
-    of room): the token with its last four digits replaced by digits - 1 (see
-    mark(); the others are the token's), and without trailing zeros after the
-    point, but one
-    */
-    char* write_token_digits(char* w, const char* src, const node& n, std::uint64_t digits)
-    {
-        const char* const token = src + n.off;
-        std::memcpy(w, token, 32);
-        char* const end = w + n.len;
-        const std::uint32_t last = four_digit_text(static_cast<std::uint32_t>(digits - 1));
-        std::memcpy(end - 4, &last, 4);
-        // (the token's text before the new digits, from the source: reading
-        // the output back would wait for the stores)
-        std::uint64_t before = 0;
-        std::memcpy(&before, token + n.len - 12, 8);
-        const std::uint32_t last_zeros = last ^ 0x30303030u;
-        const std::uint64_t before_zeros = before ^ 0x3030303030303030u;
-        if (NLOHMANN_VIEW_UNLIKELY(last_zeros == 0 && before_zeros == 0))
-        {
-            return write_double_at(w, n); // (twelve or more trailing zeros)
-        }
-        const unsigned zeros = last_zeros != 0 ? (static_cast<unsigned>(count_leading_zeros(last_zeros)) / 8) - 4
-                               : 4 + (static_cast<unsigned>(count_leading_zeros(before_zeros)) / 8);
-        const unsigned frac_digits = n.extra >> 8u;
-        return end - (zeros < frac_digits ? zeros : frac_digits - 1);
-    }
-#endif
-
     /// a float node as dump() writes it
     void write_float_node(const node& n)
     {

tests/src/unit-alt-string.cpp

@@ -373,6 +373,23 @@ TEST_CASE("alternative string type")
         CHECK_FALSE(j.contains(alt_json::json_pointer("/foo/bar")));
     }
 
+    SECTION("non-const operator[](json_pointer)")
+    {
+        // creating values must compile without string_t::begin()
+        alt_json j = alt_json::parse(R"({"a":{"b":[1]},"c":null})");
+        const alt_json before = j;
+        j[alt_json::json_pointer("/a/b/3/x/-/y")] = 1; // pad, append, create
+        j[alt_json::json_pointer("/a/z")] = 2;         // insert a key
+        j[alt_json::json_pointer("/c/0/q")] = 3;       // convert null
+        j[alt_json::json_pointer("/a/b/-")] = 4;       // append
+        CHECK(j.dump() == R"({"a":{"b":[1,null,null,{"x":[{"y":1}]},4],"z":2},"c":[{"q":3}]})");
+
+        // a failing access leaves the value unchanged
+        j = before;
+        CHECK_THROWS_AS(j[alt_json::json_pointer("/a/n/99999999999999999999999")], alt_json::out_of_range&);
+        CHECK(j == before);
+    }
+
     SECTION("operator/(std::size_t)")
     {
         // json_pointer::operator/=(std::size_t) must compile without string_t

tests/src/unit-json_pointer.cpp

@@ -29,9 +29,64 @@ using nlohmann::json;
 #include <map>
 #include <random>
 #include <sstream>
+#include <stdexcept>
 #include <string>
 #include <vector>
 
+namespace
+{
+// the non-const operator[] must throw for pointer and leave the value parsed
+// from init unchanged (strong exception safety)
+template<typename Json>
+void check_strong_guarantee(const char* init, const std::string& pointer, const char* message)
+{
+    CAPTURE(init)
+    CAPTURE(pointer)
+    Json j = Json::parse(init);
+    const Json before = Json::parse(init);
+    const typename Json::json_pointer ptr(pointer);
+    CHECK_THROWS_WITH_AS(j[ptr], message, typename Json::exception&);
+    CHECK(j == before);
+}
+
+// as above, for an index that fits into size_type, but not into an array
+template<typename Json>
+void check_strong_guarantee_length_error(const char* init, const std::string& pointer)
+{
+    CAPTURE(init)
+    CAPTURE(pointer)
+    Json j = Json::parse(init);
+    const Json before = Json::parse(init);
+    const typename Json::json_pointer ptr(pointer);
+    CHECK_THROWS_AS(j[ptr], std::length_error&);
+    CHECK(j == before);
+}
+
+template<typename Json>
+void check_strong_guarantee_cases()
+{
+    const char* const unresolved = "[json.exception.out_of_range.404] unresolved reference token '99999999999999999999999'";
+
+    // the first change converts a null value
+    check_strong_guarantee<Json>("null", "/99999999999999999999999", unresolved);
+    check_strong_guarantee<Json>("null", "/a/99999999999999999999999", unresolved);
+    check_strong_guarantee<Json>(R"({"a":null})", "/a/b/-/99999999999999999999999", unresolved);
+    // the first change inserts a key into an object
+    check_strong_guarantee<Json>("{}", "/a/99999999999999999999999", unresolved);
+    check_strong_guarantee<Json>(R"({"a":{"b":1}})", "/a/c/d/99999999999999999999999", unresolved);
+    // the first change pads or appends to an array
+    check_strong_guarantee<Json>(R"({"a":[1]})", "/a/5/99999999999999999999999", unresolved);
+    check_strong_guarantee<Json>(R"({"a":[1]})", "/a/-/x/1/99999999999999999999999", unresolved);
+    // an index that does not fit into size_type
+    check_strong_guarantee<Json>("null", "/x/18446744073709551615",
+                                 "[json.exception.out_of_range.410] array index 18446744073709551615 exceeds size_type");
+    // an index that fits into size_type, but not into an array
+    const auto too_large = std::to_string((std::numeric_limits<typename Json::size_type>::max)() - 1);
+    check_strong_guarantee_length_error<Json>("null", "/" + too_large);
+    check_strong_guarantee_length_error<Json>(R"({"a":[[1]]})", "/a/0/3/" + too_large);
+}
+} // namespace
+
 TEST_CASE("JSON pointers")
 {
     SECTION("errors")
@@ -557,6 +612,23 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_WITH_AS(j.at("/01"_json_pointer),
                                  "[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'", json::parse_error&);
         }
+
+        SECTION("a failing operator[] leaves the value unchanged")
+        {
+            check_strong_guarantee_cases<json>();
+            check_strong_guarantee_cases<nlohmann::ordered_json>();
+        }
+
+        SECTION("a successful operator[] still creates the same values")
+        {
+            json j = {{"a", {1}}};
+            j["/a/3/x/-/y"_json_pointer] = 1;
+            CHECK(j == json::parse(R"({"a":[1,null,null,{"x":[{"y":1}]}]})"));
+            j["/a/-"_json_pointer] = 2;
+            j["/a/0"_json_pointer] = 3;
+            j["/b"_json_pointer] = 4;
+            CHECK(j == json::parse(R"({"a":[3,null,null,{"x":[{"y":1}]},2],"b":4})"));
+        }
     }
 
     SECTION("flatten")

tests/src/unit-json_view_dump.cpp

@@ -35,9 +35,9 @@ using json_view_test::has_duplicate_keys;
 #include <string>
 #include <vector>
 
-// These tests were split off unit-json_view.cpp, whose object file got too large for the MinGW
+// These tests were split off unit-json_view.cpp, whose object file got too large
-// linker (see json_view_test_helpers.hpp). Like that file, this one is also built
+// for the MinGW linker (see json_view_test_helpers.hpp). Like that file, this one
-// with C++17, as it mentions JSON_HAS_CPP_17.
+// is also built with C++17, as it mentions JSON_HAS_CPP_17.
 
 TEST_CASE("json_view dump")
 {
@@ -150,88 +150,6 @@ TEST_CASE("json_view dump")
             CHECK(many_doc.root().dump() == json::parse(many_tokens).dump());
         }
 
-        // tokens of 16 and 17 digits without an exponent (like GeoJSON
-        // coordinates), which dump() converts in batches: doubles exactly
-        // halfway between two candidates for the shortest digits, random
-        // digits, and digits near a shorter decimal (...99999997,
-        // ...00000003), whose rounding carries; in pairs and among other
-        // values, so that the batches are interrupted; the last token near the
-        // end of the text
-        {
-            std::mt19937_64 tokens(5627); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
-            const auto draw = [&tokens](std::size_t n)
-            {
-                const std::uint64_t r = tokens() % n;
-                return static_cast<std::size_t>(r);
-            };
-            std::string coordinates = "[754570942.33984373,257769445.56835938,858106901.94921875,97944964.876953125,"
-                                      "[0.5,1e-7],[1.5,-0.0,2.5],[1E2,12.5,0.1,3.25,4.5,5.75,6.125,7.0,8.5],[],[1.5],[1,2.5],[2.5,\"x\"],[[1.5],2.5],";
-            for (int i = 0; i < 20000; ++i)
-            {
-                const std::size_t length = 16 + draw(2);
-                std::string digits(1, static_cast<char>('1' + draw(9)));
-                const std::size_t kept = draw(3) == 0 ? length : 2 + draw(length - 3);
-                for (std::size_t k = 1; k < kept; ++k)
-                {
-                    digits += static_cast<char>('0' + draw(10));
-                }
-                digits += std::string(length - kept, draw(2) == 0 ? '9' : '0');
-                digits.back() = static_cast<char>('0' + draw(10));
-                const std::size_t point = 1 + draw(9);
-                const std::string token = (draw(2) == 0 ? "-" : "") + digits.substr(0, point) + "." + digits.substr(point);
-                if (i != 0)
-                {
-                    coordinates += ',';
-                }
-                if (draw(8) == 0)
-                {
-                    coordinates += R"({"x":)";
-                    coordinates += token;
-                    coordinates += R"(,"s":"a"})";
-                }
-                else
-                {
-                    coordinates += '[';
-                    coordinates += token;
-                    coordinates += ',';
-                    coordinates += token;
-                    coordinates += ']';
-                }
-            }
-            coordinates += ",-65.613616999999977]";
-            const json_document parsed = json_document::parse(coordinates);
-            const ordered_json j = ordered_json::parse(coordinates);
-            CHECK(parsed.root().dump() == j.dump());
-            CHECK(parsed.root().dump(1) == j.dump(1));
-            CHECK(parsed.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-            CHECK(parsed.root().back().get<double>() == j.back().get<double>());
-            CHECK(parsed.root().back().dump() == "-65.61361699999998");
-            std::size_t i = 0;
-            for (const json_view v : parsed.root())
-            {
-                const ordered_json& e = j[i++];
-                CHECK(v.dump() == e.dump());
-                if (v.is_array() && !v.empty() && v[0].is_number())
-                {
-                    CHECK(v[0].get<double>() == e[0].get<double>());
-                }
-            }
-
-            // an editable document: edits move some arrays, so that the walk
-            // leaves the order of the parsed nodes
-            ordered_json_editable_document editable = ordered_json_editable_document::parse(coordinates);
-            ordered_json expected = j;
-            for (std::size_t k = 0; k < 20000; k += 97)
-            {
-                if (expected[k].is_array())
-                {
-                    editable.push_back(editable.root()[k], ordered_json(1.5));
-                    expected[k].push_back(1.5);
-                }
-            }
-            CHECK(editable.root().dump() == expected.dump());
-        }
-
         // random doubles, written as parse() and dump() would
         std::mt19937_64 rng(1170); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
         std::string many = "[";
@@ -253,4 +171,768 @@ TEST_CASE("json_view dump")
         const nlohmann::basic_json_document<json_float> float_document = nlohmann::basic_json_document<json_float>::parse("[0.1, 1.5e10, 3.4028235e38]");
         CHECK(float_document.root().dump() == json_float::parse("[0.1, 1.5e10, 3.4028235e38]").dump());
     }
+
+    SECTION("members in document order, all of them")
+    {
+        const json_document d = json_document::parse(R"({"b": 1, "a": 2, "b": 3})");
+        CHECK(d.root().dump() == R"({"b":1,"a":2,"b":3})");
+        CHECK(d.root().dump(1) == "{\n \"b\": 1,\n \"a\": 2,\n \"b\": 3\n}");
+        // dump() writes all members, though the lookup finds the first
+        CHECK(d.root()["b"].dump() == "1");
+    }
+
+    SECTION("deep nesting")
+    {
+        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
+        const json_document deep_document = json_document::parse(deep);
+        CHECK(deep_document.root().dump() == deep);
+    }
+
+    SECTION("ensure_ascii: a character that needs an escape at each position of a string")
+    {
+        // string lengths around the width of the vector steps, in a string value, a key, and a value near the end of the text
+        for (const char* const special :
+                {
+                    "\xC3\xA9", "\xE4\xB8\xAD", "\xF0\x9F\x98\x80", "\x7F", "\\n", "\\u0001", "\\\"", "\\\\"
+                })
+        {
+            for (std::size_t length = 0; length <= 40; ++length)
+            {
+                for (std::size_t position = 0; position <= length; ++position)
+                {
+                    std::string content(length, 'a');
+                    content.insert(position, special);
+                    const std::array<std::string, 3> texts =
+                    {
+                        {
+                            "\"" + content + "\"",
+                            "[\"" + content + "\"]",
+                            "{\"" + content + "\":1}",
+                        }
+                    };
+                    for (const std::string& text : texts)
+                    {
+                        CAPTURE(text)
+                        const ordered_json_document d = ordered_json_document::parse(text);
+                        const ordered_json j = ordered_json::parse(text);
+                        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+                        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
+                        CHECK(d.root().dump() == j.dump());
+                    }
+                }
+            }
+        }
+    }
+
+    SECTION("ensure_ascii: every character of the Basic Multilingual Plane and some beyond")
+    {
+        // (the two- and three-byte sequences, including the ranges that need a check: E0, ED, EF BF BF)
+        std::string text = "[";
+        std::size_t in_chunk = 0;
+        const auto append = [&](std::uint32_t cp)
+        {
+            if (cp < 0x80)
+            {
+                if (cp < 0x20 || cp == '"' || cp == '\\')
+                {
+                    return;
+                }
+                text += static_cast<char>(cp);
+            }
+            else if (cp < 0x800)
+            {
+                text += static_cast<char>(0xC0 | (cp >> 6));
+                text += static_cast<char>(0x80 | (cp & 0x3F));
+            }
+            else if (cp < 0x10000)
+            {
+                text += static_cast<char>(0xE0 | (cp >> 12));
+                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                text += static_cast<char>(0x80 | (cp & 0x3F));
+            }
+            else
+            {
+                text += static_cast<char>(0xF0 | (cp >> 18));
+                text += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
+                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                text += static_cast<char>(0x80 | (cp & 0x3F));
+            }
+        };
+        for (std::uint32_t cp = 0x20; cp < 0x10400; ++cp)
+        {
+            if (cp >= 0xD800 && cp < 0xE000)
+            {
+                continue;
+            }
+            if (in_chunk == 0)
+            {
+                text += text.size() > 1 ? ",\"" : "\"";
+            }
+            append(cp);
+            if (++in_chunk == 37)
+            {
+                text += "\"";
+                in_chunk = 0;
+            }
+        }
+        text += in_chunk != 0 ? "\"]" : "]";
+        const ordered_json_document d = ordered_json_document::parse(text);
+        const ordered_json j = ordered_json::parse(text);
+        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
+        CHECK(d.root().dump() == j.dump());
+        CHECK(d.root().dump(2) == j.dump(2));
+    }
+
+    SECTION("deep nesting, indented")
+    {
+        // indentations of up to and beyond the width of the writer's fixed-size copy
+        for (const int depth :
+                {
+                    1, 5, 20, 70, 300
+                })
+        {
+            std::string text;
+            for (int i = 0; i < depth; ++i)
+            {
+                text += i % 2 == 0 ? "[1," : R"({"k":2,"\u00e9":)";
+            }
+            text += "[]";
+            for (int i = depth - 1; i >= 0; --i)
+            {
+                text += i % 2 == 0 ? "]" : "}";
+            }
+            const ordered_json_document d = ordered_json_document::parse(text);
+            const ordered_json j = ordered_json::parse(text);
+            for (const int indent :
+                    {
+                        0, 1, 2, 3, 8
+                    })
+            {
+                CHECK(d.root().dump(indent) == j.dump(indent));
+                CHECK(d.root().dump(indent, '\t') == j.dump(indent, '\t'));
+            }
+        }
+    }
+
+    SECTION("the output buffer of a small value is small")
+    {
+        // an escaped key after the value: its node lies in the arena, so the
+        // source extent of the value cannot be read from the next node
+        const std::string big(100000, 'a');
+        const std::string text = R"({"small":1,"list":[1,2,3],"k\n":")" + big + R"("})";
+        const json_document d = json_document::parse(text);
+        const auto small = d.root()["small"].dump();
+        CHECK(small == "1");
+        CHECK(small.capacity() < 4096);
+        const auto list = d.root()["list"].dump();
+        CHECK(list == "[1,2,3]");
+        CHECK(list.capacity() < 4096);
+        CHECK(d.root()["list"].dump(2).capacity() < 4096);
+
+        // the whole document and the large value are unaffected
+        CHECK(d.root().dump() == ordered_json::parse(text).dump());
+        CHECK(d.root()["k\n"].dump() == "\"" + big + "\"");
+    }
+
+    SECTION("output that outgrows the estimate")
+    {
+        // ensure_ascii writes six bytes for each two-byte character
+        std::string chars;
+        for (int i = 0; i < 5000; ++i)
+        {
+            chars += "\xC3\xA9";
+        }
+        const json_document d = json_document::parse(R"({"a":")" + chars + R"(","k\n":1})");
+        const json expected = json::parse("\"" + chars + "\"");
+        CHECK(d.root()["a"].dump(-1, ' ', true) == expected.dump(-1, ' ', true));
+        CHECK(d.root()["a"].dump(-1, ' ', true).size() == 2 + (5000 * 6));
+    }
+
+    SECTION("ensure_ascii with strings of the source, decoded strings, and edited strings")
+    {
+        // plain ASCII, non-ASCII, escaped (decoded), and mixed strings, as values and as keys;
+        // the second text has a DEL, which ensure_ascii writes as an escape
+        for (const char* const del :
+                {"", "\x7F"
+                })
+        {
+            const std::string text = std::string("{\"plain\":\"abc\",\"caf\xC3\xA9\":\"\xC3\xA9\xE2\x82\xAC\xF0\x9F\x98\x80\",")
+                                     + "\"esc\\n\\\"\":\"a\\tb\\u00e4\\ud83d\\ude00\",\"del\":\"a" + del + "b\",\"\":\"\"," // NOLINT(modernize-raw-string-literal)
+                                     + "\"list\":[\"x\",\"\xC3\xBC\",\"\\\\\",\"long ASCII string with more than thirty-two bytes in it\","
+                                     + "\"long string with more than thirty-two bytes and one non-ASCII byte \xC3\xB6\"],"
+                                     + "\"n\":[1,2.5,-0,true,null]}";
+            const ordered_json j = ordered_json::parse(text);
+            const ordered_json_document d = ordered_json_document::parse(text);
+            CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+            CHECK(d.root().dump(4, ' ', true) == j.dump(4, ' ', true));
+            CHECK(d.root().dump() == j.dump());
+            CHECK(d.root()["list"].dump(-1, ' ', true) == j["list"].dump(-1, ' ', true));
+            CHECK(d.root()["del"].dump(-1, ' ', true) == j["del"].dump(-1, ' ', true));
+
+            // strings that an edit wrote (the source strings that they replace were plain)
+            ordered_json_editable_document e = ordered_json_editable_document::parse(text);
+            ordered_json k = j;
+            e.set(e.root()["plain"], std::string("\xC3\xA4gypten"));
+            k["plain"] = "\xC3\xA4gypten";
+            e.set(e.root()["list"][0], std::string("ascii after edit"));
+            k["list"][0] = "ascii after edit";
+            e.set(e.root()["list"][1], std::string("\xC3\xA4"));
+            k["list"][1] = "\xC3\xA4";
+            e.set(e.root()["del"], std::string("tab\there"));
+            k["del"] = "tab\there";
+            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
+            CHECK(e.root().dump(2, ' ', true) == k.dump(2, ' ', true));
+            CHECK(e.root().dump() == k.dump());
+
+            // strings that were edited from or to ASCII text
+            e.set(e.root()["list"][2], std::string("\xC3\xA4"));
+            k["list"][2] = "\xC3\xA4";
+            e.set(e.root()["list"][4], std::string("plain again"));
+            k["list"][4] = "plain again";
+            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
+        }
+    }
+
+    SECTION("ensure_ascii with DEL or a non-ASCII character at every position")
+    {
+        // the check whether a string of the source has no byte >= 0x7F reads
+        // eight bytes at a time and then the rest one by one
+        for (std::size_t length = 1; length <= 20; ++length)
+        {
+            for (std::size_t pos = 0; pos < length; ++pos)
+            {
+                for (const char* const c :
+                        {
+                            "\x7F", "\x7E", "\xC3\xA4", "\xC3\xBF" // NOLINT(modernize-raw-string-literal)
+                        })
+                {
+                    const std::string s = std::string(pos, 'a') + c + std::string(length - pos - 1, 'b');
+                    std::string text = "[\"";
+                    text.append(s).append("\",{\"").append(s).append("\":1}]");
+                    const json_document d = json_document::parse(text);
+                    const json j = json::parse(text);
+                    CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+                    CHECK(d.root().dump(1, ' ', true) == j.dump(1, ' ', true));
+                }
+            }
+        }
+    }
+
+    SECTION("streams and discarded views")
+    {
+        const json_document d = json_document::parse(R"({"a": [1, 2]})");
+        std::ostringstream compact;
+        compact << d.root();
+        CHECK(compact.str() == R"({"a":[1,2]})");
+        std::ostringstream pretty;
+        pretty << std::setw(2) << std::setfill('.') << d.root() << d.root()["a"];
+        CHECK(pretty.str() == "{\n..\"a\": [\n....1,\n....2\n..]\n}[1,2]");
+        CHECK(json_view().dump() == json(json::value_t::discarded).dump());
+    }
+}
+
+TEST_CASE("json_view comparison")
+{
+    SECTION("equality of the values parse() produces")
+    {
+        generator g;
+        std::vector<std::string> texts;
+        for (int i = 0; i < 600; ++i)
+        {
+            std::string text;
+            g.value(text, 0);
+            texts.push_back(text);
+            // the same value written differently: sorted keys, canonical numbers
+            texts.push_back(json::parse(text).dump(1));
+        }
+        for (std::size_t i = 0; i + 2 < texts.size(); ++i)
+        {
+            for (std::size_t k = i; k < i + 3; ++k)
+            {
+                CAPTURE(texts[i])
+                CAPTURE(texts[k])
+                const json_document a = json_document::parse(texts[i]);
+                const json_document b = json_document::parse(texts[k]);
+                const json ja = json::parse(texts[i]);
+                const json jb = json::parse(texts[k]);
+                CHECK((a.root() == b.root()) == (ja == jb));
+                CHECK((a.root() != b.root()) == (ja != jb));
+                CHECK((a.root() == jb) == (ja == jb));
+                CHECK((jb == a.root()) == (ja == jb));
+                CHECK((a.root() != jb) == (ja != jb));
+                CHECK((jb != a.root()) == (ja != jb));
+
+                // ordered_json compares members in order
+                const ordered_json_document oa = ordered_json_document::parse(texts[i]);
+                const ordered_json_document ob = ordered_json_document::parse(texts[k]);
+                const ordered_json oja = ordered_json::parse(texts[i]);
+                const ordered_json ojb = ordered_json::parse(texts[k]);
+                CHECK((oa.root() == ob.root()) == (oja == ojb));
+                CHECK((oa.root() == ojb) == (oja == ojb));
+            }
+        }
+    }
+
+    SECTION("numbers, duplicate keys, member order")
+    {
+        const auto same = [](const char* x, const char* y)
+        {
+            const json_document dx = json_document::parse(x);
+            const json_document dy = json_document::parse(y);
+            return dx.root() == dy.root();
+        };
+        CHECK(same("1", "1.0"));
+        CHECK(same("[1, -1, 2.5]", "[1.0, -1.0, 25e-1]"));
+        CHECK(!same("1", "1.5"));
+        CHECK(same("18446744073709551615", "18446744073709551615"));
+        CHECK(same(R"({"a": 1, "a": 2})", R"({"a": 2})"));
+        CHECK(!same(R"({"a": 1, "a": 2})", R"({"a": 1})"));
+        CHECK(same(R"({"a": 1, "b": 2})", R"({"b": 2, "a": 1})"));
+        CHECK(!same(R"({"a": 1})", R"({"a": 1, "b": 2})"));
+        CHECK(!same("[1, 2]", "[2, 1]"));
+        CHECK(!same("\"a\"", "\"b\""));
+        CHECK(same("\"\\u00e9\"", "\"\xc3\xa9\""));
+        CHECK(!same("null", "false"));
+        CHECK(!same("[]", "{}"));
+        const ordered_json_document dup = ordered_json_document::parse(R"({"a": 1, "b": 2, "a": 3})");
+        const ordered_json_document last = ordered_json_document::parse(R"({"a": 3, "b": 2})");
+        CHECK(dup.root() == last.root());
+        // (== compares as parse() resolves duplicates, a lookup finds the first)
+        CHECK(dup.root()["a"].materialize() == 1);
+        CHECK(dup.root()["a"] != last.root()["a"]);
+        const ordered_json_document ab = ordered_json_document::parse(R"({"a": 1, "b": 2})");
+        const ordered_json_document ba = ordered_json_document::parse(R"({"b": 2, "a": 1})");
+        CHECK(ab.root() != ba.root());
+
+        // discarded values compare as basic_json's do
+        const json discarded(json::value_t::discarded);
+        CHECK((json_view() == json_view()) == (discarded == discarded)); // NOLINT(readability-container-size-empty): operator== is tested
+        CHECK((json_view() == discarded) == (discarded == discarded)); // NOLINT(readability-container-size-empty)
+        const json_document null_document = json_document::parse("null");
+        CHECK(!(json_view() == null_document.root())); // NOLINT(readability-container-size-empty)
+        CHECK(!(null_document.root() == discarded));
+    }
+
+    SECTION("deep nesting")
+    {
+        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
+        const json_document a = json_document::parse(deep);
+        const json_document b = json_document::parse(deep);
+        CHECK(a.root() == b.root());
+        CHECK(a.root() == json::parse(deep));
+        const std::string other = std::string(100000, '[') + "1" + std::string(100000, ']');
+        const json_document c = json_document::parse(other);
+        CHECK(a.root() != c.root());
+    }
+}
+
+TEST_CASE("json_view large objects")
+{
+    // objects with 128 members or more are looked up with a hash index
+    for (const std::size_t members :
+            {
+                127u, 128u, 129u, 10000u
+            })
+    {
+        CAPTURE(members)
+        std::string text = "{";
+        for (std::size_t i = 0; i < members; ++i)
+        {
+            text += (i != 0 ? ",\"" : "\"") + std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\\n" : "") + "\":" + std::to_string(i);
+        }
+        text += R"(,"":"empty key","k1":"a duplicate of an earlier key"})";
+        const json_document d = json_document::parse(text);
+        const json_view v = d.root();
+        const json j = json::parse(text);
+        for (std::size_t i = 0; i < members; ++i)
+        {
+            const std::string key = std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\n" : "");
+            CHECK(v[key].get<std::size_t>() == i);
+            CHECK(v.contains(key));
+            CHECK(v.find(key).key() == key);
+            CHECK(v.at(key).get<std::size_t>() == i);
+            CHECK(!v.contains(key + "x"));
+        }
+        CHECK(v[""].get_string() == "empty key");
+        CHECK(v["k1"].get<int>() == 1); // the first of duplicate keys, as for small objects
+        CHECK(!v.contains("missing"));
+        CHECK_THROWS_WITH_AS(v.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", json::out_of_range&);
+        CHECK(v == j);
+        CHECK(v.materialize() == j);
+    }
+
+    SECTION("duplicate keys: the first member wins, with and without a table")
+    {
+        // an object of `total` members: the keys "k0".."k<n-1>" in order, then
+        // three keys repeated twice more (one copy in the middle, one at the
+        // end), and two keys repeated once; the value of a member is its
+        // position, so that the first member of a key can be told apart
+        struct member
+        {
+            std::string key;
+            std::size_t position;
+        };
+        const auto make_members = [](std::size_t total)
+        {
+            std::vector<std::string> keys;
+            for (std::size_t i = 0; i + 8 < total; ++i)
+            {
+                keys.push_back("k" + std::to_string(i));
+            }
+            const std::size_t n = keys.size();
+            const std::array<std::size_t, 3> triple = {{3, 17, n - 1}};
+            const std::array<std::size_t, 2> twice = {{5, n / 2}};
+            std::vector<std::string> ordered = keys;
+            for (const std::size_t i : triple)
+            {
+                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 2), keys[i]);
+            }
+            for (const std::size_t i : twice)
+            {
+                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 3), keys[i]);
+            }
+            for (const std::size_t i : triple)
+            {
+                ordered.push_back(keys[i]);
+            }
+            std::vector<member> result;
+            result.reserve(ordered.size());
+            for (std::size_t i = 0; i < ordered.size(); ++i)
+            {
+                result.push_back({ordered[i], i});
+            }
+            return result;
+        };
+
+        // 100 and 127 members: no table; 128 members and more: a table
+        for (const std::size_t total :
+                {
+                    100u, 127u, 128u, 200u, 5000u
+                })
+        {
+            CAPTURE(total)
+            const std::vector<member> members = make_members(total);
+            REQUIRE(members.size() >= total);
+            REQUIRE(members.size() >= 100);
+            std::string text = "{";
+            std::map<std::string, std::size_t> first;
+            std::map<std::string, std::size_t> last;
+            std::map<std::string, std::size_t> occurrences;
+            for (const member& m : members)
+            {
+                text += (text.size() > 1 ? ",\"" : "\"") + m.key + "\":" + std::to_string(m.position);
+                first.insert({m.key, m.position});
+                last[m.key] = m.position;
+                ++occurrences[m.key];
+            }
+            text += '}';
+            REQUIRE(first.size() < members.size());
+
+            const json_document d = json_document::parse(text);
+            const json_view v = d.root();
+            const json j = json::parse(text);
+            CHECK(v.size() == members.size()); // every occurrence is visited
+            const json m = v.materialize();
+            for (const auto& entry : first)
+            {
+                CAPTURE(entry.first)
+                const std::size_t expected = entry.second;
+                CHECK(v[entry.first].get<std::size_t>() == expected);
+                CHECK(v.at(entry.first).get<std::size_t>() == expected);
+                CHECK(v.find(entry.first).value().get<std::size_t>() == expected);
+                CHECK(v.value(entry.first, std::size_t{0}) == expected);
+                CHECK(v.contains(entry.first));
+                CHECK(v.count(entry.first) == occurrences[entry.first]);
+                const std::string pointer = "/" + entry.first;
+                CHECK(v[json::json_pointer(pointer)].get<std::size_t>() == expected);
+                CHECK(v.at(json::json_pointer(pointer)).get<std::size_t>() == expected);
+                CHECK(v.value(json::json_pointer(pointer), std::size_t{0}) == expected);
+                CHECK(v.contains(json::json_pointer(pointer)));
+                // materialize() and parse() keep the last value instead
+                CHECK(j[entry.first].get<std::size_t>() == last.at(entry.first));
+                CHECK(m[entry.first].get<std::size_t>() == last.at(entry.first));
+            }
+            CHECK(!v.contains("k"));
+            CHECK(v["missing"].is_discarded());
+            CHECK(v.materialize() == j);
+            CHECK(v == j);
+        }
+    }
+
+    SECTION("colliding keys")
+    {
+        // the hash is not seeded, so keys that all land in one place must not
+        // make the table build quadratic: such an object gets no table and is
+        // searched linearly
+        constexpr std::size_t members = 300;
+        constexpr std::size_t table_size = 1024; // the table size for 300 members: the next power of two >= 600
+        std::vector<std::string> colliding;
+        std::vector<std::string> spread;
+        for (std::uint64_t counter = 0; colliding.size() < members || spread.size() < members; ++counter)
+        {
+            std::string key(8, 'a');
+            std::uint64_t x = counter;
+            for (std::size_t i = 0; i < 8; ++i, x /= 26)
+            {
+                key[i] = static_cast<char>('a' + (x % 26));
+            }
+            const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (table_size - 1)) == 0;
+            if (lands_in_slot_zero && colliding.size() < members)
+            {
+                colliding.push_back(key);
+            }
+            else if (!lands_in_slot_zero && spread.size() < members)
+            {
+                spread.push_back(key);
+            }
+        }
+
+        const auto make_text = [](const std::vector<std::string>& keys)
+        {
+            std::string text = "{";
+            for (std::size_t i = 0; i < keys.size(); ++i)
+            {
+                text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i % 10);
+            }
+            return text + "}";
+        };
+        const std::string colliding_text = make_text(colliding);
+        const std::string spread_text = make_text(spread);
+
+        json_document with_collisions = json_document::parse(colliding_text);
+        json_document without_collisions = json_document::parse(spread_text);
+        for (const auto* pair :
+                {
+                    &colliding, &spread
+                })
+        {
+            const json_view v = (pair == &colliding ? with_collisions : without_collisions).root();
+            for (std::size_t i = 0; i < members; ++i)
+            {
+                CAPTURE(i)
+                CHECK(v[(*pair)[i]].get<std::size_t>() == i % 10);
+                CHECK(v.at((*pair)[i]).get<std::size_t>() == i % 10);
+                CHECK(v.find((*pair)[i]).key() == (*pair)[i]);
+                CHECK(!v.contains((*pair)[i] + "x"));
+            }
+            CHECK(!v.contains("missing"));
+        }
+        CHECK(with_collisions.root() == json::parse(colliding_text));
+
+        // only the object with the spread keys got a table (both texts have the
+        // same length, so the tables are the only difference)
+        with_collisions.shrink_to_fit();
+        without_collisions.shrink_to_fit();
+        CHECK(without_collisions.memory_usage() >= with_collisions.memory_usage() + (table_size * sizeof(std::uint32_t)));
+    }
+
+    SECTION("keys that differ in their last bytes are spread over the table")
+    {
+        // The hash must spread the usual families of keys (numbered names, hex
+        // strings, dates, short names): a key farther than index_max_displacement
+        // from its home slot would leave the object without a table. The keys
+        // are placed with linear probing, as the table does.
+        const auto max_displacement = [](const std::vector<std::string>& keys)
+        {
+            std::size_t slots = 16;
+            while (slots < 2 * keys.size())
+            {
+                slots *= 2;
+            }
+            std::vector<bool> used(slots, false);
+            std::size_t farthest = 0;
+            for (const std::string& key : keys)
+            {
+                std::size_t i = nlohmann::detail::conditional_static_cast<std::size_t>(nlohmann::detail::view::key_hash(key.data(), key.size())) & (slots - 1);
+                std::size_t distance = 0;
+                while (used[i])
+                {
+                    i = (i + 1) & (slots - 1);
+                    ++distance;
+                }
+                used[i] = true;
+                farthest = (std::max)(farthest, distance);
+            }
+            return farthest;
+        };
+        // the keys of a printf-like pattern with one %d, %0Nd or %0Nx, formatted with a stream
+        // (a format string that is not a literal is a Flawfinder error)
+        const auto numbered = [](const char* format, int count, int step)
+        {
+            const std::string pattern(format);
+            const std::size_t percent = pattern.find('%');
+            std::size_t conversion = percent + 1;
+            std::size_t width = 0;
+            while (pattern[conversion] >= '0' && pattern[conversion] <= '9')
+            {
+                width = (width * 10) + static_cast<std::size_t>(pattern[conversion] - '0');
+                ++conversion;
+            }
+            const bool hex = pattern[conversion] == 'x';
+            std::vector<std::string> keys;
+            for (int i = 0; i < count; ++i)
+            {
+                std::ostringstream key;
+                key << pattern.substr(0, percent) << std::setfill('0') << std::setw(static_cast<int>(width))
+                    << (hex ? std::hex : std::dec) << (i * step) << pattern.substr(conversion + 1);
+                keys.push_back(key.str());
+            }
+            return keys;
+        };
+        for (const char* format :
+                {"key%d", "%d", "item_%04d", "a%05d", "%03dxyz", "id%d", "user_%d", "%d_suffix", "0x%04x", "A%07d", "12345678%d", "1234567%d", "123456789%d",
+                 "configuration_parameter_value_%04d_extra", "2026-01-%02dT00:00:00Z"
+                })
+        {
+            CAPTURE(format)
+            CHECK(max_displacement(numbered(format, std::string(format).find("%02d") != std::string::npos ? 60 : 1000, 1)) < nlohmann::detail::view::index_max_displacement); // NOLINT(abseil-string-find-str-contains)
+            CHECK(max_displacement(numbered(format, 600, 7)) < nlohmann::detail::view::index_max_displacement);
+        }
+        std::mt19937_64 rng(7); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+        for (const std::size_t length :
+                {
+                    std::size_t{1}, std::size_t{2}, std::size_t{3}, std::size_t{5}, std::size_t{7}, std::size_t{8}, std::size_t{9}, std::size_t{12}, std::size_t{16}, std::size_t{17}, std::size_t{33}
+                })
+        {
+            CAPTURE(length)
+            std::set<std::string> distinct;
+            // (there are 26 and 676 keys of one and two letters)
+            std::size_t wanted = 700;
+            if (length == 1)
+            {
+                wanted = 26;
+            }
+            else if (length == 2)
+            {
+                wanted = 500;
+            }
+            while (distinct.size() < wanted)
+            {
+                std::string key(length, 'a');
+                for (char& c : key)
+                {
+                    c = static_cast<char>('a' + (rng() % 26));
+                }
+                distinct.insert(key);
+            }
+            CHECK(max_displacement(std::vector<std::string>(distinct.begin(), distinct.end())) < nlohmann::detail::view::index_max_displacement);
+        }
+    }
+
+    SECTION("keys of every length that differ in one byte")
+    {
+        // In a large object, a key is found by comparing its bytes with those of the member the
+        // table points to: up to 16 bytes as two overlapping words, longer ones with memcmp.
+        // Keys of every length from 0 to 40, and keys that differ from them in one byte.
+        std::mt19937_64 rng(2026); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+        std::vector<std::string> keys;
+        std::set<std::string> distinct;
+        for (std::size_t length = 0; length <= 40; ++length)
+        {
+            for (int copy = 0; copy < 5; ++copy)
+            {
+                std::string key(length, 'a');
+                for (char& c : key)
+                {
+                    c = static_cast<char>('a' + (rng() % 26));
+                }
+                if (distinct.insert(key).second)
+                {
+                    keys.push_back(key);
+                }
+            }
+        }
+        std::string text = "{";
+        for (std::size_t i = 0; i < keys.size(); ++i)
+        {
+            text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i);
+        }
+        text += "}";
+        REQUIRE(keys.size() >= 128); // (a table is built for 128 members)
+        const json_document d = json_document::parse(text);
+        const json_view v = d.root();
+        for (std::size_t i = 0; i < keys.size(); ++i)
+        {
+            CAPTURE(keys[i])
+            CHECK(v[keys[i]].get<std::size_t>() == i);
+            CHECK(v.at(keys[i]).get<std::size_t>() == i);
+            CHECK(v.contains(keys[i]));
+            for (std::size_t at = 0; at < keys[i].size(); ++at)
+            {
+                std::string other = keys[i];
+                other[at] = other[at] == 'z' ? 'y' : 'z';
+                CAPTURE(other)
+                CHECK(v.contains(other) == (distinct.count(other) != 0));
+            }
+            CHECK(v.contains(keys[i] + "a") == (distinct.count(keys[i] + "a") != 0));
+            if (!keys[i].empty())
+            {
+                CHECK(v.contains(keys[i].substr(1)) == (distinct.count(keys[i].substr(1)) != 0));
+            }
+        }
+    }
+
+    SECTION("shrink_to_fit releases the tables' spare capacity")
+    {
+        const auto make_text = [](int objects, int members)
+        {
+            std::string text = "[";
+            for (int object = 0; object < objects; ++object)
+            {
+                text += object != 0 ? ",{" : "{";
+                for (int i = 0, n = members + object; i < n; ++i)
+                {
+                    text += (i != 0 ? ",\"" : "\"") + std::to_string(i) + "\":" + std::to_string(i);
+                }
+                text += '}';
+            }
+            return text + "]";
+        };
+        const std::string small_text = make_text(5, 150);
+        const std::string big_text = make_text(40, 400);
+
+        // reading a big text, and then a small one, leaves the spare capacity
+        // of the big one: shrink_to_fit() brings the document to the size of
+        // one parsed from the small text alone
+        json_document d = json_document::parse(big_text);
+        const std::size_t big = d.memory_usage();
+        d.read(small_text);
+        CHECK(d.memory_usage() >= big);
+        d.shrink_to_fit();
+        json_document fresh = json_document::parse(small_text);
+        fresh.shrink_to_fit();
+        CHECK(d.memory_usage() == fresh.memory_usage());
+        CHECK(d.memory_usage() < big / 2);
+        CHECK(d.root() == json::parse(small_text));
+        for (int object = 0; object < 5; ++object)
+        {
+            const json_view v = d.root()[static_cast<std::size_t>(object)];
+            for (int i = 0, n = 150 + object; i < n; ++i)
+            {
+                CHECK(v[std::to_string(i)].get<int>() == i);
+            }
+        }
+    }
+
+    SECTION("nested, reused, and in arrays")
+    {
+        std::string inner = "{";
+        for (int i = 0; i < 300; ++i)
+        {
+            inner += (i != 0 ? ",\"m" : "\"m") + std::to_string(i) + "\":" + std::to_string(i);
+        }
+        inner += '}';
+        const std::string text = "[" + inner + ",{\"x\":" + inner + "}," + inner + "]";
+        json_document d = json_document::parse(text);
+        CHECK(d.root()[0]["m299"].get<int>() == 299);
+        CHECK(d.root()[1]["x"]["m150"].get<int>() == 150);
+        CHECK(d.root()[2]["m0"].get<int>() == 0);
+        const std::size_t with_index = d.memory_usage();
+        d.read(std::string("{\"small\": 1}"));
+        CHECK(d.root()["small"].get<int>() == 1);
+        d.read(text);
+        CHECK(d.root()[2]["m7"].get<int>() == 7);
+        CHECK(d.memory_usage() >= with_index / 2);
+    }
 }

tests/src/unit-json_view_dump_escape.cpp

@@ -1,298 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json_view.hpp>
-using nlohmann::json;
-using nlohmann::ordered_json;
-using nlohmann::json_document;
-using nlohmann::ordered_json_editable_document;
-using nlohmann::json_view;
-using nlohmann::ordered_json_document;
-using nlohmann::ordered_json_view;
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iomanip>
-#include <map>
-#include <random>
-#include <set>
-#include <sstream>
-#include <string>
-#include <vector>
-
-// These tests were split off unit-json_view_dump.cpp, whose object file got too large for the MinGW
-// linker (see json_view_test_helpers.hpp). Like that file, this one is also built
-// with C++17, as it mentions JSON_HAS_CPP_17.
-
-TEST_CASE("json_view dump: escaping, nesting, and output buffers")
-{
-    SECTION("members in document order, all of them")
-    {
-        const json_document d = json_document::parse(R"({"b": 1, "a": 2, "b": 3})");
-        CHECK(d.root().dump() == R"({"b":1,"a":2,"b":3})");
-        CHECK(d.root().dump(1) == "{\n \"b\": 1,\n \"a\": 2,\n \"b\": 3\n}");
-        // dump() writes all members, though the lookup finds the first
-        CHECK(d.root()["b"].dump() == "1");
-    }
-
-    SECTION("deep nesting")
-    {
-        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
-        const json_document deep_document = json_document::parse(deep);
-        CHECK(deep_document.root().dump() == deep);
-    }
-
-    SECTION("ensure_ascii: a character that needs an escape at each position of a string")
-    {
-        // string lengths around the width of the vector steps, in a string value, a key, and a value near the end of the text
-        for (const char* const special :
-                {
-                    "\xC3\xA9", "\xE4\xB8\xAD", "\xF0\x9F\x98\x80", "\x7F", "\\n", "\\u0001", "\\\"", "\\\\"
-                })
-        {
-            for (std::size_t length = 0; length <= 40; ++length)
-            {
-                for (std::size_t position = 0; position <= length; ++position)
-                {
-                    std::string content(length, 'a');
-                    content.insert(position, special);
-                    const std::array<std::string, 3> texts =
-                    {
-                        {
-                            "\"" + content + "\"",
-                            "[\"" + content + "\"]",
-                            "{\"" + content + "\":1}",
-                        }
-                    };
-                    for (const std::string& text : texts)
-                    {
-                        CAPTURE(text)
-                        const ordered_json_document d = ordered_json_document::parse(text);
-                        const ordered_json j = ordered_json::parse(text);
-                        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-                        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
-                        CHECK(d.root().dump() == j.dump());
-                    }
-                }
-            }
-        }
-    }
-
-    SECTION("ensure_ascii: every character of the Basic Multilingual Plane and some beyond")
-    {
-        // (the two- and three-byte sequences, including the ranges that need a check: E0, ED, EF BF BF)
-        std::string text = "[";
-        std::size_t in_chunk = 0;
-        const auto append = [&](std::uint32_t cp)
-        {
-            if (cp < 0x80)
-            {
-                if (cp < 0x20 || cp == '"' || cp == '\\')
-                {
-                    return;
-                }
-                text += static_cast<char>(cp);
-            }
-            else if (cp < 0x800)
-            {
-                text += static_cast<char>(0xC0 | (cp >> 6));
-                text += static_cast<char>(0x80 | (cp & 0x3F));
-            }
-            else if (cp < 0x10000)
-            {
-                text += static_cast<char>(0xE0 | (cp >> 12));
-                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
-                text += static_cast<char>(0x80 | (cp & 0x3F));
-            }
-            else
-            {
-                text += static_cast<char>(0xF0 | (cp >> 18));
-                text += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
-                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
-                text += static_cast<char>(0x80 | (cp & 0x3F));
-            }
-        };
-        for (std::uint32_t cp = 0x20; cp < 0x10400; ++cp)
-        {
-            if (cp >= 0xD800 && cp < 0xE000)
-            {
-                continue;
-            }
-            if (in_chunk == 0)
-            {
-                text += text.size() > 1 ? ",\"" : "\"";
-            }
-            append(cp);
-            if (++in_chunk == 37)
-            {
-                text += "\"";
-                in_chunk = 0;
-            }
-        }
-        text += in_chunk != 0 ? "\"]" : "]";
-        const ordered_json_document d = ordered_json_document::parse(text);
-        const ordered_json j = ordered_json::parse(text);
-        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
-        CHECK(d.root().dump() == j.dump());
-        CHECK(d.root().dump(2) == j.dump(2));
-    }
-
-    SECTION("deep nesting, indented")
-    {
-        // indentations of up to and beyond the width of the writer's fixed-size copy
-        for (const int depth :
-                {
-                    1, 5, 20, 70, 300
-                })
-        {
-            std::string text;
-            for (int i = 0; i < depth; ++i)
-            {
-                text += i % 2 == 0 ? "[1," : R"({"k":2,"\u00e9":)";
-            }
-            text += "[]";
-            for (int i = depth - 1; i >= 0; --i)
-            {
-                text += i % 2 == 0 ? "]" : "}";
-            }
-            const ordered_json_document d = ordered_json_document::parse(text);
-            const ordered_json j = ordered_json::parse(text);
-            for (const int indent :
-                    {
-                        0, 1, 2, 3, 8
-                    })
-            {
-                CHECK(d.root().dump(indent) == j.dump(indent));
-                CHECK(d.root().dump(indent, '\t') == j.dump(indent, '\t'));
-            }
-        }
-    }
-
-    SECTION("the output buffer of a small value is small")
-    {
-        // an escaped key after the value: its node lies in the arena, so the
-        // source extent of the value cannot be read from the next node
-        const std::string big(100000, 'a');
-        const std::string text = R"({"small":1,"list":[1,2,3],"k\n":")" + big + R"("})";
-        const json_document d = json_document::parse(text);
-        const auto small = d.root()["small"].dump();
-        CHECK(small == "1");
-        CHECK(small.capacity() < 4096);
-        const auto list = d.root()["list"].dump();
-        CHECK(list == "[1,2,3]");
-        CHECK(list.capacity() < 4096);
-        CHECK(d.root()["list"].dump(2).capacity() < 4096);
-
-        // the whole document and the large value are unaffected
-        CHECK(d.root().dump() == ordered_json::parse(text).dump());
-        CHECK(d.root()["k\n"].dump() == "\"" + big + "\"");
-    }
-
-    SECTION("output that outgrows the estimate")
-    {
-        // ensure_ascii writes six bytes for each two-byte character
-        std::string chars;
-        for (int i = 0; i < 5000; ++i)
-        {
-            chars += "\xC3\xA9";
-        }
-        const json_document d = json_document::parse(R"({"a":")" + chars + R"(","k\n":1})");
-        const json expected = json::parse("\"" + chars + "\"");
-        CHECK(d.root()["a"].dump(-1, ' ', true) == expected.dump(-1, ' ', true));
-        CHECK(d.root()["a"].dump(-1, ' ', true).size() == 2 + (5000 * 6));
-    }
-
-    SECTION("ensure_ascii with strings of the source, decoded strings, and edited strings")
-    {
-        // plain ASCII, non-ASCII, escaped (decoded), and mixed strings, as values and as keys;
-        // the second text has a DEL, which ensure_ascii writes as an escape
-        for (const char* const del :
-                {"", "\x7F"
-                })
-        {
-            const std::string text = std::string("{\"plain\":\"abc\",\"caf\xC3\xA9\":\"\xC3\xA9\xE2\x82\xAC\xF0\x9F\x98\x80\",")
-                                     + "\"esc\\n\\\"\":\"a\\tb\\u00e4\\ud83d\\ude00\",\"del\":\"a" + del + "b\",\"\":\"\"," // NOLINT(modernize-raw-string-literal)
-                                     + "\"list\":[\"x\",\"\xC3\xBC\",\"\\\\\",\"long ASCII string with more than thirty-two bytes in it\","
-                                     + "\"long string with more than thirty-two bytes and one non-ASCII byte \xC3\xB6\"],"
-                                     + "\"n\":[1,2.5,-0,true,null]}";
-            const ordered_json j = ordered_json::parse(text);
-            const ordered_json_document d = ordered_json_document::parse(text);
-            CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-            CHECK(d.root().dump(4, ' ', true) == j.dump(4, ' ', true));
-            CHECK(d.root().dump() == j.dump());
-            CHECK(d.root()["list"].dump(-1, ' ', true) == j["list"].dump(-1, ' ', true));
-            CHECK(d.root()["del"].dump(-1, ' ', true) == j["del"].dump(-1, ' ', true));
-
-            // strings that an edit wrote (the source strings that they replace were plain)
-            ordered_json_editable_document e = ordered_json_editable_document::parse(text);
-            ordered_json k = j;
-            e.set(e.root()["plain"], std::string("\xC3\xA4gypten"));
-            k["plain"] = "\xC3\xA4gypten";
-            e.set(e.root()["list"][0], std::string("ascii after edit"));
-            k["list"][0] = "ascii after edit";
-            e.set(e.root()["list"][1], std::string("\xC3\xA4"));
-            k["list"][1] = "\xC3\xA4";
-            e.set(e.root()["del"], std::string("tab\there"));
-            k["del"] = "tab\there";
-            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
-            CHECK(e.root().dump(2, ' ', true) == k.dump(2, ' ', true));
-            CHECK(e.root().dump() == k.dump());
-
-            // strings that were edited from or to ASCII text
-            e.set(e.root()["list"][2], std::string("\xC3\xA4"));
-            k["list"][2] = "\xC3\xA4";
-            e.set(e.root()["list"][4], std::string("plain again"));
-            k["list"][4] = "plain again";
-            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
-        }
-    }
-
-    SECTION("ensure_ascii with DEL or a non-ASCII character at every position")
-    {
-        // the check whether a string of the source has no byte >= 0x7F reads
-        // eight bytes at a time and then the rest one by one
-        for (std::size_t length = 1; length <= 20; ++length)
-        {
-            for (std::size_t pos = 0; pos < length; ++pos)
-            {
-                for (const char* const c :
-                        {
-                            "\x7F", "\x7E", "\xC3\xA4", "\xC3\xBF" // NOLINT(modernize-raw-string-literal)
-                        })
-                {
-                    const std::string s = std::string(pos, 'a') + c + std::string(length - pos - 1, 'b');
-                    std::string text = "[\"";
-                    text.append(s).append("\",{\"").append(s).append("\":1}]");
-                    const json_document d = json_document::parse(text);
-                    const json j = json::parse(text);
-                    CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-                    CHECK(d.root().dump(1, ' ', true) == j.dump(1, ' ', true));
-                }
-            }
-        }
-    }
-
-    SECTION("streams and discarded views")
-    {
-        const json_document d = json_document::parse(R"({"a": [1, 2]})");
-        std::ostringstream compact;
-        compact << d.root();
-        CHECK(compact.str() == R"({"a":[1,2]})");
-        std::ostringstream pretty;
-        pretty << std::setw(2) << std::setfill('.') << d.root() << d.root()["a"];
-        CHECK(pretty.str() == "{\n..\"a\": [\n....1,\n....2\n..]\n}[1,2]");
-        CHECK(json_view().dump() == json(json::value_t::discarded).dump());
-    }
-}

tests/src/unit-json_view_large.cpp

@@ -1,544 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json_view.hpp>
-using nlohmann::json;
-using nlohmann::ordered_json;
-using nlohmann::json_document;
-using nlohmann::ordered_json_editable_document;
-using nlohmann::json_view;
-using nlohmann::ordered_json_document;
-using nlohmann::ordered_json_view;
-
-#include "json_view_test_helpers.hpp"
-using json_view_test::generator;
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iomanip>
-#include <map>
-#include <random>
-#include <set>
-#include <sstream>
-#include <string>
-#include <vector>
-
-// These tests were split off unit-json_view_dump.cpp, whose object file got too large for the MinGW
-// linker (see json_view_test_helpers.hpp). Like that file, this one is also built
-// with C++17, as it mentions JSON_HAS_CPP_17.
-
-TEST_CASE("json_view comparison")
-{
-    SECTION("equality of the values parse() produces")
-    {
-        generator g;
-        std::vector<std::string> texts;
-        for (int i = 0; i < 600; ++i)
-        {
-            std::string text;
-            g.value(text, 0);
-            texts.push_back(text);
-            // the same value written differently: sorted keys, canonical numbers
-            texts.push_back(json::parse(text).dump(1));
-        }
-        for (std::size_t i = 0; i + 2 < texts.size(); ++i)
-        {
-            for (std::size_t k = i; k < i + 3; ++k)
-            {
-                CAPTURE(texts[i])
-                CAPTURE(texts[k])
-                const json_document a = json_document::parse(texts[i]);
-                const json_document b = json_document::parse(texts[k]);
-                const json ja = json::parse(texts[i]);
-                const json jb = json::parse(texts[k]);
-                CHECK((a.root() == b.root()) == (ja == jb));
-                CHECK((a.root() != b.root()) == (ja != jb));
-                CHECK((a.root() == jb) == (ja == jb));
-                CHECK((jb == a.root()) == (ja == jb));
-                CHECK((a.root() != jb) == (ja != jb));
-                CHECK((jb != a.root()) == (ja != jb));
-
-                // ordered_json compares members in order
-                const ordered_json_document oa = ordered_json_document::parse(texts[i]);
-                const ordered_json_document ob = ordered_json_document::parse(texts[k]);
-                const ordered_json oja = ordered_json::parse(texts[i]);
-                const ordered_json ojb = ordered_json::parse(texts[k]);
-                CHECK((oa.root() == ob.root()) == (oja == ojb));
-                CHECK((oa.root() == ojb) == (oja == ojb));
-            }
-        }
-    }
-
-    SECTION("numbers, duplicate keys, member order")
-    {
-        const auto same = [](const char* x, const char* y)
-        {
-            const json_document dx = json_document::parse(x);
-            const json_document dy = json_document::parse(y);
-            return dx.root() == dy.root();
-        };
-        CHECK(same("1", "1.0"));
-        CHECK(same("[1, -1, 2.5]", "[1.0, -1.0, 25e-1]"));
-        CHECK(!same("1", "1.5"));
-        CHECK(same("18446744073709551615", "18446744073709551615"));
-        CHECK(same(R"({"a": 1, "a": 2})", R"({"a": 2})"));
-        CHECK(!same(R"({"a": 1, "a": 2})", R"({"a": 1})"));
-        CHECK(same(R"({"a": 1, "b": 2})", R"({"b": 2, "a": 1})"));
-        CHECK(!same(R"({"a": 1})", R"({"a": 1, "b": 2})"));
-        CHECK(!same("[1, 2]", "[2, 1]"));
-        CHECK(!same("\"a\"", "\"b\""));
-        CHECK(same("\"\\u00e9\"", "\"\xc3\xa9\""));
-        CHECK(!same("null", "false"));
-        CHECK(!same("[]", "{}"));
-        const ordered_json_document dup = ordered_json_document::parse(R"({"a": 1, "b": 2, "a": 3})");
-        const ordered_json_document last = ordered_json_document::parse(R"({"a": 3, "b": 2})");
-        CHECK(dup.root() == last.root());
-        // (== compares as parse() resolves duplicates, a lookup finds the first)
-        CHECK(dup.root()["a"].materialize() == 1);
-        CHECK(dup.root()["a"] != last.root()["a"]);
-        const ordered_json_document ab = ordered_json_document::parse(R"({"a": 1, "b": 2})");
-        const ordered_json_document ba = ordered_json_document::parse(R"({"b": 2, "a": 1})");
-        CHECK(ab.root() != ba.root());
-
-        // discarded values compare as basic_json's do
-        const json discarded(json::value_t::discarded);
-        CHECK((json_view() == json_view()) == (discarded == discarded)); // NOLINT(readability-container-size-empty): operator== is tested
-        CHECK((json_view() == discarded) == (discarded == discarded)); // NOLINT(readability-container-size-empty)
-        const json_document null_document = json_document::parse("null");
-        CHECK(!(json_view() == null_document.root())); // NOLINT(readability-container-size-empty)
-        CHECK(!(null_document.root() == discarded));
-    }
-
-    SECTION("deep nesting")
-    {
-        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
-        const json_document a = json_document::parse(deep);
-        const json_document b = json_document::parse(deep);
-        CHECK(a.root() == b.root());
-        CHECK(a.root() == json::parse(deep));
-        const std::string other = std::string(100000, '[') + "1" + std::string(100000, ']');
-        const json_document c = json_document::parse(other);
-        CHECK(a.root() != c.root());
-    }
-}
-
-TEST_CASE("json_view large objects")
-{
-    // objects with 128 members or more are looked up with a hash index
-    for (const std::size_t members :
-            {
-                127u, 128u, 129u, 10000u
-            })
-    {
-        CAPTURE(members)
-        std::string text = "{";
-        for (std::size_t i = 0; i < members; ++i)
-        {
-            text += (i != 0 ? ",\"" : "\"") + std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\\n" : "") + "\":" + std::to_string(i);
-        }
-        text += R"(,"":"empty key","k1":"a duplicate of an earlier key"})";
-        const json_document d = json_document::parse(text);
-        const json_view v = d.root();
-        const json j = json::parse(text);
-        for (std::size_t i = 0; i < members; ++i)
-        {
-            const std::string key = std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\n" : "");
-            CHECK(v[key].get<std::size_t>() == i);
-            CHECK(v.contains(key));
-            CHECK(v.find(key).key() == key);
-            CHECK(v.at(key).get<std::size_t>() == i);
-            CHECK(!v.contains(key + "x"));
-        }
-        CHECK(v[""].get_string() == "empty key");
-        CHECK(v["k1"].get<int>() == 1); // the first of duplicate keys, as for small objects
-        CHECK(!v.contains("missing"));
-        CHECK_THROWS_WITH_AS(v.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", json::out_of_range&);
-        CHECK(v == j);
-        CHECK(v.materialize() == j);
-    }
-
-    SECTION("duplicate keys: the first member wins, with and without a table")
-    {
-        // an object of `total` members: the keys "k0".."k<n-1>" in order, then
-        // three keys repeated twice more (one copy in the middle, one at the
-        // end), and two keys repeated once; the value of a member is its
-        // position, so that the first member of a key can be told apart
-        struct member
-        {
-            std::string key;
-            std::size_t position;
-        };
-        const auto make_members = [](std::size_t total)
-        {
-            std::vector<std::string> keys;
-            for (std::size_t i = 0; i + 8 < total; ++i)
-            {
-                keys.push_back("k" + std::to_string(i));
-            }
-            const std::size_t n = keys.size();
-            const std::array<std::size_t, 3> triple = {{3, 17, n - 1}};
-            const std::array<std::size_t, 2> twice = {{5, n / 2}};
-            std::vector<std::string> ordered = keys;
-            for (const std::size_t i : triple)
-            {
-                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 2), keys[i]);
-            }
-            for (const std::size_t i : twice)
-            {
-                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 3), keys[i]);
-            }
-            for (const std::size_t i : triple)
-            {
-                ordered.push_back(keys[i]);
-            }
-            std::vector<member> result;
-            result.reserve(ordered.size());
-            for (std::size_t i = 0; i < ordered.size(); ++i)
-            {
-                result.push_back({ordered[i], i});
-            }
-            return result;
-        };
-
-        // 100 and 127 members: no table; 128 members and more: a table
-        for (const std::size_t total :
-                {
-                    100u, 127u, 128u, 200u, 5000u
-                })
-        {
-            CAPTURE(total)
-            const std::vector<member> members = make_members(total);
-            REQUIRE(members.size() >= total);
-            REQUIRE(members.size() >= 100);
-            std::string text = "{";
-            std::map<std::string, std::size_t> first;
-            std::map<std::string, std::size_t> last;
-            std::map<std::string, std::size_t> occurrences;
-            for (const member& m : members)
-            {
-                text += (text.size() > 1 ? ",\"" : "\"") + m.key + "\":" + std::to_string(m.position);
-                first.insert({m.key, m.position});
-                last[m.key] = m.position;
-                ++occurrences[m.key];
-            }
-            text += '}';
-            REQUIRE(first.size() < members.size());
-
-            const json_document d = json_document::parse(text);
-            const json_view v = d.root();
-            const json j = json::parse(text);
-            CHECK(v.size() == members.size()); // every occurrence is visited
-            const json m = v.materialize();
-            for (const auto& entry : first)
-            {
-                CAPTURE(entry.first)
-                const std::size_t expected = entry.second;
-                CHECK(v[entry.first].get<std::size_t>() == expected);
-                CHECK(v.at(entry.first).get<std::size_t>() == expected);
-                CHECK(v.find(entry.first).value().get<std::size_t>() == expected);
-                CHECK(v.value(entry.first, std::size_t{0}) == expected);
-                CHECK(v.contains(entry.first));
-                CHECK(v.count(entry.first) == occurrences[entry.first]);
-                const std::string pointer = "/" + entry.first;
-                CHECK(v[json::json_pointer(pointer)].get<std::size_t>() == expected);
-                CHECK(v.at(json::json_pointer(pointer)).get<std::size_t>() == expected);
-                CHECK(v.value(json::json_pointer(pointer), std::size_t{0}) == expected);
-                CHECK(v.contains(json::json_pointer(pointer)));
-                // materialize() and parse() keep the last value instead
-                CHECK(j[entry.first].get<std::size_t>() == last.at(entry.first));
-                CHECK(m[entry.first].get<std::size_t>() == last.at(entry.first));
-            }
-            CHECK(!v.contains("k"));
-            CHECK(v["missing"].is_discarded());
-            CHECK(v.materialize() == j);
-            CHECK(v == j);
-        }
-    }
-
-    SECTION("colliding keys")
-    {
-        // the hash is not seeded, so keys that all land in one place must not
-        // make the table build quadratic: such an object gets no table and is
-        // searched linearly
-        constexpr std::size_t members = 300;
-        constexpr std::size_t table_size = 1024; // the table size for 300 members: the next power of two >= 600
-        std::vector<std::string> colliding;
-        std::vector<std::string> spread;
-        for (std::uint64_t counter = 0; colliding.size() < members || spread.size() < members; ++counter)
-        {
-            std::string key(8, 'a');
-            std::uint64_t x = counter;
-            for (std::size_t i = 0; i < 8; ++i, x /= 26)
-            {
-                key[i] = static_cast<char>('a' + (x % 26));
-            }
-            const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (table_size - 1)) == 0;
-            if (lands_in_slot_zero && colliding.size() < members)
-            {
-                colliding.push_back(key);
-            }
-            else if (!lands_in_slot_zero && spread.size() < members)
-            {
-                spread.push_back(key);
-            }
-        }
-
-        const auto make_text = [](const std::vector<std::string>& keys)
-        {
-            std::string text = "{";
-            for (std::size_t i = 0; i < keys.size(); ++i)
-            {
-                text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i % 10);
-            }
-            return text + "}";
-        };
-        const std::string colliding_text = make_text(colliding);
-        const std::string spread_text = make_text(spread);
-
-        json_document with_collisions = json_document::parse(colliding_text);
-        json_document without_collisions = json_document::parse(spread_text);
-        for (const auto* pair :
-                {
-                    &colliding, &spread
-                })
-        {
-            const json_view v = (pair == &colliding ? with_collisions : without_collisions).root();
-            for (std::size_t i = 0; i < members; ++i)
-            {
-                CAPTURE(i)
-                CHECK(v[(*pair)[i]].get<std::size_t>() == i % 10);
-                CHECK(v.at((*pair)[i]).get<std::size_t>() == i % 10);
-                CHECK(v.find((*pair)[i]).key() == (*pair)[i]);
-                CHECK(!v.contains((*pair)[i] + "x"));
-            }
-            CHECK(!v.contains("missing"));
-        }
-        CHECK(with_collisions.root() == json::parse(colliding_text));
-
-        // only the object with the spread keys got a table (both texts have the
-        // same length, so the tables are the only difference)
-        with_collisions.shrink_to_fit();
-        without_collisions.shrink_to_fit();
-        CHECK(without_collisions.memory_usage() >= with_collisions.memory_usage() + (table_size * sizeof(std::uint32_t)));
-    }
-
-    SECTION("keys that differ in their last bytes are spread over the table")
-    {
-        // The hash must spread the usual families of keys (numbered names, hex
-        // strings, dates, short names): a key farther than index_max_displacement
-        // from its home slot would leave the object without a table. The keys
-        // are placed with linear probing, as the table does.
-        const auto max_displacement = [](const std::vector<std::string>& keys)
-        {
-            std::size_t slots = 16;
-            while (slots < 2 * keys.size())
-            {
-                slots *= 2;
-            }
-            std::vector<bool> used(slots, false);
-            std::size_t farthest = 0;
-            for (const std::string& key : keys)
-            {
-                std::size_t i = nlohmann::detail::conditional_static_cast<std::size_t>(nlohmann::detail::view::key_hash(key.data(), key.size())) & (slots - 1);
-                std::size_t distance = 0;
-                while (used[i])
-                {
-                    i = (i + 1) & (slots - 1);
-                    ++distance;
-                }
-                used[i] = true;
-                farthest = (std::max)(farthest, distance);
-            }
-            return farthest;
-        };
-        // the keys of a printf-like pattern with one %d, %0Nd or %0Nx, formatted with a stream
-        // (a format string that is not a literal is a Flawfinder error)
-        const auto numbered = [](const char* format, int count, int step)
-        {
-            const std::string pattern(format);
-            const std::size_t percent = pattern.find('%');
-            std::size_t conversion = percent + 1;
-            std::size_t width = 0;
-            while (pattern[conversion] >= '0' && pattern[conversion] <= '9')
-            {
-                width = (width * 10) + static_cast<std::size_t>(pattern[conversion] - '0');
-                ++conversion;
-            }
-            const bool hex = pattern[conversion] == 'x';
-            std::vector<std::string> keys;
-            for (int i = 0; i < count; ++i)
-            {
-                std::ostringstream key;
-                key << pattern.substr(0, percent) << std::setfill('0') << std::setw(static_cast<int>(width))
-                    << (hex ? std::hex : std::dec) << (i * step) << pattern.substr(conversion + 1);
-                keys.push_back(key.str());
-            }
-            return keys;
-        };
-        for (const char* format :
-                {"key%d", "%d", "item_%04d", "a%05d", "%03dxyz", "id%d", "user_%d", "%d_suffix", "0x%04x", "A%07d", "12345678%d", "1234567%d", "123456789%d",
-                 "configuration_parameter_value_%04d_extra", "2026-01-%02dT00:00:00Z"
-                })
-        {
-            CAPTURE(format)
-            CHECK(max_displacement(numbered(format, std::string(format).find("%02d") != std::string::npos ? 60 : 1000, 1)) < nlohmann::detail::view::index_max_displacement); // NOLINT(abseil-string-find-str-contains)
-            CHECK(max_displacement(numbered(format, 600, 7)) < nlohmann::detail::view::index_max_displacement);
-        }
-        std::mt19937_64 rng(7); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
-        for (const std::size_t length :
-                {
-                    std::size_t{1}, std::size_t{2}, std::size_t{3}, std::size_t{5}, std::size_t{7}, std::size_t{8}, std::size_t{9}, std::size_t{12}, std::size_t{16}, std::size_t{17}, std::size_t{33}
-                })
-        {
-            CAPTURE(length)
-            std::set<std::string> distinct;
-            // (there are 26 and 676 keys of one and two letters)
-            std::size_t wanted = 700;
-            if (length == 1)
-            {
-                wanted = 26;
-            }
-            else if (length == 2)
-            {
-                wanted = 500;
-            }
-            while (distinct.size() < wanted)
-            {
-                std::string key(length, 'a');
-                for (char& c : key)
-                {
-                    c = static_cast<char>('a' + (rng() % 26));
-                }
-                distinct.insert(key);
-            }
-            CHECK(max_displacement(std::vector<std::string>(distinct.begin(), distinct.end())) < nlohmann::detail::view::index_max_displacement);
-        }
-    }
-
-    SECTION("keys of every length that differ in one byte")
-    {
-        // In a large object, a key is found by comparing its bytes with those of the member the
-        // table points to: up to 16 bytes as two overlapping words, longer ones with memcmp.
-        // Keys of every length from 0 to 40, and keys that differ from them in one byte.
-        std::mt19937_64 rng(2026); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
-        std::vector<std::string> keys;
-        std::set<std::string> distinct;
-        for (std::size_t length = 0; length <= 40; ++length)
-        {
-            for (int copy = 0; copy < 5; ++copy)
-            {
-                std::string key(length, 'a');
-                for (char& c : key)
-                {
-                    c = static_cast<char>('a' + (rng() % 26));
-                }
-                if (distinct.insert(key).second)
-                {
-                    keys.push_back(key);
-                }
-            }
-        }
-        std::string text = "{";
-        for (std::size_t i = 0; i < keys.size(); ++i)
-        {
-            text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i);
-        }
-        text += "}";
-        REQUIRE(keys.size() >= 128); // (a table is built for 128 members)
-        const json_document d = json_document::parse(text);
-        const json_view v = d.root();
-        for (std::size_t i = 0; i < keys.size(); ++i)
-        {
-            CAPTURE(keys[i])
-            CHECK(v[keys[i]].get<std::size_t>() == i);
-            CHECK(v.at(keys[i]).get<std::size_t>() == i);
-            CHECK(v.contains(keys[i]));
-            for (std::size_t at = 0; at < keys[i].size(); ++at)
-            {
-                std::string other = keys[i];
-                other[at] = other[at] == 'z' ? 'y' : 'z';
-                CAPTURE(other)
-                CHECK(v.contains(other) == (distinct.count(other) != 0));
-            }
-            CHECK(v.contains(keys[i] + "a") == (distinct.count(keys[i] + "a") != 0));
-            if (!keys[i].empty())
-            {
-                CHECK(v.contains(keys[i].substr(1)) == (distinct.count(keys[i].substr(1)) != 0));
-            }
-        }
-    }
-
-    SECTION("shrink_to_fit releases the tables' spare capacity")
-    {
-        const auto make_text = [](int objects, int members)
-        {
-            std::string text = "[";
-            for (int object = 0; object < objects; ++object)
-            {
-                text += object != 0 ? ",{" : "{";
-                for (int i = 0, n = members + object; i < n; ++i)
-                {
-                    text += (i != 0 ? ",\"" : "\"") + std::to_string(i) + "\":" + std::to_string(i);
-                }
-                text += '}';
-            }
-            return text + "]";
-        };
-        const std::string small_text = make_text(5, 150);
-        const std::string big_text = make_text(40, 400);
-
-        // reading a big text, and then a small one, leaves the spare capacity
-        // of the big one: shrink_to_fit() brings the document to the size of
-        // one parsed from the small text alone
-        json_document d = json_document::parse(big_text);
-        const std::size_t big = d.memory_usage();
-        d.read(small_text);
-        CHECK(d.memory_usage() >= big);
-        d.shrink_to_fit();
-        json_document fresh = json_document::parse(small_text);
-        fresh.shrink_to_fit();
-        CHECK(d.memory_usage() == fresh.memory_usage());
-        CHECK(d.memory_usage() < big / 2);
-        CHECK(d.root() == json::parse(small_text));
-        for (int object = 0; object < 5; ++object)
-        {
-            const json_view v = d.root()[static_cast<std::size_t>(object)];
-            for (int i = 0, n = 150 + object; i < n; ++i)
-            {
-                CHECK(v[std::to_string(i)].get<int>() == i);
-            }
-        }
-    }
-
-    SECTION("nested, reused, and in arrays")
-    {
-        std::string inner = "{";
-        for (int i = 0; i < 300; ++i)
-        {
-            inner += (i != 0 ? ",\"m" : "\"m") + std::to_string(i) + "\":" + std::to_string(i);
-        }
-        inner += '}';
-        const std::string text = "[" + inner + ",{\"x\":" + inner + "}," + inner + "]";
-        json_document d = json_document::parse(text);
-        CHECK(d.root()[0]["m299"].get<int>() == 299);
-        CHECK(d.root()[1]["x"]["m150"].get<int>() == 150);
-        CHECK(d.root()[2]["m0"].get<int>() == 0);
-        const std::size_t with_index = d.memory_usage();
-        d.read(std::string("{\"small\": 1}"));
-        CHECK(d.root()["small"].get<int>() == 1);
-        d.read(text);
-        CHECK(d.root()[2]["m7"].get<int>() == 7);
-        CHECK(d.memory_usage() >= with_index / 2);
-    }
-}

tests/src/unit-regression1.cpp

@@ -1499,6 +1499,23 @@ TEST_CASE("regression tests 1")
         CHECK(order.dump() == R"({"a":2,"m":{"y":1,"b":2},"new_key":3})");
     }
 
+    SECTION("operator[](json_pointer) when emplace() finds a key the lookup does not")
+    {
+        // a copied fifo_map restarts its timestamps, so a new key "k" gets
+        // the timestamp of "x": the lookup does not find "k", but emplace()
+        // finds "x" and inserts nothing; the pointer then continues with the
+        // member of "x", as basic_json::operator[] does
+        const my_json orig = my_json::parse(R"({"x":1})");
+        const std::array<const char*, 3> pointers = {{"/k/0", "/k/a/b", "/k/-"}};
+        for (const char* pointer : pointers)
+        {
+            CAPTURE(pointer)
+            my_json j = orig;
+            CHECK_THROWS_AS(j[my_json::json_pointer(pointer)], my_json::out_of_range&);
+            CHECK(j.dump() == R"({"x":1})");
+        }
+    }
+
     SECTION("issue #977 - Assigning between different json types")
     {
         foo_json lj = ns::foo{3};