Regenerate the amalgamated headers

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

.inferconfig

@@ -1,6 +1,7 @@
 {
   "_comment": "Used by the ci_infer CMake target (#5715 item 4b). fail-on-issue makes CI fail on Infer findings; disable-issue-type is a type-level baseline for the ~174 pre-existing findings (all PULSE_UNNECESSARY_COPY*/PULSE_RESOURCE_LEAK/PULSE_CONST_REFABLE, mostly in test code) triaged in run https://github.com/nlohmann/json/actions/runs/35829411620 on commit 1054b2097, so CI fails only on a NEW issue type. Remove an entry here once its findings have been fixed or explicitly accepted.",
   "_comment_pulse": "Pulse stops exploring paths after pulse-max-disjuncts (default 20). With the default, basic_json::replace_value() (destroy + assert_invariant) exceeds the limit, Pulse loses the stored type, and reports false NULLPTR_DEREFERENCE findings for get_ptr() results in tests/src/unit-pointer_access.cpp.",
+  "_comment_view": "Infer's model of std::unique_ptr mixes up values that are returned by value and own one: basic_json_document (parse() results) and the `built` values of the build() helper in tests/src/unit-json_view_builder.cpp. It reports USE_AFTER_DELETE for one of them after the destructor of an unrelated object (e.g. ~built() on line 345 invalidating `shallow` on line 350 of that file, or two documents parsed in one lambda in tests/src/unit-json_view_dump.cpp). AddressSanitizer and Valgrind are clean on the same tests, so reports for the json_view test files are excluded; findings reported in the library headers are still reported.",
   "pulse-max-disjuncts": 40,
   "fail-on-issue": true,
   "disable-issue-type": [
@@ -10,5 +11,8 @@
     "PULSE_UNNECESSARY_COPY_OPTIONAL",
     "PULSE_RESOURCE_LEAK",
     "PULSE_CONST_REFABLE"
+  ],
+  "report-block-list-path-regex": [
+    "tests/src/unit-json_view.*\\.cpp"
   ]
 }

docs/mkdocs/docs/api/basic_json/find.md

@@ -93,7 +93,8 @@ Logarithmic in the size of the JSON object.
 
 - [count](count.md) returns the number of occurrences of a key
 - [contains](contains.md) checks whether a key exists
-- [basic_json_view::find](../basic_json_view/find.md) - the same lookup on a zero-copy view
+- [basic_json_view::find](../basic_json_view/find.md) - the same lookup on a zero-copy view (a duplicate key resolves
+  to the first member, whereas `parse()` keeps the last)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/front.md

@@ -51,7 +51,8 @@ Constant.
 ## See also
 
 - [back](back.md) to access the last element
-- [basic_json_view::front](../basic_json_view/front.md) - the same access on a zero-copy view
+- [basic_json_view::front](../basic_json_view/front.md) - the same access on a zero-copy view (document order, not
+  sorted; duplicate keys are visited)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/items.md

@@ -100,7 +100,7 @@ When iterating over an array, `key()` will return the index of the element as st
 - [begin](begin.md) returns an iterator to the first element
 - [end](end.md) returns an iterator to one past the last element
 - [basic_json_view::items](../basic_json_view/items.md) - the same range on a zero-copy view (`#!cpp const auto`,
-  not `#!cpp const auto&`: items are produced on the fly)
+  not `#!cpp const auto&`: items are produced on the fly; document order, not sorted; duplicate keys are visited)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/operator[].md

@@ -275,8 +275,9 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [runtime assertions](../../features/assertions.md)
 - see [`at`](at.md) for access by reference with range checking
 - see [`value`](value.md) for access with default value
