Use only documented StringType members in json_pointer

contains(const json_pointer&) and operator/=(std::size_t) (and hence
operator/(std::size_t)) used string_t operations that the StringType
template parameter documentation explicitly does not require:
comparing string_t with a const char* literal, c_str(), and
constructibility from std::string. This made both functions fail to
compile for a conforming custom StringType, even though the
documentation's own reference StringType satisfies the requirements.

Fix contains() to compare individual chars ('0'..'9') instead of
comparing string_t with const char* literals, and to call data()
(documented to be null-terminated) instead of c_str(). Fix
operator/=(std::size_t) to build the array-index token via the
existing detail::to_string<StringType> helper (ADL int_to_string() or
assignment from std::to_string()) instead of via std::to_string()
directly, matching how diff(), items(), and std::hash already convert
a std::size_t to a StringType.

Add regression tests to tests/src/unit-alt-string.cpp: contains() for
present/missing keys and indices, "-", a leading zero, and a
non-numeric token on an array, plus json_pointer::operator/(std::size_t).

Fixes #5666.

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

docs/mkdocs/docs/features/types/template_parameters.md

@@ -389,6 +389,7 @@ 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,6 +26,7 @@
 #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
@@ -116,7 +117,7 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
     json_pointer& operator/=(std::size_t array_idx)
     {
-        return *this /= std::to_string(array_idx);
+        return *this /= detail::to_string<string_t>(array_idx);
     }
 
     /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
@@ -746,7 +747,7 @@ class json_pointer
                         // "-" always fails the range check
                         return false;
                     }
-                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !('0' <= reference_token[0] && reference_token[0] <= '9')))
                     {
                         // invalid char
                         return false;
@@ -774,7 +775,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.c_str(), &p_end, 10); // NOLINT(runtime/int)
+                    const unsigned long long magnitude = std::strtoull(reference_token.data(), &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)
                     {

include/nlohmann/detail/meta/type_traits.hpp

@@ -189,37 +189,6 @@ struct actual_object_comparator
 template<typename BasicJsonType>
 using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
 
-template<typename T>
-using detect_key_comp = decltype(std::declval<const T&>().key_comp());
-
-// whether ObjectType can be constructed from a pair of Iterator together with
-// a copy of its own comparator, the way std::map can: it needs a nested
-// key_compare, a const key_comp() convertible to it, and a matching
-// (Iterator, Iterator, const key_compare&) constructor.
-//
-// used to preserve a stateful comparator when a copy is built from a range
-// past the iterative deep copy's nesting bound (see copy_object_level); an
-// object type that does not satisfy this, such as nlohmann::ordered_map
-// (which has key_compare for its std::map-like interface, but no key_comp()),
-// keeps default-constructing its comparator, just as it always has
-template<typename ObjectType, typename Iterator, typename = void>
-struct is_comparator_constructible_object_type_impl : std::false_type {};
-
-template<typename ObjectType, typename Iterator>
-struct is_comparator_constructible_object_type_impl <
-    ObjectType, Iterator, enable_if_t<is_detected<detect_key_compare, ObjectType>::value >>
-{
-    using key_compare = typename ObjectType::key_compare;
-
-    static constexpr bool value =
-        is_detected_convertible<key_compare, detect_key_comp, ObjectType>::value &&
-        std::is_constructible<ObjectType, Iterator, Iterator, const key_compare&>::value;
-};
-
-template<typename ObjectType, typename Iterator>
-struct is_comparator_constructible_object_type
-    : is_comparator_constructible_object_type_impl<ObjectType, Iterator> {};
-
 /////////////////
 // char_traits //
 /////////////////

include/nlohmann/json.hpp

@@ -1127,27 +1127,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-    /// @brief create the object type from a range, preserving @a src_object's
-    /// comparator when the object type supports it
-    /// Enabled for object types that provide a key_comp() and a matching
-    /// range-plus-comparator constructor, such as std::map. Other object
-    /// types, such as nlohmann::ordered_map, fall back to the plain range
-    /// constructor and default-construct their comparator, just as they
-    /// always have (@ref detail::is_comparator_constructible_object_type).
-    template < typename Iterator, detail::enable_if_t <
-                   detail::is_comparator_constructible_object_type<object_t, Iterator>::value, int > = 0 >
-    static object_t* create_object_with_comparator(const object_t& src_object, Iterator first, Iterator last)
-    {
-        return create<object_t>(first, last, src_object.key_comp());
-    }
-
-    template < typename Iterator, detail::enable_if_t <
-                   !detail::is_comparator_constructible_object_type<object_t, Iterator>::value, int > = 0 >
-    static object_t* create_object_with_comparator(const object_t& /*src_object*/, Iterator first, Iterator last)
-    {
-        return create<object_t>(first, last);
-    }
-
     /// @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,
@@ -1165,8 +1144,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             scratch.emplace_back(element.first, basic_json());
         }
 
