Make flatten() linear for ordered_json

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

include/nlohmann/detail/input/json_sax.hpp

@@ -674,16 +674,19 @@ class json_sax_dom_callback_parser
         if (keep && ref_stack.back())
         {
             auto& obj = *ref_stack.back()->m_data.m_value.object;
-            const auto it = obj.find(val);
-            if (it != obj.end())
+            // a single lookup: insert the placeholder, or find the existing member
+            const auto inserted = obj.emplace(val, discarded);
+            const auto it = inserted.first;
+            if (!inserted.second)
             {
                 // this is a duplicate key (legal in JSON); remember its
                 // current value so it can be restored later if the new
                 // value is rejected by the callback, instead of being
                 // erased together with the discarded placeholder
                 duplicate_key_stash.emplace_back(&(it->second), it->second);
+                it->second = discarded;
             }
-            object_element = &(obj[val] = discarded);
+            object_element = &(it->second);
         }
 
         return true;

include/nlohmann/detail/json_pointer.hpp

@@ -938,6 +938,23 @@ class json_pointer
     }
 
   private:
+    // Add the entry (key, v) to the object `obj`. Flattened paths are pairwise
+    // distinct, so objects that can append a key known to be absent
+    // (ordered_map) skip the lookup, which is linear and would make flatten
+    // quadratic; all other object types use operator[].
+    template<typename ObjectType, typename ValueType>
+    static auto add_flattened(ObjectType& obj, const string_t& key, ValueType&& v, int /*unused*/)
+    -> decltype(obj.emplace_new_key(key, std::forward<ValueType>(v)), void())
+    {
+        obj.emplace_new_key(key, std::forward<ValueType>(v));
+    }
+
+    template<typename ObjectType, typename ValueType>
+    static void add_flattened(ObjectType& obj, const string_t& key, ValueType&& v, ...)
+    {
+        obj[key] = std::forward<ValueType>(v);
+    }
+
     /*!
     @param[in] reference_string  the reference string to the current value
     @param[in] value             the value to consider
@@ -982,7 +999,8 @@ class json_pointer
 
         // 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)
+        auto& object = *result.m_data.m_value.object;
+        const auto enter = [&stack, &path, &object](const BasicJsonType & v)
         {
             switch (v.type())
             {
@@ -991,7 +1009,7 @@ class json_pointer
                     if (v.m_data.m_value.array->empty())
                     {
                         // flatten empty array as null
-                        result[path] = nullptr;
+                        add_flattened(object, path, nullptr, 0);
                     }
                     else
                     {
@@ -1005,7 +1023,7 @@ class json_pointer
                     if (v.m_data.m_value.object->empty())
                     {
                         // flatten empty object as null
-                        result[path] = nullptr;
+                        add_flattened(object, path, nullptr, 0);
                     }
                     else
                     {
@@ -1025,7 +1043,7 @@ class json_pointer
                 default:
                 {
                     // add a primitive value with its reference string
-                    result[path] = v;
+                    add_flattened(object, path, v, 0);
                     return;
                 }
             }
@@ -1071,6 +1089,10 @@ class json_pointer
                 enter(it->second);
             }
         }
+
+        // the entries were added without going through basic_json, so the
+        // parent pointers (JSON_DIAGNOSTICS) have to be set now
+        result.set_parents();
     }
 
     /*!

include/nlohmann/ordered_map.hpp

@@ -143,6 +143,17 @@ public:
         return {std::prev(this->end()), true};
     }
 
+    /// @brief add an element at the end without checking whether the key exists
+    /// @note The caller must guarantee that @a key is not yet contained, otherwise
+    ///       the container holds duplicate keys. This avoids the linear search of
+    ///       emplace() and operator[] when many keys known to be new are added.
+    template<class V, detail::enable_if_t<
+                 detail::is_constructible<T, V>::value, int> = 0>
+    void emplace_new_key(const key_type& key, V && t)
+    {
+        append(key, std::forward<V>(t));
+    }
+
     T& operator[](const key_type& key)
     {
         return emplace(key, T{}).first->second;

single_include/nlohmann/json.hpp

@@ -13850,16 +13850,19 @@ class json_sax_dom_callback_parser
         if (keep && ref_stack.back())
         {
             auto& obj = *ref_stack.back()->m_data.m_value.object;
-            const auto it = obj.find(val);
-            if (it != obj.end())
+            // a single lookup: insert the placeholder, or find the existing member
+            const auto inserted = obj.emplace(val, discarded);
+            const auto it = inserted.first;
+            if (!inserted.second)
             {
                 // this is a duplicate key (legal in JSON); remember its
                 // current value so it can be restored later if the new
                 // value is rejected by the callback, instead of being
                 // erased together with the discarded placeholder
                 duplicate_key_stash.emplace_back(&(it->second), it->second);
+                it->second = discarded;
             }
-            object_element = &(obj[val] = discarded);
+            object_element = &(it->second);
         }
 
         return true;
@@ -21559,6 +21562,23 @@ class json_pointer
     }
 
   private:
+    // Add the entry (key, v) to the object `obj`. Flattened paths are pairwise
+    // distinct, so objects that can append a key known to be absent
+    // (ordered_map) skip the lookup, which is linear and would make flatten
+    // quadratic; all other object types use operator[].
+    template<typename ObjectType, typename ValueType>
+    static auto add_flattened(ObjectType& obj, const string_t& key, ValueType&& v, int /*unused*/)
+    -> decltype(obj.emplace_new_key(key, std::forward<ValueType>(v)), void())
+    {
+        obj.emplace_new_key(key, std::forward<ValueType>(v));
+    }
+
+    template<typename ObjectType, typename ValueType>
+    static void add_flattened(ObjectType& obj, const string_t& key, ValueType&& v, ...)
+    {
+        obj[key] = std::forward<ValueType>(v);
+    }
+
     /*!
     @param[in] reference_string  the reference string to the current value
     @param[in] value             the value to consider
@@ -21603,7 +21623,8 @@ class json_pointer
 
         // 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)
+        auto& object = *result.m_data.m_value.object;
+        const auto enter = [&stack, &path, &object](const BasicJsonType & v)
         {
             switch (v.type())
             {
@@ -21612,7 +21633,7 @@ class json_pointer
                     if (v.m_data.m_value.array->empty())
                     {
                         // flatten empty array as null
-                        result[path] = nullptr;
+                        add_flattened(object, path, nullptr, 0);
                     }
                     else
                     {
@@ -21626,7 +21647,7 @@ class json_pointer
                     if (v.m_data.m_value.object->empty())
                     {
                         // flatten empty object as null
-                        result[path] = nullptr;
+                        add_flattened(object, path, nullptr, 0);
                     }
                     else
                     {
@@ -21646,7 +21667,7 @@ class json_pointer
                 default:
                 {
                     // add a primitive value with its reference string
-                    result[path] = v;
+                    add_flattened(object, path, v, 0);
                     return;
                 }
             }
@@ -21692,6 +21713,10 @@ class json_pointer
                 enter(it->second);
             }
         }
+
+        // the entries were added without going through basic_json, so the
+        // parent pointers (JSON_DIAGNOSTICS) have to be set now
+        result.set_parents();
     }
 
     /*!
@@ -29158,6 +29183,17 @@ public:
         return {std::prev(this->end()), true};
     }
 
+    /// @brief add an element at the end without checking whether the key exists
+    /// @note The caller must guarantee that @a key is not yet contained, otherwise
+    ///       the container holds duplicate keys. This avoids the linear search of
+    ///       emplace() and operator[] when many keys known to be new are added.
+    template<class V, detail::enable_if_t<
+                 detail::is_constructible<T, V>::value, int> = 0>
+    void emplace_new_key(const key_type& key, V && t)
+    {
+        append(key, std::forward<V>(t));
+    }
+
     T& operator[](const key_type& key)
     {
         return emplace(key, T{}).first->second;

tests/src/unit-guard-page.cpp

@@ -1,447 +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
-
-// The fast paths for contiguous input (bulk string scanning, SWAR searches,
-// UTF-8 prefix validation, the 8-digit number loop, the 8-byte indentation
-// skip, the BSON/BON8 bulk string readers) load several bytes at a time. This
-// test places every input directly in front of (or directly behind) an
-// inaccessible page, so reading even one byte outside the input crashes, with
-// or without sanitizers. ASan alone misses over-reads into the slack of the
-// same heap allocation.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <utility>
-#include <vector>
-
-#if defined(_WIN32)
-    #define JSON_TEST_GUARD_PAGE_WINDOWS
-    #ifndef NOMINMAX
-        #define NOMINMAX
-    #endif
-    #ifndef WIN32_LEAN_AND_MEAN
-        #define WIN32_LEAN_AND_MEAN
-    #endif
-    #include <windows.h>
-#elif defined(__unix__) || defined(__APPLE__)
-    #define JSON_TEST_GUARD_PAGE_POSIX
-    #include <sys/mman.h>
-    #include <unistd.h>
-#endif
-
-#if defined(JSON_TEST_GUARD_PAGE_WINDOWS) || defined(JSON_TEST_GUARD_PAGE_POSIX)
-
-namespace
-{
-// Three pages: an inaccessible one, a readable one, an inaccessible one. An
-// input is copied either to the end of the middle page (any read past its last
-// byte faults) or to its start (any read before its first byte faults).
-class guarded_buffer
-{
-  public:
-    guarded_buffer()
-        : page(page_size())
-    {
-#if defined(JSON_TEST_GUARD_PAGE_WINDOWS)
-        void* const p = VirtualAlloc(nullptr, 3 * page, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
-        REQUIRE(p != nullptr);
-        base = static_cast<unsigned char*>(p);
-        DWORD old_protect = 0;
-        REQUIRE(VirtualProtect(base + page, page, PAGE_READWRITE, &old_protect) != 0);
-#else
-        void* const p = mmap(nullptr, 3 * page, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
-        REQUIRE(p != MAP_FAILED);
-        base = static_cast<unsigned char*>(p);
-        REQUIRE(mprotect(base + page, page, PROT_READ | PROT_WRITE) == 0);
-#endif
-    }
-
-    ~guarded_buffer()
-    {
-#if defined(JSON_TEST_GUARD_PAGE_WINDOWS)
-        VirtualFree(base, 0, MEM_RELEASE);
-#else
-        munmap(base, 3 * page);
-#endif
-    }
-
-    guarded_buffer(const guarded_buffer&) = delete;
-    guarded_buffer& operator=(const guarded_buffer&) = delete;
-    guarded_buffer(guarded_buffer&&) = delete;
-    guarded_buffer& operator=(guarded_buffer&&) = delete;
-
-    // copies @a input so its last byte is the last readable byte
-    const std::uint8_t* at_end(const std::string& input)
-    {
-        REQUIRE(input.size() <= page);
-        unsigned char* const first = base + (2 * page) - input.size();
-        std::memcpy(first, input.data(), input.size());
-        return first;
-    }
-
-    // copies @a input so its first byte is the first readable byte
-    const std::uint8_t* at_start(const std::string& input)
-    {
-        REQUIRE(input.size() <= page);
-        unsigned char* const first = base + page;
-        std::memcpy(first, input.data(), input.size());
-        return first;
-    }
-
-  private:
-    static std::size_t page_size()
-    {
-#if defined(JSON_TEST_GUARD_PAGE_WINDOWS)
-        SYSTEM_INFO info;
-        GetSystemInfo(&info);
-        return static_cast<std::size_t>(info.dwPageSize);
-#else
-        return static_cast<std::size_t>(sysconf(_SC_PAGESIZE));
-#endif
-    }
-
-    std::size_t page = 0;
-    unsigned char* base = nullptr;
-};
-
-// the serialization of the result of @a f, or the exception message; @a f
-// takes the allow_exceptions flag, which is false without exceptions, where
-// an error yields a discarded value instead
-template<typename F>
-std::string outcome(F f)
-{
-#if defined(JSON_NOEXCEPTION)
-    return "value: " + f(false).dump(-1, ' ', false, json::error_handler_t::keep);
-#else
-    try
-    {
-        return "value: " + f(true).dump(-1, ' ', false, json::error_handler_t::keep);
-    }
-    catch (const json::exception& e)
-    {
-        return std::string("error: ") + e.what();
-    }
-#endif
-}
-
-// a SAX handler that only counts events, so sax_parse runs without a DOM
-struct counting_sax : nlohmann::json_sax<json>
-{
-    std::size_t events = 0;
-    std::string error{}; // NOLINT(readability-redundant-member-init)
-
-    bool null() override
-    {
-        return count();
-    }
-    bool boolean(bool /*val*/) override
-    {
-        return count();
-    }
-    bool number_integer(number_integer_t /*val*/) override
-    {
-        return count();
-    }
-    bool number_unsigned(number_unsigned_t /*val*/) override
-    {
-        return count();
-    }
-    bool number_float(number_float_t /*val*/, const string_t& /*s*/) override
-    {
-        return count();
-    }
-    bool string(string_t& /*val*/) override
-    {
-        return count();
-    }
-    bool binary(binary_t& /*val*/) override
-    {
-        return count();
-    }
-    bool start_object(std::size_t /*elements*/) override
-    {
-        return count();
-    }
-    bool key(string_t& /*val*/) override
-    {
-        return count();
-    }
-    bool end_object() override
-    {
-        return count();
-    }
-    bool start_array(std::size_t /*elements*/) override
-    {
-        return count();
-    }
-    bool end_array() override
-    {
-        return count();
-    }
-    bool parse_error(std::size_t position, const std::string& /*last_token*/, const nlohmann::detail::exception& ex) override
-    {
-        error = std::to_string(position) + " " + ex.what();
-        return false;
-    }
-
-  private:
-    bool count()
-    {
-        ++events;
-        return true;
-    }
-};
-
-// all prefixes of each seed, so the input ends at every byte of it
-std::vector<std::string> all_prefixes(const std::vector<std::string>& seeds)
-{
-    std::vector<std::string> result;
-    for (const auto& seed : seeds)
-    {
-        for (std::size_t n = 0; n <= seed.size(); ++n)
-        {
-            result.push_back(seed.substr(0, n));
-        }
-    }
-    return result;
-}
-
-std::vector<std::string> json_seeds()
-{
-    std::vector<std::string> seeds =
-    {
-        // string runs: ASCII, escapes, \u escapes, surrogate pairs
-        "\"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\"",
-        R"("ab\ncd\"ef\\gh\u00e4ij\uD83D\uDE00kl\u12")",
-        // 2-, 3- and 4-byte UTF-8 sequences, then invalid UTF-8
-        std::string("\"\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80") + "abcdefgh\"",
-        "\"abcdefgh\xC3\x28 \xED\xA0\x80 \xF4\x90\x80\x80 \xF8 \xC0\xAF\"",
-        std::string("\"abcdefg\x01") + "abcdefgh\"",
-        // numbers, so the 8-digit loop runs up to the end
-        "12345678",
-        "1234567890123456",
-        "12345678901234567890123",
-        "-0.000000001234567890123456789",
-        "3.14159265358979323846264338327950288e+100",
-        "-1.2345678901234567e-12",
-        "1E-5",
-        "[1.5,2e10,-3E-5,0.000000001,123456789012345678]",
-        // literals
-        "[true,false,null]",
-        // comments (only parsed with ignore_comments)
-        "/* comment */ [1, // line comment\n 2] /**/",
-        // a pretty-printed document
-        json::parse(R"({"a": [1, 2.5, "three", {"b": null, "c": [true, false]}], "d": {"e": {"f": {"g": "h"}}}})").dump(4),
-        json::parse(R"({"a": [1, 2.5, "three", {"b": null, "c": [true, false]}], "d": {"e": {"f": {"g": "h"}}}})").dump(8, '\t'),
-    };
-
-    // indentation runs of every length, with and without a closing bracket
-    for (std::size_t n = 0; n <= 20; ++n)
-    {
-        seeds.push_back("[\n" + std::string(n, ' ') + "1,\n" + std::string(n, ' ') + "2\n]");
-    }
-
-    return all_prefixes(seeds);
-}
-
-// a value whose binary serializations contain long strings and keys, numbers
-// of every width, and nested containers
-json binary_document()
-{
-    json j;
-    j["a key that is longer than eight bytes"] = "a string value that is longer than eight bytes";
-    j["\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80"] = "\xF0\x9F\x98\x80\xE2\x82\xAC\xC3\xA4 utf-8 0123456789";
-    j["numbers"] = {0, 1, -1, 255, -256, 65536, -2147483649LL, 4294967296ULL, 1.5, -2.25e100};
-    j["nested"] = {{"x", {{"y", {true, false, nullptr}}}}};
-    j["s"] = "";
-    return j;
-}
-
-// readers for check_binary(), callable with a container or an iterator range
-// followed by the allow_exceptions flag
-#define JSON_TEST_GUARD_PAGE_READER(name, from)                                     \
-    struct name                                                                     \
-    {                                                                               \
-        template<typename... Args>                                                  \
-        json operator()(bool allow_exceptions, Args&& ... args) const               \
-        {                                                                           \
-            return json::from(std::forward<Args>(args)..., true, allow_exceptions); \
-        }                                                                           \
-    };
-JSON_TEST_GUARD_PAGE_READER(read_bson, from_bson)
-JSON_TEST_GUARD_PAGE_READER(read_bon8, from_bon8)
-JSON_TEST_GUARD_PAGE_READER(read_cbor, from_cbor)
-JSON_TEST_GUARD_PAGE_READER(read_msgpack, from_msgpack)
-JSON_TEST_GUARD_PAGE_READER(read_ubjson, from_ubjson)
-JSON_TEST_GUARD_PAGE_READER(read_bjdata, from_bjdata)
-#undef JSON_TEST_GUARD_PAGE_READER
-
-// reads every prefix of @a bytes at both ends of the guarded page and from a
-// std::string, which must give the same outcome
-template<typename Reader>
-void check_binary(guarded_buffer& guard, const std::vector<std::uint8_t>& bytes, Reader parse)
-{
-    for (const auto& input : all_prefixes({std::string(bytes.begin(), bytes.end())}))
-    {
-        CAPTURE(input)
-        const std::string expected = outcome([&](bool allow)
-        {
-            return parse(allow, input);
-        });
-        for (int placement = 0; placement < 2; ++placement)
-        {
-            const std::uint8_t* const first = placement == 0 ? guard.at_end(input) : guard.at_start(input);
-            CHECK(outcome([&](bool allow)
-            {
-                return parse(allow, first, first + input.size());
-            }) == expected);
-        }
-    }
-}
-} // namespace
-
-TEST_CASE("guard page")
-{
-    guarded_buffer guard;
-
-    SECTION("string scanning")
-    {
-        // fills that drive each function to a different stop
-        const std::vector<std::string> fills =
-        {
-            std::string(64, 'a'),
-            std::string(64, '"'),
-            std::string(64, '\\'),
-            std::string(64, '\x01'),
-            std::string(64, '\x7F'),
-            std::string(64, '\xFF'),
-        };
-        std::vector<std::string> patterns = fills;
-        {
-            std::string utf8;
-            while (utf8.size() < 64)
-            {
-                utf8 += "\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80" "ab";
-            }
-            patterns.push_back(utf8);
-        }
-        {
-            std::string bytes;
-            for (unsigned int i = 0; i < 64; ++i)
-            {
-                bytes.push_back(static_cast<char>((i * 37u) & 0xFFu));
-            }
-            patterns.push_back(bytes);
-        }
-
-        for (const auto& pattern : patterns)
-        {
-            for (std::size_t n = 0; n <= 64; ++n)
-            {
-                const std::string input = pattern.substr(0, n);
-                for (int placement = 0; placement < 2; ++placement)
-                {
-                    const unsigned char* const p = placement == 0 ? guard.at_end(input) : guard.at_start(input);
-
-                    CHECK(nlohmann::detail::find_string_special(p, n) <= n);
-                    CHECK(nlohmann::detail::find_ascii_copyable_run(p, n) <= n);
-                    CHECK(nlohmann::detail::valid_utf8_prefix(p, n) <= n);
-#if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
-                    CHECK(nlohmann::detail::find_string_delimiter(p, n) <= n);
-#endif
-                    CHECK(nlohmann::detail::string_bulk_run(p, n) <= n);
-                    CHECK(nlohmann::detail::scalar_string_bulk_run(p, n) <= n);
-                    for (std::size_t i = 0; i < n; ++i)
-                    {
-                        CHECK(nlohmann::detail::validate_one_utf8(p + i, n - i) <= n - i);
-                    }
-                }
-            }
-        }
-    }
-
-    SECTION("Eisel-Lemire")
-    {
-        const std::vector<std::string> numbers = all_prefixes(
-        {
-            "1234567812345678123456781234567812345678",
-            "-1.2345678901234567890123456789e-123",
-            "0.00000000000000000000000000000000000001",
-            "98765432.10987654",
-        });
-        for (const auto& number : numbers)
-        {
-            double out = 0;
-            const char* const end = reinterpret_cast<const char*>(guard.at_end(number));
-            static_cast<void>(nlohmann::detail::parse_float_eisel_lemire(end, end + number.size(), out));
-            const char* const start = reinterpret_cast<const char*>(guard.at_start(number));
-            static_cast<void>(nlohmann::detail::parse_float_eisel_lemire(start, start + number.size(), out));
-        }
-    }
-
-    SECTION("JSON")
-    {
-        for (const auto& input : json_seeds())
-        {
-            CAPTURE(input)
-            const std::string expected = outcome([&](bool allow)
-            {
-                return json::parse(input, nullptr, allow);
-            });
-            const std::string expected_comments = outcome([&](bool allow)
-            {
-                return json::parse(input, nullptr, allow, true);
-            });
-            const bool expected_accept = json::accept(input);
-            counting_sax expected_sax;
-            const bool expected_sax_result = json::sax_parse(input, &expected_sax);
-
-            for (int placement = 0; placement < 2; ++placement)
-            {
-                const std::uint8_t* const first = placement == 0 ? guard.at_end(input) : guard.at_start(input);
-                const std::uint8_t* const last = first + input.size();
-
-                CHECK(outcome([&](bool allow)
-                {
-                    return json::parse(first, last, nullptr, allow);
-                }) == expected);
-                CHECK(outcome([&](bool allow)
-                {
-                    return json::parse(first, last, nullptr, allow, true);
-                }) == expected_comments);
-                CHECK(json::accept(first, last) == expected_accept);
-
-                counting_sax sax;
-                CHECK(json::sax_parse(first, last, &sax) == expected_sax_result);
-                CHECK(sax.events == expected_sax.events);
-                CHECK(sax.error == expected_sax.error);
-            }
-        }
-    }
-
-    SECTION("binary formats")
-    {
-        // every prefix ends inside a value, e.g., inside a BSON key or BON8
-        // string without its terminator
-        const json j = binary_document();
-        check_binary(guard, json::to_bson(j), read_bson());
-        check_binary(guard, json::to_bon8(j), read_bon8());
-        check_binary(guard, json::to_cbor(j), read_cbor());
-        check_binary(guard, json::to_msgpack(j), read_msgpack());
-        check_binary(guard, json::to_ubjson(j), read_ubjson());
-        check_binary(guard, json::to_bjdata(j), read_bjdata());
-    }
-}
-
-#endif

