Unflatten in time and memory linear in the pointer depth (#5793)

* Unflatten in time and memory linear in the pointer depth

#5443 made unflatten() decide between arrays and objects independently
of the iteration order by collecting the pointer prefixes that have a
reference token 0 below them in a std::set<std::vector<string_t>>.
Every such prefix was stored as a copy of all its reference tokens, and
get_and_create() compared whole prefix vectors at every step, so
unflattening a pointer of depth d took time and memory quadratic in d:
a 10,000-level array pointer took 18 s and 1.3 GB, a 100,000-level one
did not finish.

The prefixes are now numbered nodes of a tree, so each is stored once
and get_and_create() follows the tree token by token. The result is
unchanged, including its independence of the iteration order.

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

* Initialize prefix_tree members to satisfy -Weffc++

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

* Move prefix_tree setup and child insertion into member functions

The constructor now creates the root node, add_child() inserts a
reference token below a prefix and returns the child's number, and
find_child() looks one up for get_and_create().

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

---------

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

docs/mkdocs/docs/api/basic_json/binary_t.md

@@ -64,18 +64,7 @@ values of that type directly to a `basic_json` instance, and they will automatic
 rather than arrays:
 
 ```cpp
-using custom_json = nlohmann::basic_json<
-    nlohmann::ordered_map,  // ObjectType
-    std::vector,            // ArrayType
-    std::string,            // StringType
-    bool,                   // BooleanType
-    std::int64_t,           // NumberIntegerType
-    std::uint64_t,          // NumberUnsignedType
-    double,                 // NumberFloatType
-    std::allocator,         // AllocatorType
-    nlohmann::adl_serializer,
-    std::vector<std::byte>  // Custom BinaryType
->;
+using custom_json = nlohmann::ordered_json::with_binary_t<std::vector<std::byte>>;
 
 std::vector<std::byte> data{std::byte{1}, std::byte{2}, std::byte{3}};
 custom_json j = data;  // Creates a binary value, not an array

docs/mkdocs/docs/api/basic_json/object_t.md

@@ -26,7 +26,8 @@ To store objects in C++, a type is defined by the template parameters described
 
 `StringType`
 :   the type of the keys or names (e.g., `std::string`). The comparison function `std::less<StringType>` is used to
-    order elements inside the container.
+    order elements inside the container. `object_t::key_type` must be implicitly convertible to `string_t` (required by the
+    binary formats).
 
 `AllocatorType`
 :   the allocator to use for objects (e.g., `std::allocator`)

docs/mkdocs/docs/examples/as_base_class.cpp

@@ -15,19 +15,7 @@ class base_class_with_hidden_members
     }
 };
 
-using json = nlohmann::basic_json <
-             std::map,
-             std::vector,
-             std::string,
-             bool,
-             std::int64_t,
-             std::uint64_t,
-             double,
-             std::allocator,
-             nlohmann::adl_serializer,
-             std::vector<std::uint8_t>,
-             base_class_with_hidden_members
-             >;
+using json = nlohmann::json::with_base_class_t<base_class_with_hidden_members>;
 
 int main()
 {

include/nlohmann/detail/json_pointer.hpp

@@ -16,8 +16,8 @@
     #include <iosfwd> // ostream
 #endif  // JSON_NO_IO
 #include <limits> // max
+#include <map> // map
 #include <numeric> // accumulate
-#include <set> // set
 #include <string> // string
 #include <utility> // move
 #include <vector> // vector
@@ -359,33 +359,82 @@ class json_pointer
 
   private:
     /*!
-    @brief the reference token sequences that denote arrays
+    @brief the pointer prefixes of a flattened object, and which of them denote arrays
 
     @ref unflatten collects the pointer prefixes that have a reference token 0
     among their children; @ref get_and_create creates arrays exactly below
     those prefixes and objects everywhere else. Deciding this up front keeps
     the result independent of the order in which the flattened object is
     iterated, which is unspecified for some object types.
+
+    The prefixes form a tree and are numbered, so each of them is stored only
+    once (as a node) rather than as a copy of all of its reference tokens.
     */
-    using array_parents_t = std::set<std::vector<string_t>>;
+    struct prefix_tree
+    {
+        // children[id] maps a reference token to the number of the prefix
+        // extended by that token; number 0 is the empty prefix
+        std::vector<std::map<string_t, std::size_t>> children;
+        // is_array[id] is true iff some flattened key has the reference token
+        // 0 directly below the prefix with number id
+        std::vector<bool> is_array;
+
+        // start with the empty prefix only
+        prefix_tree()
+            : children(1)
+            , is_array(1, false)
+        {}
+
+        // return the number of the prefix with number id extended by
+        // reference_token, adding it if it is new
+        std::size_t add_child(std::size_t id, string_t&& reference_token)
+        {
+            if (reference_token == "0")
+            {
+                is_array[id] = true;
+            }
+
+            // read the number before the emplace_back below, which may
+            // reallocate children and invalidate the iterator
+            const std::size_t next = children.size();
+            const auto inserted = children[id].emplace(std::move(reference_token), next);
+            const std::size_t child = inserted.first->second;
+            if (inserted.second)
+            {
+                children.emplace_back();
+                is_array.push_back(false);
+            }
+            return child;
+        }
+
+        // return the number of the prefix with number id extended by
+        // reference_token, which must have been added before
+        std::size_t find_child(std::size_t id, const string_t& reference_token) const
+        {
+            const auto it = children[id].find(reference_token);
+            JSON_ASSERT(it != children[id].end());
+            return it->second;
+        }
+    };
 
     /*!
     @brief create and return a reference to the pointed to value
 
-    Complexity: Linear in the number of reference tokens.
+    Complexity: Linear in the number of reference tokens (times the logarithm
+    of the number of siblings for the prefix lookup).
 
     @throw parse_error.106 if an array index begins with '0'
     @throw parse_error.109 if array index is not a number
     @throw type_error.313 if value cannot be unflattened
     */
     template<typename BasicJsonType>
-    BasicJsonType& get_and_create(BasicJsonType& j, const array_parents_t& array_parents) const
+    BasicJsonType& get_and_create(BasicJsonType& j, const prefix_tree& tree) const
     {
         auto* result = &j;
 
-        // the reference tokens that have been consumed so far; used to look up
-        // whether the value to be created below is an array or an object
-        std::vector<string_t> prefix;
+        // the number of the prefix consumed so far; used to look up whether
+        // the value to be created below is an array or an object
+        std::size_t id = 0;
 
         // in case no reference tokens exist, return a reference to the JSON value
         // j which will be overwritten by a primitive value
@@ -395,7 +444,7 @@ class json_pointer
             {
                 case detail::value_t::null:
                 {
-                    if (array_parents.find(prefix) != array_parents.end())
+                    if (tree.is_array[id])
                     {
                         // some reference token below this position is 0, so the
                         // value is an array
@@ -440,7 +489,7 @@ class json_pointer
                     JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
             }
 
-            prefix.push_back(reference_token);
+            id = tree.find_child(id, reference_token);
         }
 
         return *result;
@@ -878,64 +927,131 @@ class json_pointer
     @param[in,out] result        the result object to insert values to
 
     @note Empty objects or arrays are flattened to `null`.
+
+    The value is walked with an explicit stack rather than the call stack, so
+    arbitrarily deeply nested values can be flattened.
+
+    @sa https://github.com/nlohmann/json/issues/5393
     */
     template<typename BasicJsonType>
     static void flatten(const string_t& reference_string,
                         const BasicJsonType& value,
                         BasicJsonType& result)
     {
-        switch (value.type())
+        using object_const_iterator = typename BasicJsonType::object_t::const_iterator;
+
+        // an array or object being walked: the container, the array index or
+        // object iterator of the next child, and the length of the path of the
+        // container itself
+        struct frame
         {
-            case detail::value_t::array:
-            {
-                if (value.m_data.m_value.array->empty())
-                {
-                    // flatten empty array as null
-                    result[reference_string] = nullptr;
-                }
-                else
-                {
-                    // iterate array and use index as a reference string
-                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
-                    {
-                        flatten(detail::concat<string_t>(reference_string, '/', std::to_string(i)),
-                                value.m_data.m_value.array->operator[](i), result);
-                    }
-                }
-                break;
-            }
+            frame(const BasicJsonType* container_, object_const_iterator member_, const std::size_t path_length_) noexcept
+                : container(container_), member(std::move(member_)), path_length(path_length_)
+            {}
 
-            case detail::value_t::object:
-            {
-                if (value.m_data.m_value.object->empty())
-                {
-                    // flatten empty object as null
-                    result[reference_string] = nullptr;
-                }
-                else
-                {
-                    // iterate object and use keys as reference string
-                    for (const auto& element : *value.m_data.m_value.object)
-                    {
-                        flatten(detail::concat<string_t>(reference_string, '/', detail::escape(element.first)), element.second, result);
-                    }
-                }
-                break;
-            }
+            const BasicJsonType* container;
+            std::size_t index = 0;
+            object_const_iterator member;
+            std::size_t path_length;
+        };
 
-            case detail::value_t::null:
-            case detail::value_t::string:
-            case detail::value_t::boolean:
-            case detail::value_t::number_integer:
-            case detail::value_t::number_unsigned:
-            case detail::value_t::number_float:
-            case detail::value_t::binary:
-            case detail::value_t::discarded:
-            default:
+        // The containers being flattened are kept on an explicit stack, and
+        // every child is flattened completely before the next one, so the
+        // entries come out in the same order as with a recursive walk. The
+        // path of the value being flattened is kept in one buffer that grows
+        // and shrinks with the stack, rather than in a new string per level.
+        std::vector<frame> stack;
+        string_t path = reference_string;
+
+        // flatten `v`, whose path is `path`: primitives and empty containers
+        // are added to the result right away; other containers get a frame
+        const auto enter = [&stack, &path, &result](const BasicJsonType & v)
+        {
+            switch (v.type())
             {
-                // add a primitive value with its reference string
-                result[reference_string] = value;
-                break;
+                case detail::value_t::array:
+                {
+                    if (v.m_data.m_value.array->empty())
+                    {
+                        // flatten empty array as null
+                        result[path] = nullptr;
+                    }
+                    else
+                    {
+                        stack.emplace_back(&v, object_const_iterator(), path.size());
+                    }
+                    return;
+                }
+
+                case detail::value_t::object:
+                {
+                    if (v.m_data.m_value.object->empty())
+                    {
+                        // flatten empty object as null
+                        result[path] = nullptr;
+                    }
+                    else
+                    {
+                        stack.emplace_back(&v, v.m_data.m_value.object->begin(), path.size());
+                    }
+                    return;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // add a primitive value with its reference string
+                    result[path] = v;
+                    return;
+                }
+            }
+        };
+
+        enter(value);
+        while (!stack.empty())
+        {
+            // the frame is changed through stack.back(): enter() may push a
+            // frame, which would invalidate a reference to it
+            const BasicJsonType* const container = stack.back().container;
+
+            // drop the path of the previous child
+            path.resize(stack.back().path_length);
+
+            if (container->is_array())
+            {
+                const auto& array = *container->m_data.m_value.array;
+                const std::size_t i = stack.back().index;
+                if (i == array.size())
+                {
+                    stack.pop_back();
+                    continue;
+                }
+
+                // iterate array and use index as a reference string
+                ++stack.back().index;
+                detail::concat_into(path, '/', detail::to_string<string_t>(i));
+                enter(array[i]);
+            }
+            else
+            {
+                const object_const_iterator it = stack.back().member;
+                if (it == container->m_data.m_value.object->end())
+                {
+                    stack.pop_back();
+                    continue;
+                }
+
+                // iterate object and use keys as reference string
+                ++stack.back().member;
+                detail::concat_into(path, '/', detail::escape(it->first));
+                enter(it->second);
             }
         }
     }
@@ -963,19 +1079,15 @@ class json_pointer
 
         // collect the pointer prefixes that have a reference token 0 among
         // their children; the values below them are arrays, all others are
-        // objects (see array_parents_t)
-        array_parents_t array_parents;
+        // objects (see prefix_tree)
+        prefix_tree tree;
         for (const auto& element : *value.m_data.m_value.object)
         {
             json_pointer ptr(element.first);
-            std::vector<string_t> prefix;
+            std::size_t id = 0;
             for (auto& reference_token : ptr.reference_tokens)
             {
-                if (reference_token == "0")
-                {
-                    array_parents.insert(prefix);
-                }
-                prefix.push_back(std::move(reference_token));
+                id = tree.add_child(id, std::move(reference_token));
             }
         }
 
@@ -991,7 +1103,7 @@ class json_pointer
             // that if the JSON pointer is "" (i.e., points to the whole value),
             // function get_and_create returns a reference to the result itself.
             // An assignment will then create a primitive value.
-            json_pointer(element.first).get_and_create(result, array_parents) = element.second;
+            json_pointer(element.first).get_and_create(result, tree) = element.second;
         }
 
         return result;

include/nlohmann/detail/meta/type_traits.hpp

@@ -172,10 +172,6 @@ struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
 template<typename T>
 using detect_key_compare = typename T::key_compare;
 
-// detects whether two values of type T can be compared with operator==
-template<typename T>
-using detect_equal_comparable = decltype(static_cast<bool>(std::declval<const T&>() == std::declval<const T&>()));
-
 // obtains the actual object key comparator: object_t::key_compare if the
 // object type defines it, and default_object_comparator_t otherwise
 //

include/nlohmann/detail/output/binary_writer.hpp

@@ -85,6 +85,12 @@ template<typename BasicJsonType, typename CharType, typename OutputSinkType = ou
 class binary_writer
 {
     using string_t = typename BasicJsonType::string_t;
+
+    /// an object key as string_t: a reference when object_t::key_type already is
+    /// string_t, otherwise a converted copy that outlives sanitize_utf8_for_write's result
+    using object_key_string_t = typename std::conditional <
+                                std::is_same<typename BasicJsonType::object_t::key_type, string_t>::value,
+                                const string_t&, string_t >::type;
     using binary_t = typename BasicJsonType::binary_t;
     using number_float_t = typename BasicJsonType::number_float_t;
 
@@ -307,6 +313,12 @@ class binary_writer
 
             case value_t::object:
             {
+                static_assert(
+                    std::is_convertible <
+                    typename BasicJsonType::object_t::key_type,
+                    string_t >::value,
+                    "object_t::key_type must be implicitly convertible to string_t");
+
                 // step 1: write control byte and the object size
                 write_cbor_head(0xA0, j.m_data.m_value.object->size());
 
@@ -314,7 +326,7 @@ class binary_writer
                 {
                     // el.first is written directly (not via a temporary
                     // basic_json), with the object as diagnostics context
-                    write_cbor_key(el.first, j);
+                    write_cbor_string(el.first, j);
                     write_cbor(el.second, depth + 1);
                 }
                 break;
@@ -579,6 +591,12 @@ class binary_writer
 
             case value_t::object:
             {
+                static_assert(
+                    std::is_convertible <
+                    typename BasicJsonType::object_t::key_type,
+                    string_t >::value,
+                    "object_t::key_type must be implicitly convertible to string_t");
+
                 // step 1: write control byte and the object size
                 write_msgpack_object_prefix(j.m_data.m_value.object->size(), j);
 
@@ -586,7 +604,7 @@ class binary_writer
                 {
                     // as in write_cbor, el.first is written directly with the
                     // object as diagnostics context
-                    write_msgpack_key(el.first, j);
+                    write_msgpack_string(el.first, j);
                     write_msgpack(el.second, depth + 1);
                 }
                 break;
@@ -764,8 +782,10 @@ class binary_writer
 
                 for (const auto& el : *j.m_data.m_value.object)
                 {
+                    // a converted key must outlive the reference returned by sanitize_utf8_for_write
+                    const object_key_string_t key_string = el.first;
                     string_t storage;
-                    const string_t& key = sanitize_utf8_for_write(el.first, j, storage);
+                    const string_t& key = sanitize_utf8_for_write(key_string, j, storage);
                     write_number_with_ubjson_prefix(key.size(), true, use_bjdata);
                     oa.write_characters(
                           reinterpret_cast<const CharType*>(key.data()),
@@ -972,7 +992,7 @@ class binary_writer
 
                 // the key is written directly (not via a temporary basic_json),
                 // with the object as diagnostics context, as in write_cbor
-                write_cbor_key(current.object_it->first, *current.value);
+                write_cbor_string(current.object_it->first, *current.value);
                 const BasicJsonType* child = &(current.object_it->second);
                 ++stack.back().object_it;
                 write_cbor_value_or_push(*child, stack);
@@ -1049,7 +1069,7 @@ class binary_writer
 
                 // as in write_cbor_iterative, the key is written directly with
                 // the object as diagnostics context
-                write_msgpack_key(current.object_it->first, *current.value);
+                write_msgpack_string(current.object_it->first, *current.value);
                 const BasicJsonType* child = &(current.object_it->second);
                 ++stack.back().object_it;
                 write_msgpack_value_or_push(*child, stack);
@@ -1305,8 +1325,10 @@ class binary_writer
                     continue;
                 }
 
+                // a converted key must outlive the reference returned by sanitize_utf8_for_write
+                const object_key_string_t key_string = current.object_it->first;
                 string_t storage;
-                const string_t& key = sanitize_utf8_for_write(current.object_it->first, j, storage);
+                const string_t& key = sanitize_utf8_for_write(key_string, j, storage);
                 write_number_with_ubjson_prefix(key.size(), true, use_bjdata);
                 oa.write_characters(
                       reinterpret_cast<const CharType*>(key.data()),
@@ -1816,6 +1838,7 @@ class binary_writer
         {
             // write entries until the current object or array is done, or an
             // entry is an object or array itself
+            const string_t* nested_name = nullptr;
             const BasicJsonType* nested = nullptr;
             if (current.value->is_object())
             {
@@ -1826,8 +1849,7 @@ class binary_writer
                     ++current.member;
                     if (el.second.is_structured())
                     {
-                        write_bson_entry_header(el.first, el.second.is_object() ? 0x03 : 0x04);
-                        write_number<std::int32_t>(to_bson_length(nested_sizes[next_size++]), true);
+                        nested_name = &el.first;
                         nested = &el.second;
                     }
                     else
@@ -1846,8 +1868,7 @@ class binary_writer
                     ++current.index;
                     if (el.is_structured())
                     {
-                        write_bson_entry_header(index_name, el.is_object() ? 0x03 : 0x04);
-                        write_number<std::int32_t>(to_bson_length(nested_sizes[next_size++]), true);
+                        nested_name = &index_name;
                         nested = &el;
                     }
                     else
@@ -1859,6 +1880,8 @@ class binary_writer
 
             if (nested != nullptr)
             {
+                write_bson_entry_header(*nested_name, nested->is_object() ? 0x03 : 0x04);
+                write_number<std::int32_t>(to_bson_length(nested_sizes[next_size++]), true);
                 parents.push_back(std::move(current));
                 current = bson_frame(nested);
                 continue;
@@ -1926,43 +1949,6 @@ class binary_writer
         }
     }
 
-    /*!
-    @brief write an object key as a CBOR text string
-
-    A key convertible to string_t is written directly. Other key types (only
-    an explicit conversion, or only a to_json overload) go through a temporary
-    basic_json, as in version 3.12.0; the temporary is then the diagnostics
-    context for strict UTF-8 checks.
-    */
-    template<typename Key = typename BasicJsonType::object_t::key_type,
-             enable_if_t<std::is_convertible<Key, string_t>::value, int> = 0>
-    void write_cbor_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& context)
-    {
-        write_cbor_string(key, context);
-    }
-
-    template < typename Key = typename BasicJsonType::object_t::key_type,
-               enable_if_t < !std::is_convertible<Key, string_t>::value, int > = 0 >
-    void write_cbor_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& /*context*/)
-    {
-        write_cbor(BasicJsonType(key));
-    }
-
-    /// @brief write an object key as a MessagePack str, as in @ref write_cbor_key
-    template<typename Key = typename BasicJsonType::object_t::key_type,
-             enable_if_t<std::is_convertible<Key, string_t>::value, int> = 0>
-    void write_msgpack_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& context)
-    {
-        write_msgpack_string(key, context);
-    }
-
-    template < typename Key = typename BasicJsonType::object_t::key_type,
-               enable_if_t < !std::is_convertible<Key, string_t>::value, int > = 0 >
-    void write_msgpack_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& /*context*/)
-    {
-        write_msgpack(BasicJsonType(key));
-    }
-
     /*!
     @brief write a CBOR text string
 
@@ -2784,6 +2770,11 @@ class binary_writer
     itself in every case but a sanitized `replace`/`ignore` one, so @a
     storage must outlive the returned reference only then.
 
+    @a s must be an lvalue that outlives the returned reference. An object key
+    whose `key_type` is not @ref string_t must therefore first be converted
+    into a named string_t (see @ref object_key_string_t); the deleted overload
+    below enforces this at compile time.
+
     @param[in] s        the string (value or object key) to write
     @param[in] context  the value @a s belongs to (for diagnostics)
     @param[out] storage  backing storage for a sanitized copy
@@ -2813,6 +2804,10 @@ class binary_writer
         }
     }
 
+    /// deleted: anything but a string_t would bind a temporary that dies before the returned reference is used
+    template < typename T, enable_if_t < !std::is_same<T, string_t>::value, int > = 0 >
+    const string_t& sanitize_utf8_for_write(const T& /*s*/, const BasicJsonType& /*context*/, string_t& /*storage*/) const = delete; // NOLINT(hicpp-use-equals-delete,modernize-use-equals-delete): a private helper's guard, not part of the interface
+
     /*!
     @brief write an integer in the shortest encoding
 

include/nlohmann/json.hpp

@@ -1421,24 +1421,6 @@ public:
         return create<object_t>(first, last);
     }
 
-    /// @brief compare two object keys for equality, if the key type supports it
-    /// @note object_t only needs operator< for its keys (std::map), so operator==
-    ///       may not exist; the keys are then reported as different, which makes
-    ///       copy_object_level pair the values via object_t::find()
-    template<typename K = typename object_t::key_type,
-             detail::enable_if_t<detail::is_detected<detail::detect_equal_comparable, K>::value, int> = 0>
-    static bool copy_keys_equal(const K& a, const K& b)
-    {
-        return a == b;
-    }
-
-    template < typename K = typename object_t::key_type,
-               detail::enable_if_t < !detail::is_detected<detail::detect_equal_comparable, K>::value, int > = 0 >
-    static bool copy_keys_equal(const K& /*a*/, const K& /*b*/)
-    {
-        return false;
-    }
-
     /// @brief create the copy of the object @a src in @a dst
     /// @note structured values are appended to @a worklist instead
     static void copy_object_level(const basic_json& src, basic_json& dst,
@@ -1471,7 +1453,7 @@ public:
         auto src_it = src_object.cbegin();
         for (auto& element : *dst.m_data.m_value.object)
         {
-            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && copy_keys_equal(src_it->first, element.first)))
+            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && src_it->first == element.first))
             {
                 copy_shallow(src_it->second, element.second, worklist);
                 ++src_it;
@@ -3348,27 +3330,11 @@ public:
             // std::map or ordered_map) never moves from its argument, so key is still
             // valid here regardless of whether KeyType was deduced as an rvalue reference
             // NOLINTNEXTLINE(bugprone-use-after-move,hicpp-invalid-access-moved)
-            JSON_THROW(out_of_range::create(403, detail::concat("key '", key_for_message(key), "' not found"), &j));
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(key), "' not found"), &j));
         }
         return it->second;
     }
 
-    /// @brief key as it is passed to detail::concat for an error message
-    /// @note string_t is used where it can be constructed from the key; other
-    ///       key types are passed through unchanged, as concat only needs
-    ///       data() and size() of them
-    template<typename KeyType, detail::enable_if_t<std::is_constructible<string_t, const KeyType&>::value, int> = 0>
-    static string_t key_for_message(const KeyType& key)
-    {
-        return string_t(key);
-    }
-
-    template < typename KeyType, detail::enable_if_t < !std::is_constructible<string_t, const KeyType&>::value, int > = 0 >
-    static const KeyType & key_for_message(const KeyType& key)
-    {
-        return key;
-    }
-
     /// @brief checked array element access used by the at() overloads taking an index
     /// @throw type_error.304 if @a j is not an array
     /// @throw out_of_range.401 if @a idx is out of range

single_include/nlohmann/json.hpp

@@ -4171,10 +4171,6 @@ struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
 template<typename T>
 using detect_key_compare = typename T::key_compare;
 
-// detects whether two values of type T can be compared with operator==
-template<typename T>
-using detect_equal_comparable = decltype(static_cast<bool>(std::declval<const T&>() == std::declval<const T&>()));
-
 // obtains the actual object key comparator: object_t::key_compare if the
 // object type defines it, and default_object_comparator_t otherwise
 //
@@ -19932,8 +19928,8 @@ NLOHMANN_JSON_NAMESPACE_END
     #include <iosfwd> // ostream
 #endif  // JSON_NO_IO
 #include <limits> // max
+#include <map> // map
 #include <numeric> // accumulate
-#include <set> // set
 #include <string> // string
 #include <utility> // move
 #include <vector> // vector
@@ -20281,33 +20277,82 @@ class json_pointer
 
   private:
     /*!
-    @brief the reference token sequences that denote arrays
+    @brief the pointer prefixes of a flattened object, and which of them denote arrays
 
     @ref unflatten collects the pointer prefixes that have a reference token 0
     among their children; @ref get_and_create creates arrays exactly below
     those prefixes and objects everywhere else. Deciding this up front keeps
     the result independent of the order in which the flattened object is
     iterated, which is unspecified for some object types.
+
+    The prefixes form a tree and are numbered, so each of them is stored only
+    once (as a node) rather than as a copy of all of its reference tokens.
     */
-    using array_parents_t = std::set<std::vector<string_t>>;
+    struct prefix_tree
+    {
+        // children[id] maps a reference token to the number of the prefix
+        // extended by that token; number 0 is the empty prefix
+        std::vector<std::map<string_t, std::size_t>> children;
+        // is_array[id] is true iff some flattened key has the reference token
+        // 0 directly below the prefix with number id
+        std::vector<bool> is_array;
+
+        // start with the empty prefix only
+        prefix_tree()
+            : children(1)
+            , is_array(1, false)
+        {}
+
+        // return the number of the prefix with number id extended by
+        // reference_token, adding it if it is new
+        std::size_t add_child(std::size_t id, string_t&& reference_token)
+        {
+            if (reference_token == "0")
+            {
+                is_array[id] = true;
+            }
+
+            // read the number before the emplace_back below, which may
+            // reallocate children and invalidate the iterator
+            const std::size_t next = children.size();
+            const auto inserted = children[id].emplace(std::move(reference_token), next);
+            const std::size_t child = inserted.first->second;
+            if (inserted.second)
+            {
+                children.emplace_back();
+                is_array.push_back(false);
+            }
+            return child;
+        }
+
+        // return the number of the prefix with number id extended by
+        // reference_token, which must have been added before
+        std::size_t find_child(std::size_t id, const string_t& reference_token) const
+        {
+            const auto it = children[id].find(reference_token);
+            JSON_ASSERT(it != children[id].end());
+            return it->second;
+        }
+    };
 
     /*!
     @brief create and return a reference to the pointed to value
 
-    Complexity: Linear in the number of reference tokens.
+    Complexity: Linear in the number of reference tokens (times the logarithm
+    of the number of siblings for the prefix lookup).
 
     @throw parse_error.106 if an array index begins with '0'
     @throw parse_error.109 if array index is not a number
     @throw type_error.313 if value cannot be unflattened
     */
     template<typename BasicJsonType>
-    BasicJsonType& get_and_create(BasicJsonType& j, const array_parents_t& array_parents) const
+    BasicJsonType& get_and_create(BasicJsonType& j, const prefix_tree& tree) const
     {
         auto* result = &j;
 
-        // the reference tokens that have been consumed so far; used to look up
-        // whether the value to be created below is an array or an object
-        std::vector<string_t> prefix;
+        // the number of the prefix consumed so far; used to look up whether
+        // the value to be created below is an array or an object
+        std::size_t id = 0;
 
         // in case no reference tokens exist, return a reference to the JSON value
         // j which will be overwritten by a primitive value
@@ -20317,7 +20362,7 @@ class json_pointer
             {
                 case detail::value_t::null:
                 {
-                    if (array_parents.find(prefix) != array_parents.end())
+                    if (tree.is_array[id])
                     {
                         // some reference token below this position is 0, so the
                         // value is an array
@@ -20362,7 +20407,7 @@ class json_pointer
                     JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
             }
 
-            prefix.push_back(reference_token);
+            id = tree.find_child(id, reference_token);
         }
 
         return *result;
@@ -20800,64 +20845,131 @@ class json_pointer
     @param[in,out] result        the result object to insert values to
 
     @note Empty objects or arrays are flattened to `null`.
+
+    The value is walked with an explicit stack rather than the call stack, so
+    arbitrarily deeply nested values can be flattened.
+
+    @sa https://github.com/nlohmann/json/issues/5393
     */
     template<typename BasicJsonType>
     static void flatten(const string_t& reference_string,
                         const BasicJsonType& value,
                         BasicJsonType& result)
     {
-        switch (value.type())
+        using object_const_iterator = typename BasicJsonType::object_t::const_iterator;
+
+        // an array or object being walked: the container, the array index or
+        // object iterator of the next child, and the length of the path of the
+        // container itself
+        struct frame
         {
-            case detail::value_t::array:
-            {
-                if (value.m_data.m_value.array->empty())
-                {
-                    // flatten empty array as null
-                    result[reference_string] = nullptr;
-                }
-                else
-                {
-                    // iterate array and use index as a reference string
-                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
-                    {
-                        flatten(detail::concat<string_t>(reference_string, '/', std::to_string(i)),
-                                value.m_data.m_value.array->operator[](i), result);
-                    }
-                }
-                break;
-            }
+            frame(const BasicJsonType* container_, object_const_iterator member_, const std::size_t path_length_) noexcept
+                : container(container_), member(std::move(member_)), path_length(path_length_)
+            {}
 
-            case detail::value_t::object:
-            {
-                if (value.m_data.m_value.object->empty())
-                {
-                    // flatten empty object as null
-                    result[reference_string] = nullptr;
-                }
-                else
-                {
-                    // iterate object and use keys as reference string
-                    for (const auto& element : *value.m_data.m_value.object)
-                    {
-                        flatten(detail::concat<string_t>(reference_string, '/', detail::escape(element.first)), element.second, result);
-                    }
-                }
-                break;
-            }
+            const BasicJsonType* container;
+            std::size_t index = 0;
+            object_const_iterator member;
+            std::size_t path_length;
+        };
 
-            case detail::value_t::null:
-            case detail::value_t::string:
-            case detail::value_t::boolean:
-            case detail::value_t::number_integer:
-            case detail::value_t::number_unsigned:
-            case detail::value_t::number_float:
-            case detail::value_t::binary:
-            case detail::value_t::discarded:
-            default:
+        // The containers being flattened are kept on an explicit stack, and
+        // every child is flattened completely before the next one, so the
+        // entries come out in the same order as with a recursive walk. The
+        // path of the value being flattened is kept in one buffer that grows
+        // and shrinks with the stack, rather than in a new string per level.
+        std::vector<frame> stack;
+        string_t path = reference_string;
+
+        // flatten `v`, whose path is `path`: primitives and empty containers
+        // are added to the result right away; other containers get a frame
+        const auto enter = [&stack, &path, &result](const BasicJsonType & v)
+        {
+            switch (v.type())
             {
-                // add a primitive value with its reference string
-                result[reference_string] = value;
-                break;
+                case detail::value_t::array:
+                {
+                    if (v.m_data.m_value.array->empty())
+                    {
+                        // flatten empty array as null
+                        result[path] = nullptr;
+                    }
+                    else
+                    {
+                        stack.emplace_back(&v, object_const_iterator(), path.size());
+                    }
+                    return;
+                }
+
+                case detail::value_t::object:
+                {
+                    if (v.m_data.m_value.object->empty())
+                    {
+                        // flatten empty object as null
+                        result[path] = nullptr;
+                    }
+                    else
+                    {
+                        stack.emplace_back(&v, v.m_data.m_value.object->begin(), path.size());
+                    }
+                    return;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // add a primitive value with its reference string
+                    result[path] = v;
+                    return;
+                }
+            }
+        };
+
+        enter(value);
+        while (!stack.empty())
+        {
+            // the frame is changed through stack.back(): enter() may push a
+            // frame, which would invalidate a reference to it
+            const BasicJsonType* const container = stack.back().container;
+
+            // drop the path of the previous child
+            path.resize(stack.back().path_length);
+
+            if (container->is_array())
+            {
+                const auto& array = *container->m_data.m_value.array;
+                const std::size_t i = stack.back().index;
+                if (i == array.size())
+                {
+                    stack.pop_back();
+                    continue;
+                }
+
+                // iterate array and use index as a reference string
+                ++stack.back().index;
+                detail::concat_into(path, '/', detail::to_string<string_t>(i));
+                enter(array[i]);
+            }
+            else
+            {
+                const object_const_iterator it = stack.back().member;
+                if (it == container->m_data.m_value.object->end())
+                {
+                    stack.pop_back();
+                    continue;
+                }
+
+                // iterate object and use keys as reference string
+                ++stack.back().member;
+                detail::concat_into(path, '/', detail::escape(it->first));
+                enter(it->second);
             }
         }
     }
@@ -20885,19 +20997,15 @@ class json_pointer
 
         // collect the pointer prefixes that have a reference token 0 among
         // their children; the values below them are arrays, all others are
-        // objects (see array_parents_t)
-        array_parents_t array_parents;
+        // objects (see prefix_tree)
+        prefix_tree tree;
         for (const auto& element : *value.m_data.m_value.object)
         {
             json_pointer ptr(element.first);
-            std::vector<string_t> prefix;
+            std::size_t id = 0;
             for (auto& reference_token : ptr.reference_tokens)
             {
-                if (reference_token == "0")
-                {
-                    array_parents.insert(prefix);
-                }
-                prefix.push_back(std::move(reference_token));
+                id = tree.add_child(id, std::move(reference_token));
             }
         }
 
@@ -20913,7 +21021,7 @@ class json_pointer
             // that if the JSON pointer is "" (i.e., points to the whole value),
             // function get_and_create returns a reference to the result itself.
             // An assignment will then create a primitive value.
-            json_pointer(element.first).get_and_create(result, array_parents) = element.second;
+            json_pointer(element.first).get_and_create(result, tree) = element.second;
         }
 
         return result;
@@ -21594,6 +21702,12 @@ template<typename BasicJsonType, typename CharType, typename OutputSinkType = ou
 class binary_writer
 {
     using string_t = typename BasicJsonType::string_t;
+
+    /// an object key as string_t: a reference when object_t::key_type already is
+    /// string_t, otherwise a converted copy that outlives sanitize_utf8_for_write's result
+    using object_key_string_t = typename std::conditional <
+                                std::is_same<typename BasicJsonType::object_t::key_type, string_t>::value,
+                                const string_t&, string_t >::type;
     using binary_t = typename BasicJsonType::binary_t;
     using number_float_t = typename BasicJsonType::number_float_t;
 
@@ -21816,6 +21930,12 @@ class binary_writer
 
             case value_t::object:
             {
+                static_assert(
+                    std::is_convertible <
+                    typename BasicJsonType::object_t::key_type,
+                    string_t >::value,
+                    "object_t::key_type must be implicitly convertible to string_t");
+
                 // step 1: write control byte and the object size
                 write_cbor_head(0xA0, j.m_data.m_value.object->size());
 
@@ -21823,7 +21943,7 @@ class binary_writer
                 {
                     // el.first is written directly (not via a temporary
                     // basic_json), with the object as diagnostics context
-                    write_cbor_key(el.first, j);
+                    write_cbor_string(el.first, j);
                     write_cbor(el.second, depth + 1);
                 }
                 break;
@@ -22088,6 +22208,12 @@ class binary_writer
 
             case value_t::object:
             {
+                static_assert(
+                    std::is_convertible <
+                    typename BasicJsonType::object_t::key_type,
+                    string_t >::value,
+                    "object_t::key_type must be implicitly convertible to string_t");
+
                 // step 1: write control byte and the object size
                 write_msgpack_object_prefix(j.m_data.m_value.object->size(), j);
 
@@ -22095,7 +22221,7 @@ class binary_writer
                 {
                     // as in write_cbor, el.first is written directly with the
                     // object as diagnostics context
-                    write_msgpack_key(el.first, j);
+                    write_msgpack_string(el.first, j);
                     write_msgpack(el.second, depth + 1);
                 }
                 break;
@@ -22273,8 +22399,10 @@ class binary_writer
 
                 for (const auto& el : *j.m_data.m_value.object)
                 {
+                    // a converted key must outlive the reference returned by sanitize_utf8_for_write
+                    const object_key_string_t key_string = el.first;
                     string_t storage;
-                    const string_t& key = sanitize_utf8_for_write(el.first, j, storage);
+                    const string_t& key = sanitize_utf8_for_write(key_string, j, storage);
                     write_number_with_ubjson_prefix(key.size(), true, use_bjdata);
                     oa.write_characters(
                           reinterpret_cast<const CharType*>(key.data()),
@@ -22481,7 +22609,7 @@ class binary_writer
 
                 // the key is written directly (not via a temporary basic_json),
                 // with the object as diagnostics context, as in write_cbor
-                write_cbor_key(current.object_it->first, *current.value);
+                write_cbor_string(current.object_it->first, *current.value);
                 const BasicJsonType* child = &(current.object_it->second);
                 ++stack.back().object_it;
                 write_cbor_value_or_push(*child, stack);
@@ -22558,7 +22686,7 @@ class binary_writer
 
                 // as in write_cbor_iterative, the key is written directly with
                 // the object as diagnostics context
-                write_msgpack_key(current.object_it->first, *current.value);
+                write_msgpack_string(current.object_it->first, *current.value);
                 const BasicJsonType* child = &(current.object_it->second);
                 ++stack.back().object_it;
                 write_msgpack_value_or_push(*child, stack);
@@ -22814,8 +22942,10 @@ class binary_writer
                     continue;
                 }
 
+                // a converted key must outlive the reference returned by sanitize_utf8_for_write
+                const object_key_string_t key_string = current.object_it->first;
                 string_t storage;
-                const string_t& key = sanitize_utf8_for_write(current.object_it->first, j, storage);
+                const string_t& key = sanitize_utf8_for_write(key_string, j, storage);
                 write_number_with_ubjson_prefix(key.size(), true, use_bjdata);
                 oa.write_characters(
                       reinterpret_cast<const CharType*>(key.data()),
@@ -23325,6 +23455,7 @@ class binary_writer
         {
             // write entries until the current object or array is done, or an
             // entry is an object or array itself
+            const string_t* nested_name = nullptr;
             const BasicJsonType* nested = nullptr;
             if (current.value->is_object())
             {
@@ -23335,8 +23466,7 @@ class binary_writer
                     ++current.member;
                     if (el.second.is_structured())
                     {
-                        write_bson_entry_header(el.first, el.second.is_object() ? 0x03 : 0x04);
-                        write_number<std::int32_t>(to_bson_length(nested_sizes[next_size++]), true);
+                        nested_name = &el.first;
                         nested = &el.second;
                     }
                     else
@@ -23355,8 +23485,7 @@ class binary_writer
                     ++current.index;
                     if (el.is_structured())
                     {
-                        write_bson_entry_header(index_name, el.is_object() ? 0x03 : 0x04);
-                        write_number<std::int32_t>(to_bson_length(nested_sizes[next_size++]), true);
+                        nested_name = &index_name;
                         nested = &el;
                     }
                     else
@@ -23368,6 +23497,8 @@ class binary_writer
 
             if (nested != nullptr)
             {
+                write_bson_entry_header(*nested_name, nested->is_object() ? 0x03 : 0x04);
+                write_number<std::int32_t>(to_bson_length(nested_sizes[next_size++]), true);
                 parents.push_back(std::move(current));
                 current = bson_frame(nested);
                 continue;
@@ -23435,43 +23566,6 @@ class binary_writer
         }
     }
 
-    /*!
-    @brief write an object key as a CBOR text string
-
-    A key convertible to string_t is written directly. Other key types (only
-    an explicit conversion, or only a to_json overload) go through a temporary
-    basic_json, as in version 3.12.0; the temporary is then the diagnostics
-    context for strict UTF-8 checks.
-    */
-    template<typename Key = typename BasicJsonType::object_t::key_type,
-             enable_if_t<std::is_convertible<Key, string_t>::value, int> = 0>
-    void write_cbor_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& context)
-    {
-        write_cbor_string(key, context);
-    }
-
-    template < typename Key = typename BasicJsonType::object_t::key_type,
-               enable_if_t < !std::is_convertible<Key, string_t>::value, int > = 0 >
-    void write_cbor_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& /*context*/)
-    {
-        write_cbor(BasicJsonType(key));
-    }
-
-    /// @brief write an object key as a MessagePack str, as in @ref write_cbor_key
-    template<typename Key = typename BasicJsonType::object_t::key_type,
-             enable_if_t<std::is_convertible<Key, string_t>::value, int> = 0>
-    void write_msgpack_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& context)
-    {
-        write_msgpack_string(key, context);
-    }
-
-    template < typename Key = typename BasicJsonType::object_t::key_type,
-               enable_if_t < !std::is_convertible<Key, string_t>::value, int > = 0 >
-    void write_msgpack_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& /*context*/)
-    {
-        write_msgpack(BasicJsonType(key));
-    }
-
     /*!
     @brief write a CBOR text string
 
@@ -24293,6 +24387,11 @@ class binary_writer
     itself in every case but a sanitized `replace`/`ignore` one, so @a
     storage must outlive the returned reference only then.
 
+    @a s must be an lvalue that outlives the returned reference. An object key
+    whose `key_type` is not @ref string_t must therefore first be converted
+    into a named string_t (see @ref object_key_string_t); the deleted overload
+    below enforces this at compile time.
+
     @param[in] s        the string (value or object key) to write
     @param[in] context  the value @a s belongs to (for diagnostics)
     @param[out] storage  backing storage for a sanitized copy
@@ -24322,6 +24421,10 @@ class binary_writer
         }
     }
 
+    /// deleted: anything but a string_t would bind a temporary that dies before the returned reference is used
+    template < typename T, enable_if_t < !std::is_same<T, string_t>::value, int > = 0 >
+    const string_t& sanitize_utf8_for_write(const T& /*s*/, const BasicJsonType& /*context*/, string_t& /*storage*/) const = delete; // NOLINT(hicpp-use-equals-delete,modernize-use-equals-delete): a private helper's guard, not part of the interface
+
     /*!
     @brief write an integer in the shortest encoding
 
@@ -29188,24 +29291,6 @@ public:
         return create<object_t>(first, last);
     }
 
-    /// @brief compare two object keys for equality, if the key type supports it
-    /// @note object_t only needs operator< for its keys (std::map), so operator==
-    ///       may not exist; the keys are then reported as different, which makes
-    ///       copy_object_level pair the values via object_t::find()
-    template<typename K = typename object_t::key_type,
-             detail::enable_if_t<detail::is_detected<detail::detect_equal_comparable, K>::value, int> = 0>
-    static bool copy_keys_equal(const K& a, const K& b)
-    {
-        return a == b;
-    }
-
-    template < typename K = typename object_t::key_type,
-               detail::enable_if_t < !detail::is_detected<detail::detect_equal_comparable, K>::value, int > = 0 >
-    static bool copy_keys_equal(const K& /*a*/, const K& /*b*/)
-    {
-        return false;
-    }
-
     /// @brief create the copy of the object @a src in @a dst
     /// @note structured values are appended to @a worklist instead
     static void copy_object_level(const basic_json& src, basic_json& dst,
@@ -29238,7 +29323,7 @@ public:
         auto src_it = src_object.cbegin();
         for (auto& element : *dst.m_data.m_value.object)
         {
-            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && copy_keys_equal(src_it->first, element.first)))
+            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && src_it->first == element.first))
             {
                 copy_shallow(src_it->second, element.second, worklist);
                 ++src_it;
@@ -31115,27 +31200,11 @@ public:
             // std::map or ordered_map) never moves from its argument, so key is still
             // valid here regardless of whether KeyType was deduced as an rvalue reference
             // NOLINTNEXTLINE(bugprone-use-after-move,hicpp-invalid-access-moved)
-            JSON_THROW(out_of_range::create(403, detail::concat("key '", key_for_message(key), "' not found"), &j));
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(key), "' not found"), &j));
         }
         return it->second;
     }
 
-    /// @brief key as it is passed to detail::concat for an error message
-    /// @note string_t is used where it can be constructed from the key; other
-    ///       key types are passed through unchanged, as concat only needs
-    ///       data() and size() of them
-    template<typename KeyType, detail::enable_if_t<std::is_constructible<string_t, const KeyType&>::value, int> = 0>
-    static string_t key_for_message(const KeyType& key)
-    {
-        return string_t(key);
-    }
-
-    template < typename KeyType, detail::enable_if_t < !std::is_constructible<string_t, const KeyType&>::value, int > = 0 >
-    static const KeyType & key_for_message(const KeyType& key)
-    {
-        return key;
-    }
-
     /// @brief checked array element access used by the at() overloads taking an index
     /// @throw type_error.304 if @a j is not an array
     /// @throw out_of_range.401 if @a idx is out of range

tests/src/custom_object_key_type.hpp

@@ -71,5 +71,5 @@ class object
     using base_type::base_type;
 };
 
-using json = nlohmann::json::with_object_t<object>;
+using json = nlohmann::basic_json<object>;
 } // namespace custom_object_key_test

tests/src/unit-binary_utf8_error_handler.cpp

@@ -12,7 +12,11 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
+#include <array>
+#include <map>
+#include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace
@@ -55,6 +59,53 @@ std::string dump_and_parse(const std::string& raw, eh error_handler)
     return json::parse(json(raw).dump(-1, ' ', false, error_handler)).get<std::string>();
 }
 
+// an object key type that is not string_t, but converts implicitly to it;
+// data() is only used when JSON_DIAGNOSTICS is enabled
+DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-member-function")
+class converting_key
+{
+  public:
+    converting_key(const char* s) : m_value(s) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
+    converting_key(std::string s) : m_value(std::move(s)) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
+
+    // the conversion yields a temporary string_t
+    operator std::string() const // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
+    {
+        return m_value;
+    }
+
+    // read by the exception messages when JSON_DIAGNOSTICS is enabled
+    const char* data() const noexcept
+    {
+        return m_value.data();
+    }
+
+    friend bool operator<(const converting_key& lhs, const converting_key& rhs)
+    {
+        return lhs.m_value < rhs.m_value;
+    }
+
+  private:
+    std::string m_value;
+};
+DOCTEST_CLANG_SUPPRESS_WARNING_POP
+
+// ObjectType using converting_key; the Key template argument is ignored
+template<typename Key, typename Value, typename Compare, typename Allocator>
+class converting_key_object : public std::map<converting_key, Value, std::less<converting_key>, // NOLINT(modernize-use-transparent-functors)
+    typename std::allocator_traits<Allocator>::template rebind_alloc<std::pair<const converting_key, Value>>>
+{
+    using base_type = std::map<converting_key, Value, std::less<converting_key>, // NOLINT(modernize-use-transparent-functors)
+                               typename std::allocator_traits<Allocator>::template rebind_alloc<std::pair<const converting_key, Value>>>;
+
+                             public:
+                               using base_type::base_type;
+                               using base_type::operator=;
+};
+
+using converting_key_json = nlohmann::basic_json<converting_key_object>;
+
 } // namespace
 
 TEST_CASE("UTF-8 error_handler for the binary readers and writers")
@@ -370,3 +421,109 @@ TEST_CASE("UTF-8 error_handler for the binary readers and writers")
         CHECK(json::from_bson(bson_bytes)["k"].get<std::string>() == ill_formed_cases()[0].bytes);
     }
 }
+
+// The UBJSON and BJData writers bind the (possibly sanitized) key to a const
+// string_t&. If key_type is not string_t but converts to it, the converted
+// temporary must outlive that reference; this was a use-after-scope found by
+// AddressSanitizer. Keys exceed the small string optimization on purpose.
+TEST_CASE("UBJSON and BJData writers with an object_t whose key_type is not string_t")
+{
+    const std::string long_prefix(70, 'k');
+
+    SECTION("well-formed keys, every error_handler")
+    {
+        const std::string key1 = long_prefix + "-first";
+        const std::string key2 = long_prefix + "-second";
+
+        converting_key_json::object_t o;
+        o.emplace(converting_key(key1), 1);
+        o.emplace(converting_key(key2), "value");
+        const converting_key_json v(std::move(o));
+
+        json expected;
+        expected[key1] = 1;
+        expected[key2] = "value";
+
+        const std::array<std::pair<bool, bool>, 3> combos = {{{false, false}, {true, false}, {true, true}}};
+        for (const auto h : all_handlers())
+        {
+            CAPTURE(static_cast<int>(h))
+            for (const auto& combo : combos)
+            {
+                const bool use_count = combo.first;
+                const bool use_type = combo.second;
+                CAPTURE(use_count)
+                CAPTURE(use_type)
+
+                CHECK(json::from_ubjson(converting_key_json::to_ubjson(v, use_count, use_type, h)) == expected);
+                CHECK(json::from_bjdata(converting_key_json::to_bjdata(v, use_count, use_type, json::bjdata_version_t::draft2, h)) == expected);
+                CHECK(json::from_bjdata(converting_key_json::to_bjdata(v, use_count, use_type, json::bjdata_version_t::draft3, h)) == expected);
+            }
+        }
+    }
+
+    SECTION("ill-formed keys")
+    {
+        for (const auto& c : ill_formed_cases())
+        {
+            CAPTURE(c.name)
+            const std::string key = long_prefix + c.bytes;
+
+            converting_key_json::object_t o;
+            o.emplace(converting_key(key), 1);
+            const converting_key_json v(std::move(o));
+
+            CHECK_THROWS_AS(converting_key_json::to_ubjson(v, false, false, eh::strict), converting_key_json::type_error&);
+            CHECK_THROWS_AS(converting_key_json::to_bjdata(v, false, false, json::bjdata_version_t::draft2, eh::strict), converting_key_json::type_error&);
+
+            for (const auto h :
+                    {
+                        eh::replace, eh::ignore
+                    })
+            {
+                CAPTURE(static_cast<int>(h))
+                const std::string expected = dump_and_parse(key, h);
+
+                CHECK(json::from_ubjson(converting_key_json::to_ubjson(v, false, false, h)).begin().key() == expected);
+                CHECK(json::from_bjdata(converting_key_json::to_bjdata(v, false, false, json::bjdata_version_t::draft2, h)).begin().key() == expected);
+            }
+
+            CHECK(json::from_ubjson(converting_key_json::to_ubjson(v, false, false, eh::keep)).begin().key() == key);
+            CHECK(json::from_bjdata(converting_key_json::to_bjdata(v, false, false, json::bjdata_version_t::draft2, eh::keep)).begin().key() == key);
+        }
+    }
+
+    SECTION("nested deeper than the recursion limit")
+    {
+        // wrap the previous value, innermost first
+        converting_key_json v = 42;
+        json expected = 42;
+        for (int i = 199; i >= 0; --i)
+        {
+            const std::string key = "level-" + std::to_string(i) + "-" + std::string(64, 'x');
+
+            converting_key_json::object_t o;
+            o.emplace(converting_key(key), std::move(v));
+            v = converting_key_json(std::move(o));
+
+            json e;
+            e[key] = std::move(expected);
+            expected = std::move(e);
+        }
+
+        for (const auto h : all_handlers())
+        {
+            CAPTURE(static_cast<int>(h))
+            for (const bool use_count :
+                    {
+                        false, true
+                    })
+            {
+                CAPTURE(use_count)
+
+                CHECK(json::from_ubjson(converting_key_json::to_ubjson(v, use_count, false, h)) == expected);
+                CHECK(json::from_bjdata(converting_key_json::to_bjdata(v, use_count, false, json::bjdata_version_t::draft2, h)) == expected);
+            }
+        }
+    }
+}

tests/src/unit-bson.cpp

@@ -46,9 +46,7 @@ class huge_binary_t : public std::vector<std::uint8_t>
     }
 };
 
-using huge_binary_json = nlohmann::basic_json <
-                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
-                         double, std::allocator, nlohmann::adl_serializer, huge_binary_t, void >;
+using huge_binary_json = nlohmann::json::with_binary_t<huge_binary_t>;
 
 // a string type that can be made to report a size beyond INT32_MAX without
 // allocating that much memory, so BSON length overflow can be tested for
@@ -96,9 +94,7 @@ class huge_string_t : public std::string
     bool pretend_huge = false;
 };
 
-using huge_string_json = nlohmann::basic_json <
-                         std::map, std::vector, huge_string_t, bool, std::int64_t, std::uint64_t,
-                         double, std::allocator, nlohmann::adl_serializer, std::vector<std::uint8_t>, void >;
+using huge_string_json = nlohmann::json::with_string_t<huge_string_t>;
 } // namespace
 
 TEST_CASE("BSON")

tests/src/unit-custom-base-class.cpp

@@ -400,20 +400,7 @@ class base_class_with_hidden_members
     std::size_t m_size = 42;
 };
 
-using json_with_hidden_base_members =
-    nlohmann::basic_json <
-    std::map,
-    std::vector,
-    std::string,
-    bool,
-    std::int64_t,
-    std::uint64_t,
-    double,
-    std::allocator,
-    nlohmann::adl_serializer,
-    std::vector<std::uint8_t>,
-    base_class_with_hidden_members
-    >;
+using json_with_hidden_base_members = nlohmann::json::with_base_class_t<base_class_with_hidden_members>;
 
 TEST_CASE("JSON Node as_base_class")
 {
@@ -459,19 +446,7 @@ struct const_member_base
     const int id = 7; // NOLINT(misc-non-private-member-variables-in-classes)
 };
 
-using json_with_const_base = nlohmann::basic_json <
-                             std::map,
-                             std::vector,
-                             std::string,
-                             bool,
-                             std::int64_t,
-                             std::uint64_t,
-                             double,
-                             std::allocator,
-                             nlohmann::adl_serializer,
-                             std::vector<std::uint8_t>,
-                             const_member_base
-                             >;
+using json_with_const_base = nlohmann::json::with_base_class_t<const_member_base>;
 
 // build an array nested @a depth levels deep, with the innermost value 1;
 // every level is constructed (never assigned), since const_member_base does

tests/src/unit-custom-binary-type.cpp

@@ -26,15 +26,11 @@ namespace
 
 // a BinaryType whose value type is signed: the elements must still be
 // processed as the numbers 0..255
-using char_binary_json = nlohmann::basic_json <
-                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
-                         double, std::allocator, nlohmann::adl_serializer, std::vector<char>, void >;
+using char_binary_json = nlohmann::json::with_binary_t<std::vector<char>>;
 
 #ifdef JSON_HAS_CPP_17
     // a BinaryType whose value type is not an integer type at all
-    using byte_binary_json = nlohmann::basic_json <
-    std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
-    double, std::allocator, nlohmann::adl_serializer, std::vector<std::byte>, void >;
+    using byte_binary_json = nlohmann::json::with_binary_t<std::vector<std::byte>>;
 #endif
 
 } // namespace

tests/src/unit-custom-object-key-type.cpp

@@ -1,501 +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.hpp>
-
-#include <cstddef>
-#include <cstdint>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-// Object types with a user-defined key type. The key types differ in what they
-// offer to the library: a conversion to std::string (implicit or explicit), a
-// comparison with ==, a to_json overload, or a c_str() member.
-
-namespace custom_key_test
-{
-class key_base
-{
-  public:
-    key_base() = default;
-
-    key_base(const char* value)
-        : m_value(value)
-    {}
-
-    key_base(std::string value)
-        : m_value(std::move(value))
-    {}
-
-    // Required by JSON_DIAGNOSTICS, which reads object keys through data()
-    // when building the path of an exception.
-    const char* data() const noexcept
-    {
-        return m_value.data();
-    }
-
-    friend bool operator<(const key_base& lhs, const key_base& rhs)
-    {
-        return lhs.m_value < rhs.m_value;
-    }
-
-  protected:
-    std::string m_value;
-};
-
-// implicit conversion to std::string and operator==
-class key_full : public key_base
-{
-  public:
-    key_full() = default;
-    using key_base::key_base;
-
-    operator std::string() const
-    {
-        return m_value;
-    }
-
-    friend bool operator==(const key_full& lhs, const key_full& rhs)
-    {
-        return lhs.m_value == rhs.m_value;
-    }
-};
-
-// implicit conversion to std::string, but no operator==
-class key_no_eq : public key_base
-{
-  public:
-    key_no_eq() = default;
-    using key_base::key_base;
-
-    operator std::string() const
-    {
-        return m_value;
-    }
-};
-
-// explicit conversion to std::string, no operator==
-class key_explicit : public key_base
-{
-  public:
-    key_explicit() = default;
-    using key_base::key_base;
-
-    explicit operator std::string() const
-    {
-        return m_value;
-    }
-};
-
-// no conversion at all, only a to_json overload, no operator==
-class key_to_json : public key_base
-{
-  public:
-    key_to_json() = default;
-    using key_base::key_base;
-
-    const std::string& value() const
-    {
-        return m_value;
-    }
-};
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, const key_to_json& k)
-{
-    j = k.value();
-}
-
-// like key_to_json, but with size() and c_str()
-class key_c_str : public key_base
-{
-  public:
-    key_c_str() = default;
-    using key_base::key_base;
-
-    const std::string& value() const
-    {
-        return m_value;
-    }
-
-    std::size_t size() const
-    {
-        return m_value.size();
-    }
-
-    const char* c_str() const
-    {
-        return m_value.c_str();
-    }
-};
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, const key_c_str& k)
-{
-    j = k.value();
-}
-
-// std::map with key type K, ignoring the key type basic_json passes
-template<class K>
-struct object_for
-{
-    template<class Key, class Value, class Compare, class Allocator>
-    using pair_allocator = typename std::allocator_traits<Allocator>::template rebind_alloc<std::pair<const K, Value>>;
-
-    template<class Key, class Value, class Compare, class Allocator>
-    using type = std::map<K, Value, std::less<K>, pair_allocator<Key, Value, Compare, Allocator>>; // NOLINT(modernize-use-transparent-functors)
-};
-
-using json_full = nlohmann::json::with_object_t<object_for<key_full>::type>;
-using json_no_eq = nlohmann::json::with_object_t<object_for<key_no_eq>::type>;
-using json_explicit = nlohmann::json::with_object_t<object_for<key_explicit>::type>;
-using json_to_json = nlohmann::json::with_object_t<object_for<key_to_json>::type>;
-using json_c_str = nlohmann::json::with_object_t<object_for<key_c_str>::type>;
-
-// a key that is long enough to need a length byte in CBOR and MessagePack
-const char* long_key_name(std::size_t i, std::string& storage);
-const char* long_key_name(std::size_t i, std::string& storage)
-{
-    storage = "a key longer than thirty-one characters " + std::to_string(i);
-    return storage.c_str();
-}
-
-// name of the key at nesting level i of a deep value
-std::string deep_name(std::size_t i, bool long_keys);
-std::string deep_name(std::size_t i, bool long_keys)
-{
-    std::string storage;
-    return (long_keys && i % 2 == 1) ? std::string(long_key_name(i, storage)) : "k" + std::to_string(i);
-}
-
-// {"a": 1, "b": [true, null, "x"], "c": {"d": 2.5}, <keys of 23, 36, and 300 characters>}
-// 23 is the longest CBOR length stored in the initial byte; 36 needs one
-// length byte in CBOR and MessagePack, 300 needs two
-template<class J>
-J make_shallow()
-{
-    using key_t = typename J::object_t::key_type;
-
-    J array = J::array();
-    array.push_back(J(true));
-    array.push_back(J(nullptr));
-    array.push_back(J("x"));
-
-    typename J::object_t inner;
-    inner.emplace(key_t("d"), J(2.5));
-
-    typename J::object_t object;
-    object.emplace(key_t("a"), J(1));
-    object.emplace(key_t("b"), std::move(array));
-    object.emplace(key_t("c"), J(std::move(inner)));
-    object.emplace(key_t(std::string(23, 'x')), J(2));
-    object.emplace(key_t(std::string(36, 'y')), J(3));
-    object.emplace(key_t(std::string(300, 'z')), J(4));
-    return J(std::move(object));
-}
-
-// {"k0": {"k1": {... {"k<depth-1>": 1} ...}}}
-template<class J>
-J make_deep(std::size_t depth, bool long_keys)
-{
-    using key_t = typename J::object_t::key_type;
-
-    J value = 1;
-    for (std::size_t i = depth; i > 0; --i)
-    {
-        typename J::object_t object;
-        object.emplace(key_t(deep_name(i - 1, long_keys)), std::move(value));
-        value = J(std::move(object));
-    }
-    return value;
-}
-
-std::size_t deep_depth();
-std::size_t deep_depth()
-{
-    return nlohmann::detail::recursion_depth_limit() + 10;
-}
-
-// walk down the nesting levels without recursion and check the leaf
-template<class J>
-bool check_deep(const J& value, std::size_t depth, bool long_keys)
-{
-    using key_t = typename J::object_t::key_type;
-
-    const J* current = &value;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        if (!current->is_object() || current->size() != 1)
-        {
-            return false;
-        }
-        const auto it = current->find(key_t(deep_name(i, long_keys)));
-        if (it == current->end())
-        {
-            return false;
-        }
-        current = &it.value();
-    }
-    return current->is_number_integer() && current->template get<int>() == 1;
-}
-
-template<class J>
-bool check_shallow(const J& value)
-{
-    using key_t = typename J::object_t::key_type;
-
-    if (!value.is_object() || value.size() != 6)
-    {
-        return false;
-    }
-
-    const auto a = value.find(key_t("a"));
-    const auto b = value.find(key_t("b"));
-    const auto c = value.find(key_t("c"));
-    if (a == value.end() || b == value.end() || c == value.end())
-    {
-        return false;
-    }
-
-    const auto d = c->find(key_t("d"));
-    // basic_json::operator== needs operator== on the keys, which most of the
-    // key types do not have, so the values are checked through get<>()
-    return a->template get<int>() == 1
-    && b->is_array() && b->size() == 3 && (*b)[0].template get<bool>() && (*b)[1].is_null()
-    && (*b)[2].template get<std::string>() == "x"
-    && d != c->end() && d->template get<double>() == 2.5
-    && value.find(key_t(std::string(23, 'x')))->template get<int>() == 2
-    && value.find(key_t(std::string(36, 'y')))->template get<int>() == 3
-    && value.find(key_t(std::string(300, 'z')))->template get<int>() == 4;
-}
-
-template<class J>
-bool is_missing(const J& value, const char* name)
-{
-    return value.find(typename J::object_t::key_type(name)) == value.end();
-}
-
-// member access through find(): at() does not compile for key types without
-// size() or a conversion to string_t (key_to_json), as in version 3.12.0
-template<class J>
-const J& member(const J& value, const char* name)
-{
-    const auto it = value.find(typename J::object_t::key_type(name));
-    REQUIRE(it != value.end());
-    return *it;
-}
-} // namespace custom_key_test
-
-TEST_CASE_TEMPLATE("custom object key types: copy", J,
-                   custom_key_test::json_full, custom_key_test::json_no_eq, custom_key_test::json_explicit,
-                   custom_key_test::json_to_json, custom_key_test::json_c_str)
-{
-    SECTION("shallow")
-    {
-        const J original = custom_key_test::make_shallow<J>();
-        REQUIRE(custom_key_test::check_shallow(original));
-
-        const J copy(original); // NOLINT(performance-unnecessary-copy-initialization)
-        CHECK(custom_key_test::check_shallow(copy));
-
-        J assigned;
-        assigned = original;
-        CHECK(custom_key_test::check_shallow(assigned));
-
-        // the original is unchanged
-        CHECK(custom_key_test::check_shallow(original));
-    }
-
-    SECTION("deep")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-
-        const J original = custom_key_test::make_deep<J>(depth, false);
-        REQUIRE(custom_key_test::check_deep(original, depth, false));
-
-        const J copy(original); // NOLINT(performance-unnecessary-copy-initialization)
-        CHECK(custom_key_test::check_deep(copy, depth, false));
-
-        J assigned;
-        assigned = original;
-        CHECK(custom_key_test::check_deep(assigned, depth, false));
-
-        CHECK(custom_key_test::check_deep(original, depth, false));
-    }
-}
-
-TEST_CASE_TEMPLATE("custom object key types: parse", J,
-                   custom_key_test::json_full, custom_key_test::json_no_eq, custom_key_test::json_explicit,
-                   custom_key_test::json_to_json, custom_key_test::json_c_str)
-{
-    const J j = J::parse(R"({"a":1,"b":{"c":[1,2]}})");
-
-    CHECK(j.size() == 2);
-    CHECK(custom_key_test::member(j, "a").template get<int>() == 1);
-    CHECK(custom_key_test::member(custom_key_test::member(j, "b"), "c").size() == 2);
-    CHECK(custom_key_test::member(custom_key_test::member(j, "b"), "c")[1].template get<int>() == 2);
-
-    // a deeply nested document
-    const std::size_t depth = custom_key_test::deep_depth();
-    std::string text;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        text += "{\"k" + std::to_string(i) + "\":";
-    }
-    text += "1";
-    text.append(depth, '}');
-    CHECK(custom_key_test::check_deep(J::parse(text), depth, false));
-}
-
-TEST_CASE_TEMPLATE("custom object key types: merge_patch, update, and insert", J,
-                   custom_key_test::json_full, custom_key_test::json_no_eq, custom_key_test::json_explicit,
-                   custom_key_test::json_to_json, custom_key_test::json_c_str)
-{
-    SECTION("merge_patch")
-    {
-        J j = J::parse(R"({"a":1,"b":2,"n":{"x":1,"y":2}})");
-        j.merge_patch(J::parse(R"({"b":null,"c":3,"n":{"y":null,"z":3}})"));
-
-        CHECK(j.size() == 3);
-        CHECK(custom_key_test::member(j, "a").template get<int>() == 1);
-        CHECK(custom_key_test::is_missing(j, "b"));
-        CHECK(custom_key_test::member(j, "c").template get<int>() == 3);
-        CHECK(custom_key_test::member(j, "n").size() == 2);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "x").template get<int>() == 1);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "z").template get<int>() == 3);
-    }
-
-    SECTION("update")
-    {
-        J j = J::parse(R"({"a":1,"b":2,"n":{"x":1}})");
-        const J other = J::parse(R"({"b":3,"c":4,"n":{"y":2}})");
-
-        J replaced = j;
-        replaced.update(other);
-        CHECK(replaced.size() == 4);
-        CHECK(custom_key_test::member(replaced, "a").template get<int>() == 1);
-        CHECK(custom_key_test::member(replaced, "b").template get<int>() == 3);
-        CHECK(custom_key_test::member(replaced, "c").template get<int>() == 4);
-        CHECK(custom_key_test::member(replaced, "n").size() == 1);
-        CHECK(custom_key_test::member(custom_key_test::member(replaced, "n"), "y").template get<int>() == 2);
-
-        j.update(other, true);
-        CHECK(j.size() == 4);
-        CHECK(custom_key_test::member(j, "n").size() == 2);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "x").template get<int>() == 1);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "y").template get<int>() == 2);
-    }
-
-    SECTION("insert")
-    {
-        J j = J::parse(R"({"a":1,"b":2})");
-        const J other = J::parse(R"({"b":3,"c":4})");
-        j.insert(other.begin(), other.end());
-
-        CHECK(j.size() == 3);
-        CHECK(custom_key_test::member(j, "b").template get<int>() == 2);
-        CHECK(custom_key_test::member(j, "c").template get<int>() == 4);
-    }
-}
-
-TEST_CASE_TEMPLATE("custom object key types: at() reports a missing key", J,
-                   custom_key_test::json_full, custom_key_test::json_no_eq, custom_key_test::json_explicit,
-                   custom_key_test::json_c_str)
-{
-    // not for key_to_json: at() needs the key's size() or a conversion to
-    // string_t for its error message, which also was the case in version 3.12.0
-    J j = J::parse(R"({"a":1})");
-    const J& j_const = j;
-
-    CHECK(j.at("a").template get<int>() == 1);
-    CHECK(j_const.at("a").template get<int>() == 1);
-    CHECK_THROWS_WITH_AS(j.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", typename J::out_of_range&);
-    CHECK_THROWS_WITH_AS(j_const.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", typename J::out_of_range&);
-}
-
-TEST_CASE_TEMPLATE("custom object key types: BSON", J,
-                   custom_key_test::json_full, custom_key_test::json_no_eq)
-{
-    SECTION("shallow")
-    {
-        const J value = custom_key_test::make_shallow<J>();
-        const nlohmann::json expected = custom_key_test::make_shallow<nlohmann::json>();
-
-        const std::vector<std::uint8_t> encoded = J::to_bson(value);
-        CHECK(encoded == nlohmann::json::to_bson(expected));
-        CHECK(nlohmann::json::from_bson(encoded) == expected);
-    }
-
-    SECTION("deep")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-        const J value = custom_key_test::make_deep<J>(depth, false);
-        const nlohmann::json expected = custom_key_test::make_deep<nlohmann::json>(depth, false);
-
-        const std::vector<std::uint8_t> encoded = J::to_bson(value);
-        CHECK(encoded == nlohmann::json::to_bson(expected));
-        CHECK(nlohmann::json::from_bson(encoded) == expected);
-    }
-}
-
-TEST_CASE_TEMPLATE("custom object key types: CBOR", J,
-                   custom_key_test::json_full, custom_key_test::json_no_eq, custom_key_test::json_explicit,
-                   custom_key_test::json_to_json, custom_key_test::json_c_str)
-{
-    SECTION("shallow")
-    {
-        const J value = custom_key_test::make_shallow<J>();
-        const nlohmann::json expected = custom_key_test::make_shallow<nlohmann::json>();
-
-        const std::vector<std::uint8_t> encoded = J::to_cbor(value);
-        CHECK(encoded == nlohmann::json::to_cbor(expected));
-        CHECK(nlohmann::json::from_cbor(encoded) == expected);
-    }
-
-    SECTION("deeper than the recursion depth limit")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-        const J value = custom_key_test::make_deep<J>(depth, true);
-        const nlohmann::json expected = custom_key_test::make_deep<nlohmann::json>(depth, true);
-
-        const std::vector<std::uint8_t> encoded = J::to_cbor(value);
-        CHECK(encoded == nlohmann::json::to_cbor(expected));
-        CHECK(nlohmann::json::from_cbor(encoded) == expected);
-    }
-}
-
-TEST_CASE_TEMPLATE("custom object key types: MessagePack", J,
-                   custom_key_test::json_full, custom_key_test::json_no_eq, custom_key_test::json_explicit,
-                   custom_key_test::json_to_json, custom_key_test::json_c_str)
-{
-    SECTION("shallow")
-    {
-        const J value = custom_key_test::make_shallow<J>();
-        const nlohmann::json expected = custom_key_test::make_shallow<nlohmann::json>();
-
-        const std::vector<std::uint8_t> encoded = J::to_msgpack(value);
-        CHECK(encoded == nlohmann::json::to_msgpack(expected));
-        CHECK(nlohmann::json::from_msgpack(encoded) == expected);
-    }
-
-    SECTION("deeper than the recursion depth limit")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-        const J value = custom_key_test::make_deep<J>(depth, true);
-        const nlohmann::json expected = custom_key_test::make_deep<nlohmann::json>(depth, true);
-
-        const std::vector<std::uint8_t> encoded = J::to_msgpack(value);
-        CHECK(encoded == nlohmann::json::to_msgpack(expected));
-        CHECK(nlohmann::json::from_msgpack(encoded) == expected);
-    }
-}

tests/src/unit-json_pointer.cpp

@@ -939,3 +939,114 @@ TEST_CASE("unescaping keeps a '~' that does not start an escape sequence")
     nlohmann::detail::unescape(s);
     CHECK(s == "~/~");
 }
+
+TEST_CASE("flatten of structured values")
+{
+    SECTION("values nested too deeply for the call stack (#5393)")
+    {
+        // flatten() used to recurse once per nesting level
+        const std::size_t depth = 100000;
+        for (const bool objects :
+                {
+                    false, true
+                })
+        {
+            CAPTURE(objects)
+            std::string text;
+            std::string path;
+            for (std::size_t i = 0; i < depth; ++i)
+            {
+                text += objects ? "{\"a\":" : "[";
+                path += objects ? "/a" : "/0";
+            }
+            text += "0";
+            text += std::string(depth, objects ? '}' : ']');
+            const auto value = json::parse(text);
+
+            const auto flat = value.flatten();
+            REQUIRE(flat.size() == 1);
+            REQUIRE(flat.begin().key().size() == path.size());
+            CHECK(flat.begin().key() == path);
+            CHECK(flat.begin().value() == 0);
+
+            // unflatten() is linear in the depth, so the value roundtrips
+            CHECK(flat.unflatten() == value);
+        }
+    }
+
+    SECTION("unflatten of a deeply nested pointer")
+    {
+        const std::size_t depth = 100000;
+        for (const bool objects :
+                {
+                    false, true
+                })
+        {
+            CAPTURE(objects)
+            std::string path;
+            for (std::size_t i = 0; i < depth; ++i)
+            {
+                path += objects ? "/a" : "/0";
+            }
+
+            json flat = json::object();
+            flat[path] = 1;
+            const json value = flat.unflatten();
+
+            // walk down iteratively
+            std::size_t levels = 0;
+            const json* current = &value;
+            while (objects ? current->is_object() : current->is_array())
+            {
+                REQUIRE(current->size() == 1);
+                current = objects ? &current->at("a") : &current->at(0);
+                ++levels;
+            }
+            CHECK(levels == depth);
+            CHECK(*current == 1);
+        }
+    }
+
+    SECTION("unflatten does not depend on the iteration order")
+    {
+        // the "0" key comes after its sibling in iteration order
+        const nlohmann::ordered_json flat_array = nlohmann::ordered_json::parse(R"({"/a/1": 2, "/a/0": 1})");
+        CHECK(flat_array.unflatten() == nlohmann::ordered_json::parse(R"({"a": [1, 2]})"));
+
+        const nlohmann::ordered_json flat_object = nlohmann::ordered_json::parse(R"({"/b/1": 2})");
+        CHECK(flat_object.unflatten() == nlohmann::ordered_json::parse(R"({"b": {"1": 2}})"));
+    }
+
+    SECTION("objects and arrays interleaved")
+    {
+        const json value =
+        {
+            {"a", {1, {{"b", json::array()}, {"c", json::object()}}, json::array({{{"x~/", {true, nullptr}}}})}},
+            {"a/b", {{"~", 1}}},
+            {"z", "s"}
+        };
+
+        const json expected =
+        {
+            {"/a/0", 1},
+            {"/a/1/b", nullptr},
+            {"/a/1/c", nullptr},
+            {"/a/2/0/x~0~1/0", true},
+            {"/a/2/0/x~0~1/1", nullptr},
+            {"/a~1b/~0", 1},
+            {"/z", "s"}
+        };
+
+        CHECK(value.flatten() == expected);
+    }
+
+    SECTION("order of the entries of an ordered_json")
+    {
+        const auto value = nlohmann::ordered_json::parse(
+                               R"({"z":"s","a/b":{"~":1,"k":[]},"a":[1,{"c":{},"b":[]},[{"x~/":[true,null],"w":2}]]})");
+
+        const auto flat = value.flatten();
+        CHECK(flat.dump() ==
+              R"({"/z":"s","/a~1b/~0":1,"/a~1b/k":null,"/a/0":1,"/a/1/c":null,"/a/1/b":null,"/a/2/0/x~0~1/0":true,"/a/2/0/x~0~1/1":null,"/a/2/0/w":2})");
+    }
+}

tests/src/unit-msgpack.cpp

@@ -2202,10 +2202,7 @@ struct huge_array : std::vector<T, A>
     }
 };
 
-using huge_array_json = nlohmann::basic_json <
-                        std::map, huge_array, std::string, bool, std::int64_t, std::uint64_t,
-                        double, std::allocator, nlohmann::adl_serializer,
-                        std::vector<std::uint8_t>, void >;
+using huge_array_json = nlohmann::json::with_array_t<huge_array>;
 
 TEST_CASE("MessagePack Size above uint32 for array")
 {
@@ -2250,18 +2247,7 @@ template<typename K, typename V,
     }
 };
 
-using huge_object_json = nlohmann::basic_json <
-                         huge_map,
-                         std::vector,
-                         std::string,
-                         bool,
-                         std::int64_t,
-                         std::uint64_t,
-                         double,
-                         std::allocator,
-                         nlohmann::adl_serializer,
-                         std::vector<std::uint8_t>,
-                         void >;
+using huge_object_json = nlohmann::json::with_object_t<huge_map>;
 
 TEST_CASE("MessagePack Size above uint32 for object")
 {
@@ -2296,18 +2282,7 @@ struct huge_string : std::string
     }
 };
 
-using huge_string_json = nlohmann::basic_json <
-                         std::map,
-                         std::vector,
-                         huge_string,
-                         bool,
-                         std::int64_t,
-                         std::uint64_t,
-                         double,
-                         std::allocator,
-                         nlohmann::adl_serializer,
-                         std::vector<std::uint8_t>,
-                         void >;
+using huge_string_json = nlohmann::json::with_string_t<huge_string>;
 
 TEST_CASE("MessagePack Size above uint32 for string")
 {
@@ -2330,18 +2305,7 @@ struct huge_binary : std::vector<std::uint8_t>
     }
 };
 
-using huge_binary_json = nlohmann::basic_json <
-                         std::map,
-                         std::vector,
-                         std::string,
-                         bool,
-                         std::int64_t,
-                         std::uint64_t,
-                         double,
-                         std::allocator,
-                         nlohmann::adl_serializer,
-                         huge_binary,
-                         void >;
+using huge_binary_json = nlohmann::json::with_binary_t<huge_binary>;
 
 TEST_CASE("MessagePack Size above uint32 for binary")
 {
@@ -2391,14 +2355,10 @@ class beyond_uint32_string_t : public std::string
     }
 };
 
-using beyond_uint32_string_json = nlohmann::basic_json <
-                                  std::map, std::vector, beyond_uint32_string_t, bool, std::int64_t, std::uint64_t,
-                                  double, std::allocator, nlohmann::adl_serializer, std::vector<std::uint8_t>, void >;
+using beyond_uint32_string_json = nlohmann::json::with_string_t<beyond_uint32_string_t>;
 #endif
 
-using beyond_uint32_binary_json = nlohmann::basic_json <
-                                  std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
-                                  double, std::allocator, nlohmann::adl_serializer, beyond_uint32_binary_t, void >;
+using beyond_uint32_binary_json = nlohmann::json::with_binary_t<beyond_uint32_binary_t>;
 } // namespace
 
 TEST_CASE("MessagePack lengths beyond UINT32_MAX cannot be serialized")

tests/src/unit-ordered_json2.cpp

@@ -217,16 +217,7 @@ void int_to_string(alt_string& target, std::size_t value)
     target = std::to_string(value).c_str();
 }
 
-using alt_json = nlohmann::basic_json <
-                 std::map,
-                 std::vector,
-                 alt_string,
-                 bool,
-                 std::int64_t,
-                 std::uint64_t,
-                 double,
-                 std::allocator,
-                 nlohmann::adl_serializer >;
+using alt_json = nlohmann::json::with_string_t<alt_string>;
 
 bool operator<(const char* op1, const alt_string& op2) noexcept
 {