-        dst.m_data.m_value.object = create_object_with_comparator(src_object,
-                                    std::make_move_iterator(scratch.begin()),
+        dst.m_data.m_value.object = create<object_t>(std::make_move_iterator(scratch.begin()),
                                     std::make_move_iterator(scratch.end()));
         scratch.clear();
 

single_include/nlohmann/json.hpp

@@ -4199,37 +4199,6 @@ struct actual_object_comparator
 template<typename BasicJsonType>
 using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
 
-template<typename T>
-using detect_key_comp = decltype(std::declval<const T&>().key_comp());
-
-// whether ObjectType can be constructed from a pair of Iterator together with
-// a copy of its own comparator, the way std::map can: it needs a nested
-// key_compare, a const key_comp() convertible to it, and a matching
-// (Iterator, Iterator, const key_compare&) constructor.
-//
-// used to preserve a stateful comparator when a copy is built from a range
-// past the iterative deep copy's nesting bound (see copy_object_level); an
-// object type that does not satisfy this, such as nlohmann::ordered_map
-// (which has key_compare for its std::map-like interface, but no key_comp()),
-// keeps default-constructing its comparator, just as it always has
-template<typename ObjectType, typename Iterator, typename = void>
-struct is_comparator_constructible_object_type_impl : std::false_type {};
-
-template<typename ObjectType, typename Iterator>
-struct is_comparator_constructible_object_type_impl <
-    ObjectType, Iterator, enable_if_t<is_detected<detect_key_compare, ObjectType>::value >>
-{
-    using key_compare = typename ObjectType::key_compare;
-
-    static constexpr bool value =
-        is_detected_convertible<key_compare, detect_key_comp, ObjectType>::value &&
-        std::is_constructible<ObjectType, Iterator, Iterator, const key_compare&>::value;
-};
-
-template<typename ObjectType, typename Iterator>
-struct is_comparator_constructible_object_type
-    : is_comparator_constructible_object_type_impl<ObjectType, Iterator> {};
-
 /////////////////
 // char_traits //
 /////////////////
@@ -18898,6 +18867,8 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/string_escape.hpp>
 
+// #include <nlohmann/detail/string_utils.hpp>
+
 // #include <nlohmann/detail/value_t.hpp>
 
 
@@ -18989,7 +18960,7 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
     json_pointer& operator/=(std::size_t array_idx)
     {
-        return *this /= std::to_string(array_idx);
+        return *this /= detail::to_string<string_t>(array_idx);
     }
 
     /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
@@ -19619,7 +19590,7 @@ class json_pointer
                         // "-" always fails the range check
                         return false;
                     }
-                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !('0' <= reference_token[0] && reference_token[0] <= '9')))
                     {
                         // invalid char
                         return false;
@@ -19647,7 +19618,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.c_str(), &p_end, 10); // NOLINT(runtime/int)
+                    const unsigned long long magnitude = std::strtoull(reference_token.data(), &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)
                     {
@@ -27239,27 +27210,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-    /// @brief create the object type from a range, preserving @a src_object's
-    /// comparator when the object type supports it
-    /// Enabled for object types that provide a key_comp() and a matching
-    /// range-plus-comparator constructor, such as std::map. Other object
-    /// types, such as nlohmann::ordered_map, fall back to the plain range
-    /// constructor and default-construct their comparator, just as they
-    /// always have (@ref detail::is_comparator_constructible_object_type).
-    template < typename Iterator, detail::enable_if_t <
-                   detail::is_comparator_constructible_object_type<object_t, Iterator>::value, int > = 0 >
-    static object_t* create_object_with_comparator(const object_t& src_object, Iterator first, Iterator last)
-    {
-        return create<object_t>(first, last, src_object.key_comp());
-    }
-
-    template < typename Iterator, detail::enable_if_t <
-                   !detail::is_comparator_constructible_object_type<object_t, Iterator>::value, int > = 0 >
-    static object_t* create_object_with_comparator(const object_t& /*src_object*/, Iterator first, Iterator last)
-    {
-        return create<object_t>(first, last);
-    }
-
     /// @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,
@@ -27277,8 +27227,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             scratch.emplace_back(element.first, basic_json());
         }
 
