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/features/types/template_parameters.md

@@ -389,7 +389,6 @@ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
 | Functionality                                                                                                                     | Additional requirement                                                                                                                                                                       |
 |-----------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | [`diff`](../../api/basic_json/diff.md), [`items`](../../api/basic_json/items.md), [`std::hash`](../../api/basic_json/std_hash.md) | conversion of a `#!cpp std::size_t` to `StringType`: either assignability from the result of `#!cpp std::to_string`, or an ADL overload `#!cpp void int_to_string(StringType&, std::size_t)` |
-| [`operator/(std::size_t)`](../../api/json_pointer/operator_slash.md)                                                              | the same conversion of a `#!cpp std::size_t` to `StringType` as `diff`, `items`, and `std::hash` above                                                                                       |
 | [`std::hash<basic_json>`](../../api/basic_json/std_hash.md)                                                                       | additionally a specialization of `#!cpp std::hash<StringType>`                                                                                                                               |
 | [`to_bson`](../../api/basic_json/to_bson.md)                                                                                      | `find(value_type)` and `npos`                                                                                                                                                                |
 | [`parse`](../../api/basic_json/parse.md) from a `string_t`                                                                        | the input adapters must accept it; otherwise pass a character range                                                                                                                          |

include/nlohmann/detail/json_pointer.hpp

@@ -26,7 +26,6 @@
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 #include <nlohmann/detail/string_escape.hpp>
-#include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -117,7 +116,7 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
     json_pointer& operator/=(std::size_t array_idx)
     {
-        return *this /= detail::to_string<string_t>(array_idx);
+        return *this /= std::to_string(array_idx);
     }
 
     /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
@@ -747,7 +746,7 @@ class json_pointer
                         // "-" always fails the range check
                         return false;
                     }
-                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !('0' <= reference_token[0] && reference_token[0] <= '9')))
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
                     {
                         // invalid char
                         return false;
@@ -775,7 +774,7 @@ class json_pointer
                     // not throw (see #5395), so such a reference token is treated as "not found"
                     errno = 0; // strtoull() does not reset errno on success
                     char* p_end = nullptr; // NOLINT(misc-const-correctness)
-                    const unsigned long long magnitude = std::strtoull(reference_token.data(), &p_end, 10); // NOLINT(runtime/int)
+                    const unsigned long long magnitude = std::strtoull(reference_token.c_str(), &p_end, 10); // NOLINT(runtime/int)
                     if (JSON_HEDLEY_UNLIKELY(errno == ERANGE // the value exceeds ULLONG_MAX
                                              || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
                     {

single_include/nlohmann/json.hpp

@@ -18867,8 +18867,6 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/string_escape.hpp>
 
-// #include <nlohmann/detail/string_utils.hpp>
-
 // #include <nlohmann/detail/value_t.hpp>
 
 
@@ -18960,7 +18958,7 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
     json_pointer& operator/=(std::size_t array_idx)
     {
-        return *this /= detail::to_string<string_t>(array_idx);
+        return *this /= std::to_string(array_idx);
     }
 
     /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
@@ -19590,7 +19588,7 @@ class json_pointer
                         // "-" always fails the range check
                         return false;
                     }
-                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !('0' <= reference_token[0] && reference_token[0] <= '9')))
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
                     {
                         // invalid char
                         return false;
@@ -19618,7 +19616,7 @@ class json_pointer
                     // not throw (see #5395), so such a reference token is treated as "not found"
                     errno = 0; // strtoull() does not reset errno on success
                     char* p_end = nullptr; // NOLINT(misc-const-correctness)
-                    const unsigned long long magnitude = std::strtoull(reference_token.data(), &p_end, 10); // NOLINT(runtime/int)
+                    const unsigned long long magnitude = std::strtoull(reference_token.c_str(), &p_end, 10); // NOLINT(runtime/int)
                     if (JSON_HEDLEY_UNLIKELY(errno == ERANGE // the value exceeds ULLONG_MAX
                                              || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
                     {

tests/src/unit-alt-string.cpp

@@ -343,41 +343,6 @@ TEST_CASE("alternative string type")
         CHECK(j2.flatten().unflatten() == j2);
     }
 
-    SECTION("contains(json_pointer)")
-    {
-        // contains(json_pointer) must compile and work with a string_t that has
-        // no c_str() and no comparison with const char* (see #5666)
-        auto j = alt_json::parse(R"({"foo": ["bar", "baz"]})");
-
-        // present: object key and array indices
-        CHECK(j.contains(alt_json::json_pointer("/foo")));
-        CHECK(j.contains(alt_json::json_pointer("/foo/0")));
-        CHECK(j.contains(alt_json::json_pointer("/foo/1")));
-
-        // missing: absent object key and out-of-range array index
-        CHECK_FALSE(j.contains(alt_json::json_pointer("/bar")));
-        CHECK_FALSE(j.contains(alt_json::json_pointer("/foo/2")));
-
-        // "-" always fails the range check
-        CHECK_FALSE(j.contains(alt_json::json_pointer("/foo/-")));
-
-        // an array index must not have a leading zero
-        CHECK_FALSE(j.contains(alt_json::json_pointer("/foo/01")));
-
-        // a reference token that is not a number
-        CHECK_FALSE(j.contains(alt_json::json_pointer("/foo/bar")));
-    }
-
-    SECTION("operator/(std::size_t)")
-    {
-        // json_pointer::operator/=(std::size_t) must compile without string_t
-        // being constructible from std::string (see #5666)
-        auto j = alt_json::parse(R"({"foo": ["bar", "baz"]})");
-
-        CHECK(j.at(alt_json::json_pointer("/foo") / std::size_t(0)) == j["foo"][0]);
-        CHECK(j.at(alt_json::json_pointer("/foo") / std::size_t(1)) == j["foo"][1]);
-    }
-
     SECTION("patch")
     {
         alt_json const patch1 = alt_json::parse(R"([{ "op": "add", "path": "/a/b", "value": [ "foo", "bar" ] }])");

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"]
+}