Keep external headers as #include when amalgamating

A header that builds on json.hpp (such as the planned json_view.hpp) must
not inline json.hpp: its single-header version would contain a second copy
of the library, and that copy would change with every library change.

The optional config key "external" lists include paths that are kept as
#include directives. Only the first directive per path is kept; repeated
ones are commented out, as the tool already does for inlined headers.
config_json_view.json uses it for json_view.hpp; the existing configs do
not set it, and json.hpp and json_fwd.hpp regenerate byte-identically.

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

docs/mkdocs/docs/api/basic_json/operator_spaceship.md

@@ -96,8 +96,5 @@ Linear.
 
 ## Version history
 
-1. Added in version 3.11.0. Fixed in version 3.13.0 to keep the result independent of nesting depth: before, a pair
-   of binary values with the same bytes but a different subtype - unequal by `operator==`, yet equivalent by
-   `operator<=>` - could end an ordered comparison as `unordered` only past 128 levels of nesting, or at every depth
-   with [`JSON_NO_THREAD_LOCAL`](../macros/json_no_thread_local.md) defined.
+1. Added in version 3.11.0.
 2. Added in version 3.11.0.

include/nlohmann/json.hpp

@@ -1307,65 +1307,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     */
     template<bool Ordered>
     static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
-    {
-        return compare_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
-    }
-
-    /// @brief compare two leaves that are only being checked for equality
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::false_type /*ordered*/) noexcept
     {
         if (lhs == rhs)
         {
             return compare_result::equal;
         }
 
-        return order_leaves(lhs, rhs, std::false_type {});
+        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
     }
 
-#if JSON_HAS_THREE_WAY_COMPARISON
-    /*!
-    @brief compare two leaves that are being ordered, for operator<=>
-
-    Reached only from operator<=>, so the leaves must be classified exactly
-    as operator<=> classifies them - which is not the same as asking
-    == and then order_leaves(), the way the other overload does it. The two
-    disagree on a binary value: == also compares the subtype, but <=> compares
-    only the bytes, through std::vector<std::uint8_t>::operator<=>. Using <=>
-    itself here keeps a leaf pair classified the same way regardless of how
-    deep it is nested - == first would again call operator<=> a level down
-    through order_leaves(), but call it after a mismatching == already ended
-    the comparison for a pair that <=> alone would still call equivalent.
-    */
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        const std::partial_ordering order = lhs <=> rhs; // *NOPAD*
-        if (order == 0)
-        {
-            return compare_result::equal;
-        }
-        if (order < 0)
-        {
-            return compare_result::less;
-        }
-        if (order > 0)
-        {
-            return compare_result::greater;
-        }
-        return compare_result::unordered;
-    }
-#else
-    /// @brief compare two leaves that are being ordered, for operator<
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        if (lhs == rhs)
-        {
-            return compare_result::equal;
-        }
-
-        return order_leaves(lhs, rhs, std::true_type {});
-    }
-#endif
-
     /*!
     @brief compare two object keys
 

single_include/nlohmann/json.hpp

@@ -27388,65 +27388,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     */
     template<bool Ordered>
     static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
-    {
-        return compare_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
-    }
-
-    /// @brief compare two leaves that are only being checked for equality
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::false_type /*ordered*/) noexcept
     {
         if (lhs == rhs)
         {
             return compare_result::equal;
         }
 
-        return order_leaves(lhs, rhs, std::false_type {});
+        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
     }
 