tests/src/unit-json_pointer.cpp

@@ -24,6 +24,8 @@ using nlohmann::json;
 #endif
 
 #include <map>
+#include <string>
+#include <vector>
 #include <sstream>
 
 TEST_CASE("JSON pointers")
@@ -1071,3 +1073,53 @@ TEST_CASE("flatten of structured values")
               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})");
     }
 }
+
+TEST_CASE("flatten of ordered_json")
+{
+    using nlohmann::ordered_json;
+
+    SECTION("keeps the document order of the leaves")
+    {
+        const ordered_json j = ordered_json::parse(R"({
+            "z": 1, "a": {"y": [true, null, {}], "b": "x", "": []},
+            "m~n": 2.5, "o/p": {"k": {}}, "0": [[1], [2, 3]]
+        })");
+
+        const ordered_json flat = j.flatten();
+        std::vector<std::string> keys;
+        for (const auto& el : flat.items())
+        {
+            keys.push_back(el.key());
+        }
+        const std::vector<std::string> expected =
+        {
+            "/z", "/a/y/0", "/a/y/1", "/a/y/2", "/a/b", "/a/", "/m~0n", "/o~1p/k", "/0/0/0", "/0/1/0", "/0/1/1"
+        };
+        CHECK(keys == expected);
+        CHECK(flat.size() == expected.size());
+        CHECK(flat["/m~0n"] == 2.5);
+        CHECK(flat["/a/y/2"].is_null());
+    }
+
+    SECTION("round-trips and agrees with json")
+    {
+        ordered_json j;
+        for (int i = 0; i < 200; ++i)
+        {
+            j["k" + std::to_string(i)] = {{"v", i}, {"l", {i, i + 1, "s"}}};
+        }
+        const ordered_json flat = j.flatten();
+        CHECK(flat.size() == 800);
+        CHECK(flat.unflatten() == j);
+
+        // same entries as for a sorted object
+        const nlohmann::json plain = nlohmann::json::parse(j.dump());
+        CHECK(nlohmann::json::parse(flat.dump()) == plain.flatten());
+    }
+
+    SECTION("primitive and empty root")
+    {
+        CHECK(ordered_json(1).flatten() == ordered_json({{"", 1}}));
+        CHECK(ordered_json::array().flatten() == ordered_json({{"", nullptr}}));
+    }
+}