-- [basic_json_view::operator[]](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (always
-  returns a discarded view instead of assuming undefined behavior)
+- [basic_json_view::operator[]](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (a duplicate
+  key resolves to the first member, whereas `parse()` keeps the last; a missing key gives a discarded view instead of
+  undefined behavior)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json_view/at.md

@@ -41,7 +41,7 @@ basic_json_view at(const json_pointer& ptr) const;
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 
@@ -77,8 +77,8 @@ None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics
 1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
    another, in document order, stopping at the first match. Each comparison first checks the
    key's length -- already known from the index, without reading the key bytes -- before comparing its content.
-   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
-   on average.
+   Objects with 128 or more members get a hash index of their keys while parsing, so that a lookup in them takes
+   constant time on average.
 2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
    index (unlike `BasicJsonType`'s array, which is random-access).
 3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at

docs/mkdocs/docs/api/basic_json_view/back.md

@@ -13,7 +13,7 @@ The last element or member value. For a primitive value (number, string, boolean
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 
@@ -33,8 +33,7 @@ index.
 ## Notes
 
 Unlike [`BasicJsonType::back()`](../basic_json/back.md), which has undefined behavior for an empty array or object,
-`back()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and for a
-discarded view, where `BasicJsonType::back()` also throws.
+`back()` throws `invalid_iterator.214` for an empty array, an empty object, a null value, or a discarded view.
 
 ## Examples
 

docs/mkdocs/docs/api/basic_json_view/begin.md

@@ -23,7 +23,7 @@ Constant.
 ## Notes
 
 For an object, iteration visits **every** member, including all occurrences of a duplicate key -- unlike
-[`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), [`contains`](contains.md), and [`count`](count.md),
+[`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), and [`contains`](contains.md),
 which all resolve to the *first* member with a given key. See the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]`.
 
@@ -31,6 +31,10 @@ Because objects are iterated in document order rather than sorted by key, the or
 iterating the [`materialize()`](materialize.md)d `BasicJsonType` value would produce: a `#!cpp basic_json` object
 (`std::map`-backed by default) sorts its keys, while a view does not.
 
+An `ordered_json` value also keeps document order, but it keeps only one entry per key: as `parse()` does, it keeps the
+*last* value, at the position of the key's *first* occurrence. The view, in contrast, visits every member, including
+the duplicates.
+
 ## Examples
 
 ??? example

docs/mkdocs/docs/api/basic_json_view/contains.md

@@ -35,8 +35,8 @@ No-throw guarantee: this function never throws exceptions.
 1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
    another, in document order, stopping at the first match. Each comparison first checks the
    key's length -- already known from the index, without reading the key bytes -- before comparing its content.
-   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
-   on average.
+   Objects with 128 or more members get a hash index of their keys while parsing, so that a lookup in them takes
+   constant time on average.
 2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
    that level or the index into the array -- as for [`operator[]`](operator[].md#complexity) and
    [`at`](at.md#complexity) with a JSON pointer.
@@ -55,7 +55,8 @@ view.
 
 !!! info "Postconditions"
 
-    If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md). If
+    If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md) and
+    `#!cpp v.at(key)` does not throw. If
     `#!cpp v.contains(ptr)` returns `#!cpp true`, then `#!cpp v[ptr]` is not discarded and `#!cpp v.at(ptr)` does not
     throw.
 

docs/mkdocs/docs/api/basic_json_view/count.md

@@ -6,7 +6,8 @@ size_type count(const char* key) const;
 size_type count(const string_t& key) const;
 ```
 
-Returns `#!cpp 1` if the value is an object with a member with key `key`, `#!cpp 0` otherwise.
+Returns the number of members with key `key` if the value is an object, `#!cpp 0` otherwise. Members with a repeated
+key are all counted.
 
 ## Parameters
 
@@ -15,7 +16,8 @@ Returns `#!cpp 1` if the value is an object with a member with key `key`, `#!cpp
 
 ## Return value
 
-`#!cpp 1` if the value is an object and has a member with key `key`, `#!cpp 0` otherwise.
+the number of members of the object with key `key` (duplicates included), or `#!cpp 0` if the value is not an object
+or has no such member.
 
 ## Exception safety
 
@@ -23,36 +25,30 @@ No-throw guarantee: this function never throws exceptions.
 
 ## Complexity
 
-Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after another,
-in document order, stopping at the first match. Each comparison first checks the key's length
--- already known from the index, without reading the key bytes -- before comparing its content.
-Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time on
-average.
+Linear in the number of members: unlike the lookup functions, `count()` does not stop at the first match, because it
+has to count every member with the key. Members are compared one after another, in document order. Each comparison
+first checks the key's length -- already known from the index, without reading the key bytes -- before comparing its
+content. The hash index of the keys of objects with 128 or more members does not help here, since every member
+is visited.
 
 ## Notes
 
-!!! warning "Duplicate keys: the first member wins"
-
-    If the source text repeats a key, this resolves to the *first* member with it, not to the last one that
-    [`materialize()`](materialize.md) and `parse()` keep. See the [Notes on duplicate keys](operator[].md#notes) of
-    `operator[]` and [Duplicate keys](../../features/json_view.md#duplicate-keys) for the reasons and for how to get
-    the last value.
-
 This method always returns `#!cpp 0` when the value is not an object -- including a [discarded](is_discarded.md)
 view.
 
-Unlike [`BasicJsonType::count()`](../basic_json/count.md), whose return value can in principle exceed `#!cpp 1` for
-an `ObjectType` that allows multiple entries per key, `count()` here never does: it is exactly
-[`contains()`](contains.md) as `#!cpp 0`/`#!cpp 1`. This holds even if the source text has a duplicate key -- see the
-[Notes on duplicate keys](operator[].md#notes) of `operator[]` -- because a `#!cpp count() > 1` result would require
-counting every member with a matching key (the lookup functions resolve to the *first* one).
+If the source text repeats a key, `count()` returns more than `#!cpp 1` for it, even though the
+[materialized](materialize.md) value (like the result of `parse()`) would have only one member with that key. Hence
+`#!cpp count(key) > 1` detects duplicate keys. This is unlike the lookup functions
+([`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), [`contains`](contains.md)), which resolve to the
+*first* member; see the [Notes on duplicate keys](operator[].md#notes) of `operator[]`.
 
 ## Examples
 
 ??? example
 
-    The example below validates that every transaction of a batch carries a mandatory `amount` field, using
-    `count()` before deciding whether to materialize a transaction at all.
+    The example below validates that every transaction of a batch carries exactly one `amount` field, using
+    `count()` before deciding whether to materialize a transaction at all. It reports a transaction with no `amount`
+    field and one with a duplicated `amount` field.
 
     ```cpp
     --8<-- "examples/basic_json_view__count.cpp"

docs/mkdocs/docs/api/basic_json_view/dump.md

@@ -60,11 +60,13 @@ Linear in the size of the output text.
 The walk over the subtree is iterative, so the nesting depth it can write is limited by available memory only, not by
 the call stack -- as for [`materialize()`](materialize.md).
 
-Strings are escaped by the same rules as [`BasicJsonType::dump`](../basic_json/dump.md). With
-`#!cpp numbers == number_format::shortest`, floats are written with the library's shortest round-trip conversion,
+Strings are escaped by the same rules as [`BasicJsonType::dump`](../basic_json/dump.md).
+
+With `#!cpp numbers == number_format::shortest`, floats are written with the library's shortest round-trip conversion,
 exactly as [`BasicJsonType::dump`](../basic_json/dump.md) would (e.g. `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`), and
 integers are copied from the source text -- already canonical in JSON, so this matches their shortest form too --
 except that `#!cpp -0` is written as `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it.
+
 `#!cpp number_format::source` copies every number exactly as written in the source text instead, with no exception
 for `#!cpp -0` -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0.0`, `#!cpp -0`, or all digits of an integer literal with more
 digits than any number type holds (such a literal is itself classified as a float, see

docs/mkdocs/docs/api/basic_json_view/find.md

@@ -28,8 +28,8 @@ No-throw guarantee: this function never throws exceptions.
 Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after another,
 in document order, stopping at the first match. Each comparison first checks the key's length
 -- already known from the index, without reading the key bytes -- before comparing its content.
-Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time on
-average.
+Objects with 128 or more members get a hash index of their keys while parsing, so that a lookup in them takes
+constant time on average.
 
 ## Notes
 

docs/mkdocs/docs/api/basic_json_view/front.md

@@ -13,7 +13,7 @@ The first element or member value. For a primitive value (number, string, boolea
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 
@@ -31,8 +31,8 @@ Constant.
 ## Notes
 
 Unlike [`BasicJsonType::front()`](../basic_json/front.md), which has undefined behavior for an empty array or
-object, `front()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and
-for a discarded view, where `BasicJsonType::front()` also throws.
+object, `front()` throws `invalid_iterator.214` for an empty array, an empty object, a null value, or a discarded
+view.
 
 ## Examples
 

docs/mkdocs/docs/api/basic_json_view/get.md

@@ -10,8 +10,8 @@ Converts the value to `T`.
 For the types below, the conversion works directly on the flat index -- no `BasicJsonType` value is built for it:
 
 - `#!cpp bool`
-- arithmetic types other than `#!cpp bool` (from a number; from a boolean, as `#!cpp 0`/`#!cpp 1`, exactly as
-  [`BasicJsonType::get<T>()`](../basic_json/get.md) converts a boolean)
+- arithmetic types other than `#!cpp bool` (for a boolean, `#!cpp 0`/`#!cpp 1`, exactly as for
+  [`BasicJsonType::get<T>()`](../basic_json/get.md))
 - `#!cpp std::nullptr_t`
 - `#!cpp std::basic_string<char, Traits, Alloc>` (including `string_t`) -- a copy of the string
 - [`string_view_t`](index.md#member-types) -- **no copy**: the returned view points into the document's
@@ -19,10 +19,10 @@ For the types below, the conversion works directly on the flat index -- no `Basi
   document's own buffer of decoded strings (see [`get_string()`](get_string.md))
 - `BasicJsonType` -- equivalent to [`materialize()`](materialize.md)
 - `basic_json_view` -- returns `#!cpp *this`
-- `#!cpp std::vector<U, A>` -- element by element, each converted with `#!cpp get<U>()`; `#!cpp
+- `#!cpp std::vector<U, A>` -- from an array, element by element, each converted with `#!cpp get<U>()`; `#!cpp
   std::vector<basic_json_view>` keeps a view of every element instead of a value
 - `#!cpp std::map<K, V, C, A>` and `#!cpp std::unordered_map<K, V, H, E, A>`, if `K` is constructible from a `#!cpp
-  (const char*, std::size_t)` pair -- member by member, each value converted with `#!cpp get<V>()`; with a repeated
+  (const char*, std::size_t)` pair -- from an object, member by member, each value converted with `#!cpp get<V>()`; with a repeated
   key, the *last* value is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) (and
   [`materialize()`](materialize.md)) does; `#!cpp std::map<std::string, basic_json_view>` keeps views of the members
   instead of values
@@ -43,7 +43,7 @@ the value, converted to `T`
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 
@@ -62,6 +62,9 @@ None of the exceptions thrown directly by this function (the first three bullets
 [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no `BasicJsonType` value to point at. An
 exception thrown while converting through `materialize()` (the last bullet) is different: it is thrown by a real
 `BasicJsonType` value, so it **does** carry a `JSON_DIAGNOSTICS` path if `BasicJsonType` was built with it enabled.
+That path is relative to the root of the view's subtree, because `materialize()` builds only the subtree (with parent
+pointers): it is empty if the failing value is the subtree's root itself, and it never is the path within the whole
+document.
 
 ## Complexity
 
@@ -73,8 +76,8 @@ exception thrown while converting through `materialize()` (the last bullet) is d
 - `#!cpp std::map`/`#!cpp std::unordered_map`: linear in the number of members for walking them, plus the container's
   own insertion cost per member (logarithmic for `#!cpp std::map`, amortized constant for `#!cpp
   std::unordered_map`), times the complexity of converting one member to the mapped type.
-- every other `T`: linear in the size of the subtree (building the `BasicJsonType` value), plus the complexity of
-  [`BasicJsonType::get<T>()`](../basic_json/get.md) on it.
+- every other `T`: the cost of [`materialize()`](materialize.md) and of destroying the `BasicJsonType` value
+  afterwards, plus that of [`BasicJsonType::get<T>()`](../basic_json/get.md).
 
 ## Notes
 

docs/mkdocs/docs/api/basic_json_view/get_string.md

@@ -15,7 +15,7 @@ had to be decoded once when the document was parsed).
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 
@@ -37,9 +37,14 @@ hand out a reference to a stored `string_t`. `get_string()` (equivalently, [`get
 zero-copy alternative: [`BasicJsonType::get_ref<const string_t&>()`](../basic_json/get_ref.md) is its closest
 counterpart, except that it returns a view instead of a reference to a value that must already exist.
 
+`get_string()` borrows the string: nothing is copied, whereas [`get<std::string>()`](get.md) copies it. For a borrowed
+document, the returned [`string_view_t`](index.md#member-types) is valid as long as the caller's buffer; for an owned
+one, as long as the document.
+
 The returned [`string_view_t`](index.md#member-types) is valid exactly as long as the view that produced it -- see the
 [validity rules](index.md) of `basic_json_view` -- and, for a string with no escapes, for as long as the document's
-source text.
+source text, which for a borrowed document must remain valid **and unmodified** for as long as the document exists,
+since floating-point values and unescaped strings are read from the source lazily.
 
 ## Examples
 

docs/mkdocs/docs/api/basic_json_view/get_to.md

@@ -5,12 +5,15 @@ template<typename T>
 T& get_to(T& v) const;
 ```
 
-Converts the value to `T` and assigns it to `v`. Equivalent to
+Converts the value to `T` and stores it in `v`, in one of two ways:
 
-```cpp
-v = get<T>();
-return v;
-```
+- For the types that [`get<T>()`](get.md) converts directly -- arithmetic types, `#!cpp bool`,
+  `#!cpp std::nullptr_t`, [`string_view_t`](index.md#member-types), `#!cpp std::basic_string`, `BasicJsonType`,
+  `basic_json_view`, `#!cpp std::vector`, and `#!cpp std::map`/`#!cpp std::unordered_map` with string keys -- `v` is
+  assigned: `#!cpp v = get<T>()`.
+- For every other type, the subtree is built into a `BasicJsonType` value and `#!cpp materialize().get_to(v)` is
+  called, i.e. `from_json()` is invoked with the existing `v`, exactly as
+  [`BasicJsonType::get_to()`](../basic_json/get_to.md) does.
 
 ## Template parameters
 
@@ -28,15 +31,27 @@ return v;
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, `v` is not modified.
+- For the directly converted types: strong exception safety. If an exception is thrown, `v` is not modified.
+- For every other type: as for [`BasicJsonType::get_to()`](../basic_json/get_to.md). `materialize()` throws before `v`
+  is touched, but a `from_json()` that throws may leave `v` partly modified.
 
 ## Exceptions
 
-Whatever [`get<T>()`](get.md) throws for the same value and `T`.
+- For the directly converted types: whatever [`get<T>()`](get.md) throws for the same value and `T`.
+- For every other type: whatever [`materialize()`](materialize.md) and
+  [`BasicJsonType::get_to()`](../basic_json/get_to.md) throw.
 
 ## Complexity
 
-Whatever [`get<T>()`](get.md) has for the same `T`.
+- For the directly converted types: whatever [`get<T>()`](get.md) has for the same `T`.
+- For every other type: that of [`materialize()`](materialize.md), plus that of
+  [`BasicJsonType::get_to()`](../basic_json/get_to.md).
+
+## Notes
+
+The difference between the two ways matters for a `from_json()` that sets only the fields present in the JSON: since
+it runs on the existing `v`, the other fields of `v` keep their values, whereas assigning `get<T>()` would replace
+them with those of a default-constructed `T`.
 
 ## Examples
 

docs/mkdocs/docs/api/basic_json_view/index.md

@@ -14,18 +14,27 @@ to the document and a pointer into its index), trivially copyable. A view is val
 - the document has not been re-parsed with [`read()`](../basic_json_document/read.md) (or
   [`parse()`](../basic_json_document/parse.md) into it) or shrunk with
   [`shrink_to_fit()`](../basic_json_document/shrink_to_fit.md) since the view was taken, and
-- if the document borrows its source text, that text is still alive.
+- if the document borrows its source text, that text is still alive and unmodified (floating-point values and
+  unescaped strings are read from it lazily).
 
 Moving the document itself does not invalidate its views: the index is heap-allocated independently of the
 `basic_json_document` object.
 
-`basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, element
-access, lookup, iteration, conversion, and comparison -- [`get<T>()`](get.md), [`get_string()`](get_string.md),
-[`number_token()`](number_token.md), and [`materialize()`](materialize.md) to build the `BasicJsonType` value of a
-subtree on demand. [`operator[]`](operator%5B%5D.md), [`at`](at.md), [`contains`](contains.md), and
-[`value`](value.md) also accept a [`json_pointer`](../json_pointer/index.md). [`operator==`](operator_eq.md) and
-[`operator!=`](operator_ne.md) compare two views, or a view and a `BasicJsonType` value, without ever building a
-`BasicJsonType` value for a view; no ordering comparison (`#!cpp operator<`) is provided.
+`basic_json_view` provides the read-only part of the `BasicJsonType` interface:
+
+- the type-inspection functions,
+- element access,
+- lookup,
+- iteration,
+- conversion: [`get<T>()`](get.md), [`get_string()`](get_string.md), [`number_token()`](number_token.md), and
+  [`materialize()`](materialize.md) to build the `BasicJsonType` value of a subtree on demand, and
+- comparison: [`operator==`](operator_eq.md) and [`operator!=`](operator_ne.md) compare two views, or a view and a
+  `BasicJsonType` value, without ever building a `BasicJsonType` value for a view; no ordering comparison
+  (`#!cpp operator<`) is provided.
+
+[`operator[]`](operator%5B%5D.md), [`at`](at.md), [`contains`](contains.md), and [`value`](value.md) also accept a
+[`json_pointer`](../json_pointer/index.md). Unlike `basic_json`, there are no implicit conversion operators (no
+`#!cpp operator ValueType()`), and no `#!cpp get_ptr()` or `#!cpp get_ref()`; see [`get`](get.md).
 
 `basic_json_view` itself is always read-only -- it never has a `set` or `push_back` of its own. A view of an
 **editable** document (`#!cpp Editable == true`) sees every edit made through
@@ -61,7 +70,6 @@ still refers to it -- including ones taken before the change -- reads the new va
 - **string_view_t** - `#!cpp std::string_view` on C++17 and newer, a minimal internal substitute otherwise
 - **iterator**, **const_iterator** - a forward iterator over the elements of an array or the member values of an
   object, in document order; both names refer to the same type, since a view is always read-only
-- **item** - a (key, value) pair produced by [`items()`](items.md)
 - [**number_format**](number_format.md) - how [`dump()`](dump.md) writes numbers
 
 ## Member functions

docs/mkdocs/docs/api/basic_json_view/items.md

@@ -4,9 +4,9 @@
 /* unspecified */ items() const noexcept;
 ```
 
-Returns a range of [`item`](index.md#member-types) values -- (key, value) pairs -- for use in range-based for loops.
-The key of an array element is its index, converted to a string, as for
-[`BasicJsonType::items()`](../basic_json/items.md).
+Returns a range of items -- (key, value) pairs -- for use in range-based for loops. An item's `#!cpp key()` is a
+`#!cpp string_view_t` (for an array element, its index converted to a string, as for
+[`BasicJsonType::items()`](../basic_json/items.md)), and its `#!cpp value()` is a `basic_json_view` of the element.
 
 The returned type is not part of the public API and may change between versions; use a range-based for loop (see the
 example), or `#!cpp decltype(v.items())` if you need to name it.
@@ -33,8 +33,8 @@ is nothing for a reference to bind to.
 
 ## Return value
 
-A range whose iterators dereference to [`item`](index.md#member-types) and whose `#!cpp begin()`/`#!cpp end()` are
-equivalent to [`basic_json_view::begin()`](begin.md)/[`end()`](end.md), in document order.
+A range whose iterators dereference to an item (with `#!cpp key()` and `#!cpp value()`, see above) and whose
+`#!cpp begin()`/`#!cpp end()` are equivalent to [`basic_json_view::begin()`](begin.md)/[`end()`](end.md), in document order.
 
 ## Exception safety
 
@@ -48,14 +48,14 @@ Constant.
 
 As for [`begin()`](begin.md)/[`end()`](end.md), `items()` visits **every** member of an object, including all
 occurrences of a duplicate key -- unlike [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md),
-[`contains`](contains.md), and [`count`](count.md), which resolve to the *first* member with a given key. See the
+and [`contains`](contains.md), which resolve to the *first* member with a given key. See the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]`.
 
 !!! danger "Lifetime issues"
 
-    As for `BasicJsonType::items()`, calling `items()` on a temporary view (or a temporary document) is dangerous:
-    the range refers back to the document, so the document must outlive the loop. See
-    [#2040](https://github.com/nlohmann/json/issues/2040) for the `BasicJsonType` background.
+    Unlike `BasicJsonType::items()` (see [#2040](https://github.com/nlohmann/json/issues/2040)), calling `items()` on
+    a temporary view is safe, for instance `#!cpp for (auto item : v["a"].items())`: the returned range holds a copy
+    of the view. What must outlive the loop is the document and, for a borrowed document, the source buffer.
 
 ## Examples
 

docs/mkdocs/docs/api/basic_json_view/number_token.md

@@ -15,7 +15,7 @@ and [`materialize()`](materialize.md) can only represent approximately, as a `nu
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 

docs/mkdocs/docs/api/basic_json_view/operator[].md

@@ -50,7 +50,7 @@ basic_json_view operator[](const json_pointer& ptr) const;
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 
@@ -83,8 +83,8 @@ None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics
    another, in document order, stopping at the first match. Each comparison first checks the
    key's length -- already known from the index, without reading the key bytes -- before comparing its content, so a
    key of a different length than `key` is rejected without touching the source text.
-   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
-   on average.
+   Objects with 128 or more members get a hash index of their keys while parsing, so that a lookup in them takes
+   constant time on average.
 2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
    index (unlike `BasicJsonType`'s array, which is random-access).
 3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
@@ -110,13 +110,13 @@ document.
 !!! warning "Duplicate keys: the first member wins"
 
     If the source text has an object with a duplicate key, `#!cpp operator[]` (and [`at`](at.md), [`find`](find.md),
-    [`contains`](contains.md), [`count`](count.md), [`value`](value.md), and JSON pointer resolution) all resolve to
+    [`contains`](contains.md), [`value`](value.md), and JSON pointer resolution) all resolve to
     the *first* member with that key, because a lookup can stop as soon as it finds a match. This is different from
     [`materialize()`](materialize.md) (and [`BasicJsonType::parse()`](../basic_json/parse.md)), which replay every
     member in order and so keep the *last* value for a repeated key, so `#!cpp v["a"]` and
     `#!cpp v.materialize()["a"]` can differ. To get the value `parse()` would give, use
     [`materialize()`](materialize.md) or iterate the members with [`items()`](items.md) and keep the last match.
-    The hash index of a larger object (128 members or more) leads to the first member of a key as well.
+    The key hash index of a larger object (128 members or more) leads to the first member of a key as well.
     [`begin()`](begin.md)/[`end()`](end.md) and [`items()`](items.md) iterate over *all* members, including
     duplicates, in document order. See [Duplicate keys](../../features/json_view.md#duplicate-keys) and
     [`size()`](size.md#notes).

docs/mkdocs/docs/api/basic_json_view/type_name.md

@@ -14,14 +14,14 @@ same string for a discarded `BasicJsonType` value).
 a string representation of the type ([`value_t`](../basic_json/value_t.md)):
 
 | Value type                                         | return value  |
-|-----------------------------------------------------|---------------|
-| `#!json null`                                        | `"null"`      |
-| boolean                                              | `"boolean"`   |
-| string                                               | `"string"`    |
-| number (integer, unsigned integer, floating-point)   | `"number"`    |
-| object                                               | `"object"`    |
-| array                                                | `"array"`     |
-| discarded                                            | `"discarded"` |
+|----------------------------------------------------|---------------|
+| `#!json null`                                      | `"null"`      |
+| boolean                                            | `"boolean"`   |
+| string                                             | `"string"`    |
+| number (integer, unsigned integer, floating-point) | `"number"`    |
+| object                                             | `"object"`    |
+| array                                              | `"array"`     |
+| discarded                                          | `"discarded"` |
 
 `type_name()` never returns `#!cpp "binary"`, since a JSON text has no binary values (see
 [`is_binary()`](is_binary.md)); it also never returns `#!cpp "invalid"`, since a view's `#!cpp kind` always comes

docs/mkdocs/docs/api/basic_json_view/value.md

@@ -44,7 +44,7 @@ equivalent) deduce `string_t`, not `const char*`, for their return type and for
 
 ## Exception safety
 
-Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+Strong guarantee: there are no changes to the view or the document it refers to.
 
 ## Exceptions
 
@@ -70,8 +70,8 @@ None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics
 1. Linear in the number of members: as for [`operator[]`](operator[].md#complexity), members are compared one after
    another, in document order, stopping at the first match. Plus the complexity of converting
    the found member to `T` (see [`get`](get.md)).
-   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
-   on average.
+   Objects with 128 or more members get a hash index of their keys while parsing, so that a lookup in them takes
+   constant time on average.
 2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
    that level or the index into the array -- as for the [`operator[]`](operator[].md#complexity) and
    [`at`](at.md#complexity) overloads that take a JSON pointer. Plus the complexity of converting the resolved value

docs/mkdocs/docs/api/macros/json_view_no_simd.md

@@ -14,10 +14,12 @@ The same input is accepted or rejected either way, with the same values, and err
 the speed differs. The macro exists for platforms whose compilers lack the intrinsics headers, and to test the portable
 code.
 
-!!! warning "Define consistently"
+!!! note "ABI compatibility"
 
-    The macro selects between two definitions of the same inline functions. It must therefore be defined identically for
-    **every** translation unit that includes `<nlohmann/json_view.hpp>`; prefer a compile definition on the target.
+    The macro selects between two definitions of the same inline functions. Whether it is defined is encoded in the
+    [namespace](../../features/namespace.md) (tag `_vns`), resulting in distinct symbol names. Translation units
+    compiled with and without it can therefore be linked into the same program without One Definition Rule (ODR)
+    violations, but they cannot exchange instances of library types.
 
 ## Default definition
 

docs/mkdocs/docs/api/macros/json_view_use_ssse3.md

@@ -17,12 +17,12 @@ Define the macro only together with a compiler option that enables SSSE3 (e.g. `
 has it), and only for programs that run on such CPUs. It saves the check of the CPU, which costs little. The same
 input is accepted or rejected either way; only the speed of non-ASCII text differs.
 
-!!! warning "Define consistently"
+!!! note "ABI compatibility"
 
-    The macro selects between two definitions of the same inline functions. It must therefore be defined identically,
-    with the same compiler options, for **every** translation unit that includes `<nlohmann/json_view.hpp>`; mixing
-    translation units that define it with ones that do not is an ODR violation. Prefer a compile definition on the
-    target.
+    The macro selects between two definitions of the same inline functions. Whether it is defined is encoded in the
+    [namespace](../../features/namespace.md) (tag `_vssse3`, on every architecture), resulting in distinct symbol
+    names. Translation units compiled with and without it can therefore be linked into the same program without One
+    Definition Rule (ODR) violations, but they cannot exchange instances of library types.
 
 ## Default definition
 

docs/mkdocs/docs/api/macros/nlohmann_json_namespace.md

@@ -39,5 +39,6 @@ the library.
 ## Version history
 
 - Added in version 3.11.0. Changed inline namespace name in version 3.11.2. Added the ABI tag `_dp` in
-  version 3.12.0, and the ABI tags `_bics`, `_psp`, `_snul`, `_sbu8`, and `_ekmo` in version 3.13.0; see
+  version 3.12.0, and the ABI tags `_bics`, `_psp`, `_snul`, `_sbu8`, `_ekmo`, `_vns`, and `_vssse3` in version
+  3.13.0; see
   [`nlohmann` Namespace](../../features/namespace.md#structure).

docs/mkdocs/docs/examples/basic_json_view__count.cpp

@@ -5,13 +5,14 @@ using json_document = nlohmann::json_document;
 
 int main()
 {
-    // validate that every transaction of a batch carries a mandatory
+    // validate that every transaction of a batch carries exactly one
     // "amount" field before materializing any of them into a nlohmann::json
-    // value -- count() returns 0 or 1 for an object
+    // value -- count() counts every member with the key
     json_document batch = json_document::parse(R"(
       [
         {"id": 1, "amount": 9.99},
-        {"id": 2}
+        {"id": 2},
+        {"id": 3, "amount": 5.00, "amount": 500.00}
       ]
     )");
 
@@ -19,9 +20,10 @@ int main()
     for (std::size_t i = 0; i < transactions.size(); ++i)
     {
         const auto transaction = transactions[i];
-        if (transaction.count("amount") == 0)
+        const auto amounts = transaction.count("amount");
+        if (amounts != 1)
         {
-            std::cout << "transaction " << i << " is missing \"amount\"\n";
+            std::cout << "transaction " << i << " has " << amounts << " \"amount\" fields\n";
             continue;
         }
         std::cout << "transaction " << i << ": " << transaction["amount"].materialize().dump() << '\n';

docs/mkdocs/docs/examples/basic_json_view__count.output

@@ -1,2 +1,3 @@
 transaction 0: 9.99
-transaction 1 is missing "amount"
+transaction 1 has 0 "amount" fields
+transaction 2 has 2 "amount" fields

docs/mkdocs/docs/features/json_view.md

@@ -67,9 +67,10 @@ table). [`parse_copy()`](../api/basic_json_document/parse_copy.md) always owns a
 
 !!! warning "A borrowed document depends on your buffer"
 
-    If a document borrows its text, that text **must outlive the document** (and every view taken from it). Reading
-    or writing through a view after the underlying buffer is gone is undefined behavior, exactly as it would be for
-    a dangling `#!cpp std::string_view`.
+    If a document borrows its text, that text **must outlive the document** (and every view taken from it) and must
+    stay **unmodified** for as long as the document exists, since floating-point values and unescaped strings are
+    read from it lazily. Reading or writing through a view after the underlying buffer is gone is undefined behavior,
+    exactly as it would be for a dangling `#!cpp std::string_view`.
 
 A view is valid only while all of the following hold:
 
@@ -77,7 +78,7 @@ A view is valid only while all of the following hold:
 - the document has not been re-parsed since the view was taken (with [`read()`](../api/basic_json_document/read.md)
   or [`parse()`](../api/basic_json_document/parse.md) into it),
 - the document has not had [`shrink_to_fit()`](../api/basic_json_document/shrink_to_fit.md) called on it since, and
-- if the document borrows its source text, that text is still alive.
+- if the document borrows its source text, that text is still alive and unmodified.
 
 Moving the `basic_json_document<>` itself is fine and does **not** invalidate its views: the index is a separate heap
 allocation that keeps its address across the move. Take a fresh view from [`root()`](../api/basic_json_document/root.md)
@@ -167,10 +168,10 @@ document: `#!cpp auto v = json_document::parse(text).root();` does not compile.
 
     If an object in the source text repeats a key, [`operator[]`](../api/basic_json_view/operator%5B%5D.md),
     [`at`](../api/basic_json_view/at.md), [`find`](../api/basic_json_view/find.md),
-    [`value`](../api/basic_json_view/value.md), [`contains`](../api/basic_json_view/contains.md),
-    [`count`](../api/basic_json_view/count.md), and JSON pointer resolution all return the **first** member with that
-    key. `basic_json::parse()` instead keeps the **last** value of a repeated key, so for `#!cpp {"a":1,"a":2}`,
-    `#!cpp view["a"]` is `#!cpp 1` while `#!cpp parse(text)["a"]` is `#!cpp 2`.
+    [`value`](../api/basic_json_view/value.md), [`contains`](../api/basic_json_view/contains.md), and JSON pointer
+    resolution all return the **first** member with that key. `basic_json::parse()` instead keeps the **last** value
+    of a repeated key, so for `#!cpp {"a":1,"a":2}`, `#!cpp view["a"]` is `#!cpp 1` while `#!cpp parse(text)["a"]` is
+    `#!cpp 2`. [`count`](../api/basic_json_view/count.md) counts every member with the key, so it is `#!cpp 2` here.
 
 [`begin()`](../api/basic_json_view/begin.md)/[`end()`](../api/basic_json_view/end.md) and
 [`items()`](../api/basic_json_view/items.md) visit *every* occurrence, in document order, and
@@ -179,7 +180,7 @@ document: `#!cpp auto v = json_document::parse(text).root();` does not compile.
 
 **Why the first?** A lookup can stop as soon as it finds a match. Returning the last member would force every lookup
 to scan all members of the object, even when the key is found at the very first one: this made lookups in small
-objects 1.6 to 3.4 times slower. The hash index of objects with 128 members or more leads to the first member of a
+objects 1.6 to 3.4 times slower. The hash index of the keys of objects with 128 members or more leads to the first member of a
 key as well. Other zero-copy parsers that index the source text, such as yyjson and simdjson, also return the first
 member. RFC 8259 only says that names within an object SHOULD be unique and that the behavior of a receiver that sees
 duplicates is unpredictable, so neither choice is wrong.

docs/mkdocs/docs/features/namespace.md

@@ -23,6 +23,8 @@ The complete default namespace name is derived as follows:
     - [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md) defined non-zero appends `_sbu8`.
     - [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) defined non-zero
       appends `_ekmo`.
+    - [`JSON_VIEW_NO_SIMD`](../api/macros/json_view_no_simd.md) defined appends `_vns`.
+    - [`JSON_VIEW_USE_SSSE3`](../api/macros/json_view_use_ssse3.md) defined appends `_vssse3`.
 - The inline namespace ends with the suffix `_v` followed by the 3 components of the version number separated by
   underscores. To omit the version component, see [Disabling the version component](#disabling-the-version-component)
   below.
@@ -105,5 +107,7 @@ follows:
 - Added ABI tags `_bics` ([`JSON_BRACE_INIT_COPY_SEMANTICS`](../api/macros/json_brace_init_copy_semantics.md)), `_psp`
   ([`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md)), `_snul`
   ([`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md)), `_sbu8`
-  ([`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)), and `_ekmo`
-  ([`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)) in version 3.13.0.
+  ([`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)), `_ekmo`
+  ([`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)), `_vns`
+  ([`JSON_VIEW_NO_SIMD`](../api/macros/json_view_no_simd.md)), and `_vssse3`
+  ([`JSON_VIEW_USE_SSSE3`](../api/macros/json_view_use_ssse3.md)) in version 3.13.0.

docs/mkdocs/docs/home/architecture.md

@@ -196,7 +196,7 @@ packet-beta
 |-------|---------|------------|-------------------------------------------------------------------------------------------------------------------------------|
 | 0     | `kind`  | `uint8_t`  | the type, numbered as [`value_t`](../api/basic_json/value_t.md): 0 null, 1 object, 2 array, 3 string, 4 boolean, 5 signed integer, 6 unsigned integer, 7 float; 10 for a link (see below) |
 | 1     | `flags` | `uint8_t`  | bits 0-1: where a string's bytes (or a number's token) are (0: the source text, 1: the buffer of decoded strings, for strings with escapes, 2: the edit buffer); bit 2: the value of a boolean; bits 3 and 4: moved and new (see below) |
-| 2-3   | `extra` | `uint16_t` | numbers: the number of integer digits (low byte) and fraction digits (high byte), 255 for more; objects: the number of their hash index (1-based), or 0; otherwise 0 |
+| 2-3   | `extra` | `uint16_t` | numbers: the number of integer digits (low byte) and fraction digits (high byte), 255 for more; objects: the number of their key hash index (1-based), or 0; otherwise 0 |
 | 4-7   | `off`   | `uint32_t` | where the value starts: the first byte after a string's opening quote (or its position in the buffer of decoded strings), the first byte of a number or literal, the bracket of an array or object |
 | 8-11  | `len`   | `uint32_t` | strings: the length after decoding; floats and literals: the length of the token; arrays and objects: the number of elements |
 | 12-15 | `next`  | `uint32_t` | arrays and objects: the number of nodes of the subtree, including the node itself                                              |
@@ -212,7 +212,7 @@ packet-beta
   step from element to element this way and skip whole subtrees in constant time.
 - **Offsets** are 32 bits wide, so a document is limited to 4294967279 bytes, 4 GiB minus 16 bytes (a margin below
   2^32 for positions one scanner step past the end of the text; `out_of_range.416`).
-- **Large objects** (128 members or more) get a hash index after parsing
+- **Large objects** (128 members or more) get a hash index for their keys after parsing
   ([`detail/view/object_index.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/view/object_index.hpp)):
   an open-addressing table whose slots hold the distance from the object's node to a key's node, so that a lookup does
   not compare every key. Of duplicate keys the table leads to the first, as a linear search does. The object's `extra`

include/nlohmann/detail/abi_macros.hpp

@@ -102,14 +102,26 @@
     #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif
 
+#ifdef JSON_VIEW_NO_SIMD
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD _vns
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3 _vssse3
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -120,7 +132,9 @@
             NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
             NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
             NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS,       \
+            NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD,                      \
+            NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

include/nlohmann/detail/view/builder.hpp

@@ -422,8 +422,10 @@ class builder
             arena_ensure(16);
             std::memcpy(m_arena_write, r, 16);
         }
-        else
+        else if (n != 0)
         {
+            // (an empty run leaves an empty arena unallocated, and memcpy()
+            // must not be passed its null pointer even for zero bytes)
             arena_ensure(n);
             std::memcpy(m_arena_write, r, n);
         }
@@ -682,7 +684,7 @@ obj_next:
             return fail(error_code::expected_object_end);
 
 close_object:
-            // a large object gets a hash index (objects only, so that closing
+            // a large object gets a hash index for its keys (objects only, so that closing
             // an array pays nothing for this)
             if (NLOHMANN_VIEW_UNLIKELY(cur_count >= document_data::index_min_members))
             {
@@ -844,7 +846,7 @@ indent_done:
 
         /// append a node: (kind, flags, extra, off) and the second word (len, or
         /// an integer's value); two stores on little-endian targets
-        NLOHMANN_VIEW_ALWAYS_INLINE node* emit(value_t k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
+        NLOHMANN_VIEW_ALWAYS_INLINE node* push_node(value_t k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
         {
             if (NLOHMANN_VIEW_UNLIKELY(out == cap))
             {
@@ -874,9 +876,9 @@ indent_done:
 
         NLOHMANN_VIEW_ALWAYS_INLINE void open(value_t k)
         {
-            // (base is read after emit(), which moves the node array when it
+            // (base is read after push_node(), which moves the node array when it
             // grows; in one expression the order of the two is unspecified)
-            const node* const n = emit(k, 0, 0, static_cast<std::size_t>(p - b), 0);
+            const node* const n = push_node(k, 0, 0, static_cast<std::size_t>(p - b), 0);
             const auto idx = static_cast<std::uint32_t>(n - base);
             if (depth != 0)
             {
@@ -936,7 +938,7 @@ indent_done:
             {
                 return fail(error_code::invalid_literal);
             }
-            emit(k, flags, 0, static_cast<std::size_t>(p - b), n);
+            push_node(k, flags, 0, static_cast<std::size_t>(p - b), n);
             p += n;
             return true;
         }
@@ -1044,7 +1046,7 @@ indent_done:
                 // of the negative std::int64_t)
                 second = negative ? 0 - m : m;
             }
-            emit(kind, 0, layout, static_cast<std::size_t>(s - b), second);
+            push_node(kind, 0, layout, static_cast<std::size_t>(s - b), second);
             return true;
         }
 
@@ -1057,7 +1059,7 @@ indent_done:
             p = scan_string_run<Value>(p, e);
             if (NLOHMANN_VIEW_LIKELY(p != e && *p == '"'))
             {
-                emit(value_t::string, 0, 0, static_cast<std::size_t>(s - b), static_cast<std::uint64_t>(p - s));
+                push_node(value_t::string, 0, 0, static_cast<std::size_t>(s - b), static_cast<std::uint64_t>(p - s));
                 ++p;
                 return true;
             }
@@ -1067,7 +1069,7 @@ indent_done:
                 return false;
             }
             p = r.p;
-            emit(value_t::string, node_flags::escaped, 0, r.start, r.len);
+            push_node(value_t::string, node_flags::escaped, 0, r.start, r.len);
             return true;
         }
     };

include/nlohmann/detail/view/compare.hpp

@@ -201,6 +201,11 @@ class json_side
     const BasicJsonType* m_json;
 };
 
+inline bool is_number(value_t t) noexcept
+{
+    return t == value_t::number_integer || t == value_t::number_unsigned || t == value_t::number_float;
+}
+
 /// whether two sides are equal; iterative, so that the nesting depth is
 /// limited by memory only
 template<typename BasicJsonType, typename A, typename B>
@@ -225,8 +230,6 @@ bool equal(const A& a0, const B& b0)
     {
         const value_t ta = a.type();
         const value_t tb = b.type();
-        const bool numbers = (ta == value_t::number_integer || ta == value_t::number_unsigned || ta == value_t::number_float)
-                             && (tb == value_t::number_integer || tb == value_t::number_unsigned || tb == value_t::number_float);
         if (ta == value_t::discarded || tb == value_t::discarded)
         {
             // basic_json decides (JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
@@ -237,13 +240,13 @@ bool equal(const A& a0, const B& b0)
         }
         else
         {
-            if (!numbers && ta != tb)
+            if (ta != tb && !(is_number(ta) && is_number(tb))) // numbers of different types can be equal
             {
                 return false;
             }
             if (ta == value_t::string)
             {
-                if (!(a.string() == b.string()))
+                if (a.string() != b.string())
                 {
                     return false;
                 }
@@ -272,7 +275,7 @@ bool equal(const A& a0, const B& b0)
                 }
                 stack.push_back(std::move(f));
             }
-            else if (!(a.scalar() == b.scalar())) // numbers (also of different types), null, boolean
+            else if (a.scalar() != b.scalar()) // numbers (also of different types), null, boolean
             {
                 return false;
             }
@@ -289,7 +292,7 @@ bool equal(const A& a0, const B& b0)
             const std::size_t count = f.object ? f.members_a.size() : f.elements_a.size();
             if (f.next == count)
             {
-                stack.pop_back();
+                stack.pop_back(); // (f dangles now, and is bound again after continue)
                 continue;
             }
             if (f.object)

include/nlohmann/detail/view/document_data.hpp

@@ -46,7 +46,7 @@ struct document_data
     std::string owned; ///< owned copy of the input, if any (a std::string, so that its NUL serves as the parser's sentinel)
     std::vector<std::uint8_t> owned_image; ///< a loaded image the document owns (the text and the decoded strings point into it)
 
-    // hash indexes of large objects (see object_index.hpp)
+    // hash indexes of the keys of large objects (see object_index.hpp)
     static constexpr std::uint32_t index_min_members = 128;
     struct object_index
     {

include/nlohmann/detail/view/image.hpp

@@ -105,7 +105,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
         }
         return r;
     };
-    const auto emit = [&](const node * v)
+    const auto copy_node = [&](const node * v)
     {
         node r = *v;
         switch (static_cast<value_t>(v->kind))
@@ -159,7 +159,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
         }
         out.push_back(r);
     };
-    emit(d.nodes);
+    copy_node(d.nodes);
     while (!stack.empty())
     {
         frame& top = stack.back();
@@ -184,7 +184,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
             v = document_data::deref(top.cur);
             top.cur = document_data::after(top.cur);
         }
-        emit(v); // may grow the stack (top is not used afterwards)
+        copy_node(v); // may grow the stack (top is not used afterwards)
     }
 }
 

include/nlohmann/detail/view/lookup.hpp

@@ -120,6 +120,23 @@ const node* find_member(const document_data& d, const node* object, const char*
     return nullptr;
 }
 
+/// the number of members of an object with this key (duplicates included)
+template<bool Editable>
+std::size_t count_members(const document_data& d, const node* object, const char* key, std::size_t n) noexcept
+{
+    using nav = navigation<Editable>;
+    std::size_t result = 0;
+    const node* const end = nav::end(d, object);
+    for (const node* m = nav::first(d, object); m != end; m = document_data::after(m + 1))
+    {
+        if (m->len == n && (n == 0 || std::memcmp(d.str(*m), key, n) == 0))
+        {
+            ++result;
+        }
+    }
+    return result;
+}
+
 /// whether an integer type is accepted as an array index by the view's
 /// operator[] and at(): every integer type but bool and size_t, which has its
 /// own overload

include/nlohmann/detail/view/macro_scope.hpp

@@ -70,5 +70,11 @@
     #define NLOHMANN_VIEW_LITTLE_ENDIAN 0
 #endif
 
+/// eight checks at fixed offsets 0..7
+#define NLOHMANN_VIEW_REPEAT_FIRST_8(X) X(0) X(1) X(2) X(3) X(4) X(5) X(6) X(7)
+
+/// eight checks at fixed offsets 8..15
+#define NLOHMANN_VIEW_REPEAT_SECOND_8(X) X(8) X(9) X(10) X(11) X(12) X(13) X(14) X(15)
+
 /// sixteen checks at fixed offsets 0..15
-#define NLOHMANN_VIEW_REPEAT16(X) X(0) X(1) X(2) X(3) X(4) X(5) X(6) X(7) X(8) X(9) X(10) X(11) X(12) X(13) X(14) X(15)
+#define NLOHMANN_VIEW_REPEAT16(X) NLOHMANN_VIEW_REPEAT_FIRST_8(X) NLOHMANN_VIEW_REPEAT_SECOND_8(X)

include/nlohmann/detail/view/macro_unscope.hpp

@@ -19,6 +19,8 @@
 #undef NLOHMANN_VIEW_THROW
 #undef NLOHMANN_VIEW_LITTLE_ENDIAN
 #undef NLOHMANN_VIEW_REPEAT16
+#undef NLOHMANN_VIEW_REPEAT_SECOND_8
+#undef NLOHMANN_VIEW_REPEAT_FIRST_8
 #undef NLOHMANN_VIEW_NEON
 #undef NLOHMANN_VIEW_SSE2
 #undef NLOHMANN_VIEW_SSSE3

include/nlohmann/detail/view/node.hpp

@@ -53,7 +53,7 @@ struct node
 {
     std::uint8_t kind;   ///< value_t, or kind_link
     std::uint8_t flags;  ///< node_flags
-    std::uint16_t extra; ///< numbers: integer digits (low byte) and fraction digits (high byte), 255 = "many"; objects: number of the hash index (1-based, 0 = none); otherwise 0
+    std::uint16_t extra; ///< numbers: integer digits (low byte) and fraction digits (high byte), 255 = "many"; objects: number of the object's key hash index (1-based, 0 = none); otherwise 0
     std::uint32_t off;   ///< source offset (string content, number token, literal, bracket); arena offset if escaped/edited; number of the element sequence if moved
     std::uint32_t len;   ///< string: decoded bytes; float: token bytes; array/object: element count
     std::uint32_t next;  ///< array/object: number of nodes of the subtree (its extent in the enclosing sequence)

include/nlohmann/detail/view/object_index.hpp

@@ -13,11 +13,12 @@
 #include <cstring> // memcmp
 
 #include <nlohmann/json.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/view/document_data.hpp>
 #include <nlohmann/detail/view/macro_scope.hpp>
 #include <nlohmann/detail/view/node.hpp>
 
-// Hash indexes of large objects, so that a lookup does not compare thousands
+// Hash indexes of the keys of large objects, so that a lookup does not compare thousands
 // of keys (as Boost.JSON switches from a linear search to a hash table for
 // large objects). An object with document_data::index_min_members members or
 // more gets an open-addressing table after parsing; its node stores the
@@ -42,6 +43,12 @@ namespace view
 /// members; and every member costs at most this many steps while building)
 constexpr std::size_t index_max_displacement = 64;
 
+// a table has at least 2 * len slots (len >= index_min_members), so the probe
+// window of index_max_displacement + 1 slots stays far smaller than the table
+// and a probe never wraps around onto its own start
+static_assert(document_data::index_min_members >= 2 * index_max_displacement,
+              "a table must be much larger than the probe window of a lookup");
+
 /// hash of a key: its bytes, eight at a time, in a fixed byte order
 inline std::uint64_t key_hash(const char* s, std::size_t n) noexcept
 {
@@ -77,45 +84,36 @@ inline void build_object_index(document_data& d, node* obj)
     }
     const std::size_t start = d.index_slots.size();
     d.index_slots.resize(start + cap, 0);
-    std::uint32_t* const slots = d.index_slots.data() + start;
+    std::uint32_t* const table = d.index_slots.data() + start;
     const std::size_t mask = cap - 1;
-    bool degenerate = false;
     for (const node* k = document_data::first_child(obj), *end = document_data::child_end(obj); k != end; k = document_data::after(k + 1))
     {
         const char* const key = d.str(*k);
-        const std::uint64_t hash = key_hash(key, k->len); // (a cast of the call would be useless where std::uint64_t is std::size_t)
-        std::size_t i = static_cast<std::size_t>(hash) & mask;
+        std::size_t slot = conditional_static_cast<std::size_t>(key_hash(key, k->len)) & mask;
         bool duplicate = false;
         std::size_t distance = 0;
-        while (slots[i] != 0)
+        while (table[slot] != 0)
         {
-            const node* const other = obj + slots[i];
+            const node* const other = obj + table[slot];
             if (other->len == k->len && (k->len == 0 || std::memcmp(d.str(*other), key, k->len) == 0))
             {
                 duplicate = true; // keep the first
                 break;
             }
-            if (++distance > index_max_displacement)
+            if (distance == index_max_displacement)
             {
-                degenerate = true; // too many keys share a home region
-                break;
+                // too many keys share a home region
+                d.index_slots.resize(start); // no table: the object is searched linearly
+                return;
             }
-            i = (i + 1) & mask;
-        }
-        if (degenerate)
-        {
-            break;
+            ++distance;
+            slot = (slot + 1) & mask;
         }
         if (!duplicate)
         {
-            slots[i] = static_cast<std::uint32_t>(k - obj);
+            table[slot] = static_cast<std::uint32_t>(k - obj);
         }
     }
-    if (degenerate)
-    {
-        d.index_slots.resize(start); // no table: the object is searched linearly
-        return;
-    }
     d.indexes.push_back(document_data::object_index{start, static_cast<std::uint32_t>(mask)});
     obj->extra = static_cast<std::uint16_t>(d.indexes.size());
 }
@@ -134,12 +132,11 @@ inline void build_object_indexes(document_data& d)
 inline const node* find_indexed(const document_data& d, const node* obj, const char* key, std::size_t n) noexcept
 {
     const document_data::object_index& ix = d.indexes[obj->extra - 1u];
-    const std::uint32_t* const slots = d.index_slots.data() + ix.start;
-    const std::uint64_t hash = key_hash(key, n); // (a cast of the call would be useless where std::uint64_t is std::size_t)
-    std::size_t i = static_cast<std::size_t>(hash) & ix.mask;
+    const std::uint32_t* const table = d.index_slots.data() + ix.start;
+    std::size_t slot = conditional_static_cast<std::size_t>(key_hash(key, n)) & ix.mask;
     for (std::size_t distance = 0; distance <= index_max_displacement; ++distance)
     {
-        const std::uint32_t s = slots[i];
+        const std::uint32_t s = table[slot];
         if (s == 0)
         {
             return nullptr;
@@ -149,7 +146,7 @@ inline const node* find_indexed(const document_data& d, const node* obj, const c
         {
             return k;
         }
-        i = (i + 1) & ix.mask;
+        slot = (slot + 1) & ix.mask;
     }
     return nullptr; // (no key sits further from its home slot)
 }

include/nlohmann/detail/view/pointer.hpp

@@ -47,24 +47,24 @@ enum class index_status
 template<typename StringType>
 index_status array_index(const StringType& s, std::size_t& idx) noexcept
 {
+    // as basic_json: the empty token and "-" (past the last element) are
+    // unresolved rather than not a number
+    if (s.empty() || (s.size() == 1 && s[0] == '-'))
+    {
+        return index_status::unresolved;
+    }
+    if (s[0] < '0' || s[0] > '9')
+    {
+        return index_status::not_number;
+    }
     if (s.size() > 1 && s[0] == '0')
     {
         return index_status::leading_zero;
     }
-    // as basic_json: also a single character, but "-" and the empty token are
-    // left to the conversion below and reported as unresolved
-    if (!s.empty() && !(s.size() == 1 && s[0] == '-') && !(s[0] >= '0' && s[0] <= '9'))
-    {
-        return index_status::not_number;
-    }
-    if (s.empty())
-    {
-        return index_status::unresolved;
-    }
     std::uint64_t v = 0;
-    for (std::size_t i = 0; i < s.size(); ++i)
+    for (const auto c : s)
     {
-        const auto d = static_cast<unsigned>(static_cast<unsigned char>(s[i])) - '0';
+        const auto d = static_cast<unsigned>(static_cast<unsigned char>(c)) - '0';
         if (d > 9 || v > ((std::numeric_limits<std::uint64_t>::max)() - d) / 10)
         {
             return index_status::unresolved; // not a number, or beyond unsigned long long

include/nlohmann/detail/view/scan.hpp

@@ -83,14 +83,12 @@ NLOHMANN_VIEW_ALWAYS_INLINE const unsigned char* scan_string_run(const unsigned
         if (e - p >= 16)
         {
 #define NLOHMANN_VIEW_STEP(i) if (NLOHMANN_VIEW_LIKELY(plain[p[i]] != 0)) {} else { p += (i); goto stop; }
-            NLOHMANN_VIEW_STEP(0) NLOHMANN_VIEW_STEP(1) NLOHMANN_VIEW_STEP(2) NLOHMANN_VIEW_STEP(3)
-            NLOHMANN_VIEW_STEP(4) NLOHMANN_VIEW_STEP(5) NLOHMANN_VIEW_STEP(6) NLOHMANN_VIEW_STEP(7)
+            NLOHMANN_VIEW_REPEAT_FIRST_8(NLOHMANN_VIEW_STEP)
 #if NLOHMANN_VIEW_VECTOR
             if (!Value) // (a plain `!Value || !NLOHMANN_VIEW_VECTOR` is a constant condition for MSVC, C4127)
 #endif
             {
-                NLOHMANN_VIEW_STEP(8) NLOHMANN_VIEW_STEP(9) NLOHMANN_VIEW_STEP(10) NLOHMANN_VIEW_STEP(11)
-                NLOHMANN_VIEW_STEP(12) NLOHMANN_VIEW_STEP(13) NLOHMANN_VIEW_STEP(14) NLOHMANN_VIEW_STEP(15)
+                NLOHMANN_VIEW_REPEAT_SECOND_8(NLOHMANN_VIEW_STEP)
                 p += 8;
             }
 #undef NLOHMANN_VIEW_STEP

include/nlohmann/detail/view/serializer.hpp

@@ -73,6 +73,13 @@ class output_buffer
         m_pos += n;
     }
 
+    /// a string literal, without its terminating NUL
+    template<std::size_t N>
+    NLOHMANN_VIEW_ALWAYS_INLINE void put(const char (&s)[N])
+    {
+        put(s, N - 1);
+    }
+
     void put_repeated(char c, std::size_t n)
     {
         reserve(n);
@@ -322,7 +329,7 @@ class view_serializer
                 frame& f = stack.back();
                 if (f.pos == f.end)
                 {
-                    const bool object = f.object;
+                    const bool object = f.object; // (f dangles after pop_back)
                     stack.pop_back();
                     newline(stack.size());
                     m_out.put(object ? '}' : ']');
@@ -339,7 +346,7 @@ class view_serializer
                     write_string(*f.pos);
                     if (m_style.pretty)
                     {
-                        m_out.put(": ", 2);
+                        m_out.put(": ");
                     }
                     else
                     {
@@ -666,16 +673,16 @@ class view_serializer
         switch (static_cast<value_t>(n.kind))
         {
             case value_t::null:
-                m_out.put("null", 4);
+                m_out.put("null");
                 break;
             case value_t::boolean:
                 if ((n.flags & node_flags::is_true) != 0)
                 {
-                    m_out.put("true", 4);
+                    m_out.put("true");
                 }
                 else
                 {
-                    m_out.put("false", 5);
+                    m_out.put("false");
                 }
                 break;
             case value_t::string:
@@ -802,12 +809,14 @@ class view_serializer
     {
         if (!std::isfinite(x))
         {
-            m_out.put("null", 4);
+            m_out.put("null");
             return;
         }
-        write_float(x, std::integral_constant < bool,
-                    (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128)
-                    || (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024) > {});
+        static constexpr bool is_ieee_single_or_double
+            = std::numeric_limits<number_float_t>::is_iec559
+              && ((std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128)
+                  || (std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024));
+        write_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
     }
 
     void write_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
@@ -902,25 +911,25 @@ class view_serializer
         switch (codepoint)
         {
             case 0x08:
-                m_out.put("\\b", 2);
+                m_out.put("\\b");
                 return;
             case 0x09:
-                m_out.put("\\t", 2);
+                m_out.put("\\t");
                 return;
             case 0x0A:
-                m_out.put("\\n", 2);
+                m_out.put("\\n");
                 return;
             case 0x0C:
-                m_out.put("\\f", 2);
+                m_out.put("\\f");
                 return;
             case 0x0D:
-                m_out.put("\\r", 2);
+                m_out.put("\\r");
                 return;
             case 0x22:
-                m_out.put("\\\"", 2);
+                m_out.put("\\\"");
                 return;
             case 0x5C:
-                m_out.put("\\\\", 2);
+                m_out.put("\\\\");
                 return;
             default:
                 break;

include/nlohmann/detail/view/value.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <cstddef> // nullptr_t, size_t
 #include <cstdint> // int64_t
 #include <map> // map
 #include <string> // basic_string
@@ -103,6 +104,27 @@ Map map_value(const View& v)
 template<typename Key>
 struct is_string_key : std::is_constructible<Key, const char*, std::size_t> {};
 
+/// whether View::get<T>() converts to T without materialize(); get_to()
+/// assigns these, and passes the others to from_json
+template<typename T, typename BasicJsonType, typename View>
+struct is_direct_value : std::integral_constant < bool,
+    std::is_arithmetic<T>::value || std::is_same<T, std::nullptr_t>::value
+    || std::is_same<T, typename View::string_view_t>::value
+    || std::is_same<T, BasicJsonType>::value || std::is_same<T, View>::value >
+{};
+
+template<typename Traits, typename Alloc, typename BasicJsonType, typename View>
+struct is_direct_value<std::basic_string<char, Traits, Alloc>, BasicJsonType, View> : std::true_type {};
+
+template<typename U, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::vector<U, A>, BasicJsonType, View> : std::true_type {};
+
+template<typename K, typename V, typename C, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::map<K, V, C, A>, BasicJsonType, View> : is_string_key<K> {};
+
+template<typename K, typename V, typename H, typename E, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::unordered_map<K, V, H, E, A>, BasicJsonType, View> : is_string_key<K> {};
+
 }  // namespace view
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/json_view.hpp

@@ -31,12 +31,12 @@
 #include <cstddef> // nullptr_t, size_t // IWYU pragma: keep
 #include <cstdint> // uint8_t, uint32_t
 #include <cstring> // memcpy, strlen
-#include <istream> // istream
+#include <istream> // istream // IWYU pragma: keep
 #include <iterator> // distance, input_iterator_tag, iterator_traits
 #include <map> // map
 #include <memory> // unique_ptr
 #ifndef JSON_NO_IO
-    #include <ostream> // ostream
+    #include <ostream> // ostream // IWYU pragma: keep
 #endif
 #include <string> // string
 #include <tuple> // tuple_element, tuple_size // IWYU pragma: keep
@@ -265,7 +265,7 @@ class basic_json_view
         {
             if (is_discarded())
             {
-                return basic_json_view();
+                return {};
             }
             detail::view::throw_type_error(305, "cannot use operator[] with a string argument with ", type_name());
         }
@@ -291,7 +291,7 @@ class basic_json_view
         {
             if (is_discarded())
             {
-                return basic_json_view();
+                return {};
             }
             detail::view::throw_type_error(305, "cannot use operator[] with a numeric argument with ", type_name());
         }
@@ -314,7 +314,7 @@ class basic_json_view
     {
         if (NLOHMANN_VIEW_UNLIKELY(is_discarded()))
         {
-            return basic_json_view();
+            return {};
         }
         return detail::view::resolve_pointer(*this, detail::json_pointer_access::reference_tokens(ptr), detail::view::pointer_mode::unchecked);
     }
@@ -487,11 +487,11 @@ class basic_json_view
         return !detail::view::resolve_pointer(*this, detail::json_pointer_access::reference_tokens(ptr), detail::view::pointer_mode::contains).is_discarded();
     }
 
-    /// 1 if this is an object with a member with this key, else 0 (duplicate
-    /// keys count once)
+    /// the number of members with this key (more than 1 if the key occurs
+    /// more than once); 0 if this is not an object
     size_type count(string_view_t key) const
     {
-        return contains(key) ? 1 : 0;
+        return is_object() ? detail::view::count_members<Editable>(*m_doc, m_node, key.data(), key.size()) : 0;
     }
 
     size_type count(const char* key) const
@@ -558,10 +558,12 @@ class basic_json_view
         return get_impl(detail::view::value_tag<T> {}, detail::priority_tag<2> {});
     }
 
+    /// as BasicJsonType::get_to(): the types get<T>() converts directly are
+    /// assigned, all others are passed to from_json with v as it is
     template<typename T>
     T& get_to(T& v) const
     {
-        v = get<T>();
+        get_to_impl(v, detail::view::is_direct_value<T, BasicJsonType, basic_json_view> {});
         return v;
     }
 
@@ -862,6 +864,21 @@ class basic_json_view
         return materialize().template get<T>();
     }
 
+    // --- get_to() dispatch ---
+
+    template<typename T>
+    void get_to_impl(T& v, std::true_type /*direct*/) const
+    {
+        v = get<T>();
+    }
+
+    /// from_json may keep parts of v (members a JSON object lacks, say)
+    template<typename T>
+    void get_to_impl(T& v, std::false_type /*direct*/) const
+    {
+        materialize().get_to(v);
+    }
+
     const document_data* m_doc = nullptr;
     const node* m_node = nullptr;
 };

single_include/nlohmann/json.hpp

@@ -166,14 +166,26 @@
     #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif
 
+#ifdef JSON_VIEW_NO_SIMD
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD _vns
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3 _vssse3
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -184,7 +196,9 @@
             NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
             NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
             NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS,       \
+            NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD,                      \
+            NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

single_include/nlohmann/json_fwd.hpp

@@ -119,14 +119,26 @@
     #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif
 
+#ifdef JSON_VIEW_NO_SIMD
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD _vns
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3 _vssse3
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -137,7 +149,9 @@
             NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
             NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
             NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS,       \
+            NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD,                      \
+            NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

single_include/nlohmann/json_view.hpp

@@ -31,12 +31,12 @@
 #include <cstddef> // nullptr_t, size_t // IWYU pragma: keep
 #include <cstdint> // uint8_t, uint32_t
 #include <cstring> // memcpy, strlen
-#include <istream> // istream
+#include <istream> // istream // IWYU pragma: keep
 #include <iterator> // distance, input_iterator_tag, iterator_traits
 #include <map> // map
 #include <memory> // unique_ptr
 #ifndef JSON_NO_IO
-    #include <ostream> // ostream
+    #include <ostream> // ostream // IWYU pragma: keep
 #endif
 #include <string> // string
 #include <tuple> // tuple_element, tuple_size // IWYU pragma: keep
@@ -1592,8 +1592,10 @@ class builder
             arena_ensure(16);
             std::memcpy(m_arena_write, r, 16);
         }
-        else
+        else if (n != 0)
         {
+            // (an empty run leaves an empty arena unallocated, and memcpy()
+            // must not be passed its null pointer even for zero bytes)
             arena_ensure(n);
             std::memcpy(m_arena_write, r, n);
         }
@@ -2014,7 +2016,7 @@ indent_done:
 
         /// append a node: (kind, flags, extra, off) and the second word (len, or
         /// an integer's value); two stores on little-endian targets
-        NLOHMANN_VIEW_ALWAYS_INLINE node* emit(value_t k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
+        NLOHMANN_VIEW_ALWAYS_INLINE node* push_node(value_t k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
         {
             if (NLOHMANN_VIEW_UNLIKELY(out == cap))
             {
@@ -2044,9 +2046,9 @@ indent_done:
 
         NLOHMANN_VIEW_ALWAYS_INLINE void open(value_t k)
         {
-            // (base is read after emit(), which moves the node array when it
+            // (base is read after push_node(), which moves the node array when it
             // grows; in one expression the order of the two is unspecified)
-            const node* const n = emit(k, 0, 0, static_cast<std::size_t>(p - b), 0);
+            const node* const n = push_node(k, 0, 0, static_cast<std::size_t>(p - b), 0);
             const auto idx = static_cast<std::uint32_t>(n - base);
             if (depth != 0)
             {
@@ -2106,7 +2108,7 @@ indent_done:
             {
                 return fail(error_code::invalid_literal);
             }
-            emit(k, flags, 0, static_cast<std::size_t>(p - b), n);
+            push_node(k, flags, 0, static_cast<std::size_t>(p - b), n);
             p += n;
             return true;
         }
@@ -2214,7 +2216,7 @@ indent_done:
                 // of the negative std::int64_t)
                 second = negative ? 0 - m : m;
             }
-            emit(kind, 0, layout, static_cast<std::size_t>(s - b), second);
+            push_node(kind, 0, layout, static_cast<std::size_t>(s - b), second);
             return true;
         }
 
@@ -2227,7 +2229,7 @@ indent_done:
             p = scan_string_run<Value>(p, e);
             if (NLOHMANN_VIEW_LIKELY(p != e && *p == '"'))
             {
-                emit(value_t::string, 0, 0, static_cast<std::size_t>(s - b), static_cast<std::uint64_t>(p - s));
+                push_node(value_t::string, 0, 0, static_cast<std::size_t>(s - b), static_cast<std::uint64_t>(p - s));
                 ++p;
                 return true;
             }
@@ -2237,7 +2239,7 @@ indent_done:
                 return false;
             }
             p = r.p;
-            emit(value_t::string, node_flags::escaped, 0, r.start, r.len);
+            push_node(value_t::string, node_flags::escaped, 0, r.start, r.len);
             return true;
         }
     };
@@ -3186,7 +3188,7 @@ inline void build_object_index(document_data& d, node* obj)
     }
     const std::size_t start = d.index_slots.size();
     d.index_slots.resize(start + cap, 0);
-    std::uint32_t* const slots = d.index_slots.data() + start;
+    std::uint32_t* const table = d.index_slots.data() + start;
     const std::size_t mask = cap - 1;
     bool degenerate = false;
     for (const node* k = document_data::first_child(obj), *end = document_data::child_end(obj); k != end; k = document_data::after(k + 1))
@@ -3196,9 +3198,9 @@ inline void build_object_index(document_data& d, node* obj)
         std::size_t i = static_cast<std::size_t>(hash) & mask;
         bool duplicate = false;
         std::size_t distance = 0;
-        while (slots[i] != 0)
+        while (table[i] != 0)
         {
-            const node* const other = obj + slots[i];
+            const node* const other = obj + table[i];
             if (other->len == k->len && (k->len == 0 || std::memcmp(d.str(*other), key, k->len) == 0))
             {
                 duplicate = true; // keep the first
@@ -3217,7 +3219,7 @@ inline void build_object_index(document_data& d, node* obj)
         }
         if (!duplicate)
         {
-            slots[i] = static_cast<std::uint32_t>(k - obj);
+            table[i] = static_cast<std::uint32_t>(k - obj);
         }
     }
     if (degenerate)
@@ -3243,12 +3245,12 @@ inline void build_object_indexes(document_data& d)
 inline const node* find_indexed(const document_data& d, const node* obj, const char* key, std::size_t n) noexcept
 {
     const document_data::object_index& ix = d.indexes[obj->extra - 1u];
-    const std::uint32_t* const slots = d.index_slots.data() + ix.start;
+    const std::uint32_t* const table = d.index_slots.data() + ix.start;
     const std::uint64_t hash = key_hash(key, n); // (a cast of the call would be useless where std::uint64_t is std::size_t)
     std::size_t i = static_cast<std::size_t>(hash) & ix.mask;
     for (std::size_t distance = 0; distance <= index_max_displacement; ++distance)
     {
-        const std::uint32_t s = slots[i];
+        const std::uint32_t s = table[i];
         if (s == 0)
         {
             return nullptr;
@@ -4623,7 +4625,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
         }
         return r;
     };
-    const auto emit = [&](const node * v)
+    const auto copy_node = [&](const node * v)
     {
         node r = *v;
         switch (static_cast<value_t>(v->kind))
@@ -4677,7 +4679,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
         }
         out.push_back(r);
     };
-    emit(d.nodes);
+    copy_node(d.nodes);
     while (!stack.empty())
     {
         frame& top = stack.back();
@@ -4702,7 +4704,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
             v = document_data::deref(top.cur);
             top.cur = document_data::after(top.cur);
         }
-        emit(v); // may grow the stack (top is not used afterwards)
+        copy_node(v); // may grow the stack (top is not used afterwards)
     }
 }
 

tests/abi/config/CMakeLists.txt

@@ -21,7 +21,9 @@ foreach(test default noversion)
     target_compile_definitions(abi_config_${test}_all_tags PRIVATE
         JSON_DIAGNOSTICS=1
         JSON_DIAGNOSTIC_POSITIONS=1
-        JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1)
+        JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1
+        JSON_VIEW_NO_SIMD
+        JSON_VIEW_USE_SSSE3)
     target_link_libraries(abi_config_${test}_all_tags PRIVATE abi_compat_main)
     add_test(
         NAME test-abi_config_${test}_all_tags

tests/abi/config/default.cpp

@@ -52,6 +52,14 @@ TEST_CASE("default namespace")
         expected += "_ekmo";
 #endif
 
+#ifdef JSON_VIEW_NO_SIMD
+        expected += "_vns";
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+        expected += "_vssse3";
+#endif
+
         expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_MINOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_PATCH) "::basic_json";

tests/abi/config/noversion.cpp

@@ -53,6 +53,14 @@ TEST_CASE("default namespace without version component")
         expected += "_ekmo";
 #endif
 
+#ifdef JSON_VIEW_NO_SIMD
+        expected += "_vns";
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+        expected += "_vssse3";
+#endif
+
         expected += "::basic_json";
 
         // fallback for Clang

tests/src/unit-json_view.cpp

@@ -682,7 +682,12 @@ void check_access(const ordered_json_view& v, const ordered_json& j)
             ++members;
             const std::string key(it.key().data(), it.key().size());
             CHECK(v.contains(key));
-            CHECK(v.count(key) == 1);
+            std::size_t occurrences = 0;
+            for (auto other = v.begin(); other != v.end(); ++other)
+            {
+                occurrences += other.key() == it.key() ? 1 : 0;
+            }
+            CHECK(v.count(key) == occurrences);
             // lookups find the first member with the key, which is this one if
             // there is no earlier one
             if (std::find(keys.begin(), keys.end(), key) != keys.end())
@@ -790,7 +795,8 @@ TEST_CASE("json_view element access and iteration")
         CHECK(v.find("a") == v.begin());
         CHECK(v.find("a").value().materialize() == 1);
         CHECK(v.find("b") == std::next(v.begin()));
-        CHECK(v.count("a") == 1);
+        CHECK(v.count("a") == 2); // every member, unlike materialize()
+        CHECK(v.count("b") == 1);
         CHECK(v.contains("a"));
         CHECK(v.value("a", 0) == 1);
         CHECK(v.materialize()["a"] == 3); // materialize() keeps the last value, unlike the lookups
@@ -1187,6 +1193,25 @@ void from_json(const json& j, record& r)
     j.at("name").get_to(r.name);
     j.at("count").get_to(r.count);
 }
+
+struct defaults
+{
+    int a = 1;
+    int b = 2;
+};
+
+// sets only the members the JSON value has
+void from_json(const json& j, defaults& d)
+{
+    if (j.contains("a"))
+    {
+        j.at("a").get_to(d.a);
+    }
+    if (j.contains("b"))
+    {
+        j.at("b").get_to(d.b);
+    }
+}
 } // namespace
 
 TEST_CASE("json_view values")
@@ -1316,6 +1341,14 @@ TEST_CASE("json_view values")
         CHECK(name == "widget");
         CHECK(count == 3);
 
+        // other types go to from_json with the existing value, as basic_json::get_to()
+        defaults def;
+        def.b = 5;
+        const json_document partial = json_document::parse(R"({"a":4})");
+        partial.root().get_to(def);
+        CHECK(def.a == 4);
+        CHECK(def.b == 5);
+
         // a duplicate key: the last value, as parse()
         const json_document dup = json_document::parse(R"({"a":1,"a":2})");
         CHECK((dup.root().get<std::map<std::string, int>>() == std::map<std::string, int> {{"a", 2}}));

tests/src/unit-json_view_dump.cpp

@@ -418,11 +418,13 @@ TEST_CASE("json_view large objects")
             std::string text = "{";
             std::map<std::string, std::size_t> first;
             std::map<std::string, std::size_t> last;
+            std::map<std::string, std::size_t> occurrences;
             for (const member& m : members)
             {
                 text += (text.size() > 1 ? ",\"" : "\"") + m.key + "\":" + std::to_string(m.position);
                 first.insert({m.key, m.position});
                 last[m.key] = m.position;
+                ++occurrences[m.key];
             }
             text += '}';
             REQUIRE(first.size() < members.size());
@@ -441,7 +443,7 @@ TEST_CASE("json_view large objects")
                 CHECK(v.find(entry.first).value().get<std::size_t>() == expected);
                 CHECK(v.value(entry.first, std::size_t{0}) == expected);
                 CHECK(v.contains(entry.first));
-                CHECK(v.count(entry.first) == 1);
+                CHECK(v.count(entry.first) == occurrences[entry.first]);
                 const std::string pointer = "/" + entry.first;
                 CHECK(v[json::json_pointer(pointer)].get<std::size_t>() == expected);
                 CHECK(v.at(json::json_pointer(pointer)).get<std::size_t>() == expected);
@@ -464,7 +466,7 @@ TEST_CASE("json_view large objects")
         // make the table build quadratic: such an object gets no table and is
         // searched linearly
         constexpr std::size_t members = 300;
-        constexpr std::size_t slots = 1024; // the table size for 300 members: the next power of two >= 600
+        constexpr std::size_t table_size = 1024; // the table size for 300 members: the next power of two >= 600
         std::vector<std::string> colliding;
         std::vector<std::string> spread;
         for (std::uint64_t counter = 0; colliding.size() < members || spread.size() < members; ++counter)
@@ -475,7 +477,7 @@ TEST_CASE("json_view large objects")
             {
                 key[i] = static_cast<char>('a' + (x % 26));
             }
-            const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (slots - 1)) == 0;
+            const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (table_size - 1)) == 0;
             if (lands_in_slot_zero && colliding.size() < members)
             {
                 colliding.push_back(key);
@@ -522,7 +524,7 @@ TEST_CASE("json_view large objects")
         // same length, so the tables are the only difference)
         with_collisions.shrink_to_fit();
         without_collisions.shrink_to_fit();
-        CHECK(without_collisions.memory_usage() >= with_collisions.memory_usage() + (slots * sizeof(std::uint32_t)));
+        CHECK(without_collisions.memory_usage() >= with_collisions.memory_usage() + (table_size * sizeof(std::uint32_t)));
     }
 
     SECTION("shrink_to_fit releases the tables' spare capacity")

tests/src/unit-json_view_edit.cpp

@@ -228,6 +228,17 @@ std::string text_with_duplicates(const ordered_json& j)
     return j.dump();
 }
 
+// the number of members of an object view with this key, by iteration
+std::size_t occurrences(const ordered_json_editable_view& v, const std::string& key)
+{
+    std::size_t result = 0;
+    for (const auto& item : v.items())
+    {
+        result += std::string(item.key().data(), item.key().size()) == key ? 1 : 0;
+    }
+    return result;
+}
+
 // every lookup of the edited view finds the first member of its key, which
 // the iteration of the view shows
 void check_lookups(const ordered_json_editable_view& v)
@@ -253,7 +264,7 @@ void check_lookups(const ordered_json_editable_view& v)
             CHECK(v.at(ptr).materialize() == expected);
             CHECK(v.contains(key));
             CHECK(v.contains(ptr));
-            CHECK(v.count(key) == 1);
+            CHECK(v.count(key) == occurrences(v, key));
             const auto it = v.find(key);
             REQUIRE(it != v.end());
             CHECK((*it).materialize() == expected);
@@ -291,7 +302,7 @@ void check_first_members(const ordered_json_editable_view& v, const ordered_json
             CAPTURE(key)
             REQUIRE(v.contains(key));
             CHECK(v.contains(ptr));
-            CHECK(v.count(key) == 1);
+            CHECK(v.count(key) == occurrences(v, key));
             CHECK(v.find(key) != v.end());
             CHECK(v.at(ptr).type() == kv.value().type());
             check_first_members(v[key], kv.value());
@@ -640,7 +651,12 @@ void check_first_wins(const View& o, int expected)
     CHECK(o.value(json::json_pointer("/a"), -1) == expected);
     CHECK(o.contains("a"));
     CHECK(o.contains(json::json_pointer("/a")));
-    CHECK(o.count("a") == 1);
+    std::size_t members_a = 0;
+    for (const auto& item : o.items())
+    {
+        members_a += std::string(item.key().data(), item.key().size()) == "a" ? 1 : 0;
+    }
+    CHECK(o.count("a") == members_a); // every member, unlike the lookups
 }
 } // namespace
 

tests/src/unit-json_view_image.cpp

@@ -294,7 +294,7 @@ TEST_CASE("json_view images: round trips")
     {
         // the hash is not seeded: keys can be found that land in one slot of
         // a table (see json_view: "colliding keys")
-        const auto keys_for = [](std::size_t slots, std::size_t colliding_count, std::size_t spread_count)
+        const auto keys_for = [](std::size_t table_size, std::size_t colliding_count, std::size_t spread_count)
         {
             std::vector<std::string> colliding;
             std::vector<std::string> spread;
@@ -306,7 +306,7 @@ TEST_CASE("json_view images: round trips")
                 {
                     key[i] = static_cast<char>('a' + (x % 26));
                 }
-                const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (slots - 1)) == 0;
+                const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (table_size - 1)) == 0;
                 if (lands_in_slot_zero && colliding.size() < colliding_count)
                 {
                     colliding.push_back(key);
@@ -335,14 +335,14 @@ TEST_CASE("json_view images: round trips")
         // long chain
         const struct // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays): an unnamed type
         {
-            std::size_t slots;
+            std::size_t table_size;
             std::size_t colliding;
             std::size_t spread;
         } cases[] = {{1024, 300, 0}, {512, 40, 160}};
         for (const auto& c : cases)
         {
-            CAPTURE(c.slots)
-            std::vector<std::string> keys = keys_for(c.slots, c.colliding, c.spread);
+            CAPTURE(c.table_size)
+            std::vector<std::string> keys = keys_for(c.table_size, c.colliding, c.spread);
             const std::size_t members = keys.size();
             // a duplicate of a colliding key, of the first and of a spread key
             const std::vector<std::string> duplicated = {keys[c.colliding - 1], keys[0], keys[members - 1]};