-#if JSON_HAS_THREE_WAY_COMPARISON
-    /*!
-    @brief compare two leaves that are being ordered, for operator<=>
-
-    Reached only from operator<=>, so the leaves must be classified exactly
-    as operator<=> classifies them - which is not the same as asking
-    == and then order_leaves(), the way the other overload does it. The two
-    disagree on a binary value: == also compares the subtype, but <=> compares
-    only the bytes, through std::vector<std::uint8_t>::operator<=>. Using <=>
-    itself here keeps a leaf pair classified the same way regardless of how
-    deep it is nested - == first would again call operator<=> a level down
-    through order_leaves(), but call it after a mismatching == already ended
-    the comparison for a pair that <=> alone would still call equivalent.
-    */
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        const std::partial_ordering order = lhs <=> rhs; // *NOPAD*
-        if (order == 0)
-        {
-            return compare_result::equal;
-        }
-        if (order < 0)
-        {
-            return compare_result::less;
-        }
-        if (order > 0)
-        {
-            return compare_result::greater;
-        }
-        return compare_result::unordered;
-    }
-#else
-    /// @brief compare two leaves that are being ordered, for operator<
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        if (lhs == rhs)
-        {
-            return compare_result::equal;
-        }
-
-        return order_leaves(lhs, rhs, std::true_type {});
-    }
-#endif
-
     /*!
     @brief compare two object keys
 

tests/src/unit-comparison.cpp

@@ -952,51 +952,3 @@ TEST_CASE("containers are compared element by element")
         }
     }
 }
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-// JSON_HAS_CPP_20 (do not remove; see note at top of file)
-TEST_CASE("operator<=> of binary values with a different subtype does not depend on nesting depth")
-{
-    // #5654: std::vector<std::uint8_t>::operator<=>, which the binary type's
-    // own operator<=> uses, ignores the subtype that operator== checks. So a
-    // pair of binary values with the same bytes but a different subtype is
-    // unequal, yet <=>-equivalent - the same inconsistency between == and <=>
-    // that a NaN has. Within the nesting bound, an array compares itself
-    // with std::vector's own operator<=>, which treats an equivalent pair as
-    // undecided and lets the next element decide, same as
-    // std::lexicographical_compare_three_way does. Past the bound,
-    // compare_iteratively<true>() takes over and must classify the pair the
-    // same way, or the result of operator<=> - and of <, which C++20 derives
-    // from it - depends on how deeply the values are nested.
-    const json a = json::array({json::binary({1}, 1), 1});
-    const json b = json::array({json::binary({1}, 2), 2});
-
-    // the root inconsistency: unequal, yet <=>-equivalent
-    CHECK_FALSE(a[0] == b[0]);
-    CHECK((a[0] <=> b[0]) == std::partial_ordering::equivalent); // *NOPAD*
-
-    const auto deep = [](const json & j, const std::size_t depth)
-    {
-        json result = j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            result = json::array({std::move(result)});
-        }
-        return result;
-    };
-
-    // 127 levels stay within nesting_depth_limit() (128); 128 and 200 do not,
-    // and must still agree with the levels that do
-    for (const std::size_t depth : std::vector<std::size_t> {0, 127, 128, 200})
-    {
-        CAPTURE(depth);
-        const json x = deep(a, depth);
-        const json y = deep(b, depth);
-        CHECK((x <=> y) == std::partial_ordering::less); // *NOPAD*
-        CHECK((y <=> x) == std::partial_ordering::greater); // *NOPAD*
-        CHECK(x < y);
-        CHECK(y > x);
-        CHECK_FALSE(y < x);
-    }
-}
-#endif

tools/amalgamate/CHANGES.md

@@ -8,3 +8,6 @@ The following changes have been made to the code with respect to <https://github
   - membership check
   - made function from `_is_within`
   - removed unused variable `actual_path`
+- Added the optional config key `external`: include paths listed there are kept as
+  `#include` directives instead of being inlined (the first directive per path; the
+  repeated ones are commented out).

tools/amalgamate/README.md

@@ -57,6 +57,11 @@ Python v.2.7.0 or higher is required.
    amalgamation. Have a look at `test/source.c.json` and `test/include.h.json`
    to see two examples.
 
+   The optional `external` list names include paths that are kept as `#include`
+   directives instead of being inlined, e.g. `["nlohmann/json.hpp"]` for a header
+   that includes another amalgamated header. Only the first directive for each
+   of these paths is kept; the repeated ones are commented out.
+
  * The `-s, --source` option should specify the path to the source directory.
    This is useful for supporting separate source and build directories.
 

tools/amalgamate/amalgamate.py

@@ -62,6 +62,10 @@ class Amalgamation(object):
         return None
 
     def __init__(self, args):
+        # include paths that are kept as #include directives instead of
+        # being inlined (e.g. a header amalgamated on its own)
+        self.external = []
+        self.included_external = []
         with open(args.config, 'r') as f:
             config = json.loads(f.read())
             for key in config:
@@ -220,11 +224,14 @@ class TranslationUnit(object):
         while include_match:
             if not _is_within(include_match, skippable_contexts):
                 include_path = include_match.group("path")
-                search_same_dir = include_match.group(1) == '"'
-                found_included_path = self.amalgamation.find_included_file(
-                    include_path, self.file_dir if search_same_dir else None)
-                if found_included_path:
-                    includes.append((include_match, found_included_path))
+                if include_path in self.amalgamation.external:
+                    includes.append((include_match, None))
+                else:
+                    search_same_dir = include_match.group(1) == '"'
+                    found_included_path = self.amalgamation.find_included_file(
+                        include_path, self.file_dir if search_same_dir else None)
+                    if found_included_path:
+                        includes.append((include_match, found_included_path))
 
             include_match = self.include_pattern.search(self.content,
                                                         include_match.end())
@@ -235,6 +242,17 @@ class TranslationUnit(object):
         for include in includes:
             include_match, found_included_path = include
             tmp_content += self.content[prev_end:include_match.start()]
+            if found_included_path is None:
+                # an external header: keep the first directive and comment
+                # out the repeated ones
+                include_path = include_match.group("path")
+                if include_path in self.amalgamation.included_external:
+                    tmp_content += "// {0}".format(include_match.group(0))
+                else:
+                    self.amalgamation.included_external.append(include_path)
+                    tmp_content += include_match.group(0)
+                prev_end = include_match.end()
+                continue
             tmp_content += "// {0}\n".format(include_match.group(0))
             if found_included_path not in self.amalgamation.included_files:
                 t = TranslationUnit(found_included_path, self.amalgamation, False)

tools/amalgamate/config_json_view.json

@@ -0,0 +1,9 @@
+{
+	"project": "JSON for Modern C++",
+	"target": "single_include/nlohmann/json_view.hpp",
+	"sources": [
+		"include/nlohmann/json_view.hpp"
+	],
+	"include_paths": ["include"],
+	"external": ["nlohmann/json.hpp"]
+}