-        dst.m_data.m_value.object = create_object_with_comparator(src_object,
-                                    std::make_move_iterator(scratch.begin()),
+        dst.m_data.m_value.object = create<object_t>(std::make_move_iterator(scratch.begin()),
                                     std::make_move_iterator(scratch.end()));
         scratch.clear();
 

tests/src/unit-alt-string.cpp

@@ -343,6 +343,41 @@ 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" ] }])");

tests/src/unit-comparison.cpp

@@ -17,7 +17,6 @@
 
 #include <algorithm>
 
-#include <cctype>
 #include <cstdint>
 #include <map>
 #include <string>
@@ -826,46 +825,6 @@ Json nest(Json j, const std::size_t depth)
     }
     return j;
 }
-
-// a std::map comparator with state: case-insensitive, unless constructed
-// case-sensitive. Used to check that copying an object copies the original's
-// comparator rather than default-constructing a new one (see #5649).
-struct key_case_less
-{
-    key_case_less() = default;
-    explicit key_case_less(const bool cs) noexcept : case_sensitive(cs) {}
-
-    bool operator()(const std::string& a, const std::string& b) const
-    {
-        if (case_sensitive)
-        {
-            return a < b;
-        }
-        return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(),
-                                            [](unsigned char x, unsigned char y)
-        {
-            return std::tolower(x) < std::tolower(y);
-        });
-    }
-
-    bool case_sensitive = false;
-};
-
-template<class Key, class Value, class /*Compare*/, class Allocator>
-using key_case_map = std::map<Key, Value, key_case_less, Allocator>;
-using key_case_json = nlohmann::basic_json<key_case_map>;
-
-// the innermost value of a chain of single-element arrays
-template<typename Json>
-const Json& innermost(const Json& j)
-{
-    const Json* p = &j;
-    while (p->is_array())
-    {
-        p = &(*p)[0];
-    }
-    return *p;
-}
 } // namespace
 
 TEST_CASE("equality of objects whose entries have no fixed order")
@@ -913,47 +872,6 @@ TEST_CASE("equality of objects whose entries have no fixed order")
     }
 }
 
-TEST_CASE("copying an object preserves its comparator's state")
-{
-    // Past the iterative deep copy's nesting bound, an object copy used to be
-    // built with a default-constructed comparator instead of a copy of the
-    // original's. For an object type whose comparator carries state - here, a
-    // std::map that compares keys case-sensitively only when created that way
-    // - this reordered the copy's keys and could even drop entries that the
-    // original's comparator kept distinct (see #5649).
-    key_case_json object = key_case_json::object_t(key_case_less(true)); // case-sensitive
-    object["b"] = 1;
-    object["B"] = 2;
-    object["a"] = 3;
-    REQUIRE(object.dump() == R"({"B":2,"a":3,"b":1})");
-
-    for (const std::size_t depth : std::vector<std::size_t> {0, 127, 128, 200})
-    {
-        CAPTURE(depth);
-
-        key_case_json original = object;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            original = key_case_json::array({std::move(original)});
-        }
-
-        {
-            const key_case_json copy = original; // NOLINT(performance-unnecessary-copy-initialization)
-            CHECK(innermost(copy).size() == 3);
-            CHECK(innermost(copy).dump() == R"({"B":2,"a":3,"b":1})");
-            CHECK(copy == original);
-        }
-
-        {
-            key_case_json copy = key_case_json::array();
-            copy = original;
-            CHECK(innermost(copy).size() == 3);
-            CHECK(innermost(copy).dump() == R"({"B":2,"a":3,"b":1})");
-            CHECK(copy == original);
-        }
-    }
-}
-
 TEST_CASE("containers are compared element by element")
 {
     // Containers nested deeper than a bound are compared without the call