json_view: the library's std conversions read views directly

The library's from_json() overloads (containers, maps, std::array, C
arrays, pairs, tuples, optional, valarray, forward_list, enums, binary,
paths, and scalars) accept views: their traits use the view's
basic_json type, and the few accesses that differ (get_ptr) go through
small helpers. from_json() of a view now finds them; only the probe
still looks up by ADL only. get<T>() of a view thus converts these types
without materialize(), with the same values and exceptions; from an
object, a repeated key keeps the last value, as parse() does.

The view keeps its direct paths for vectors of the types it converts
directly (faster than from_json()) and for containers of views; its
other vector and map paths are replaced by from_json(). For basic_json,
std::valarray and std::forward_list are read in one pass (40 % and 3.5 %
fewer instructions); all other conversions are unchanged.

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

.github/CONTRIBUTING.md

@@ -111,8 +111,6 @@ context which existing file needs to be extended, and only very few cases requir
 When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue.
 `unit-regression2.cpp` holds the older tests; the two files exist because a single one grew large enough for the
 MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing the larger one.
-Tests that call `sax_parse` go into `unit-sax_parse.cpp` rather than into a large test file: every call instantiates
-the parser and the binary reader that recover from errors, which grows a test file considerably.
 
 #### Exceptions
 

.github/workflows/check_amalgamation.yml

@@ -163,9 +163,9 @@ jobs:
           python3 $GENERATOR --list-tags
           TAG_COUNT=$(python3 $GENERATOR --list-tags | wc -l)
 
-          python3 $GENERATOR --abi-tags diag,_dp,_vns --abi-tags _diag --output $RUNNER_TEMP/abi_tags.natvis
-          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_vns -->' $RUNNER_TEMP/abi_tags.natvis
-          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_vns_v[0-9_]* -->' $RUNNER_TEMP/abi_tags.natvis
+          python3 $GENERATOR --abi-tags diag,_dp,_ns --abi-tags _diag --output $RUNNER_TEMP/abi_tags.natvis
+          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_ns -->' $RUNNER_TEMP/abi_tags.natvis
+          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_ns_v[0-9_]* -->' $RUNNER_TEMP/abi_tags.natvis
           test $(grep -c '<!-- Namespace ' $RUNNER_TEMP/abi_tags.natvis) -eq $(( $(grep -c '<!-- Namespace ' nlohmann_json.natvis) + 2 ))
 
           python3 $GENERATOR --all --output $RUNNER_TEMP/all.natvis

BUILD.bazel

@@ -90,6 +90,7 @@ cc_library(
         "include/nlohmann/detail/view/simd.hpp",
         "include/nlohmann/detail/view/string_ref.hpp",
         "include/nlohmann/detail/view/value.hpp",
+        "include/nlohmann/detail/view/view_mode.hpp",
         "include/nlohmann/json.hpp",
         "include/nlohmann/json_fwd.hpp",
         "include/nlohmann/json_literals.hpp",

FILES.md

@@ -309,7 +309,7 @@ The "Check amalgamation" workflow fails if the file is out of date.
 
 The file covers the namespace variants with up to two ABI tags. A Natvis file for other configurations can be
 generated with the `--abi-tags` or `--all` options, for example
-`make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my_nlohmann_json.natvis"`; see
+`make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my_nlohmann_json.natvis"`; see
 [`tools/generate_natvis`](tools/generate_natvis/README.md). With MSVC, CMake adds the file to the `nlohmann_json`
 target and installs it.
 

Makefile

@@ -120,7 +120,7 @@ $(AMALGAMATED_VIEW_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_view.json -s . --verbose=yes
 
 NATVIS_VENV=tools/generate_natvis/venv
-# extra options for generate_natvis.py, e.g. NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my.natvis"
+# extra options for generate_natvis.py, e.g. NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my.natvis"
 NATVIS_ARGS=
 
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp

README.md

@@ -495,7 +495,7 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const detail::exception& ex);
 ```
 
-The return value of each function determines whether parsing should proceed. For `parse_error`, returning `true` [recovers from the error](https://json.nlohmann.me/features/parsing/error_recovery/): the parser repairs the input and continues.
+The return value of each function determines whether parsing should proceed.
 
 To implement your own SAX handler, proceed as follows:
 
@@ -503,7 +503,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `bool json::sax_parse(input, &my_sax)`; where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.
 
-Note the `sax_parse` function only returns a `bool` indicating whether the input was parsed without errors and no SAX event returned `false`. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).
+Note the `sax_parse` function only returns a `bool` indicating the result of the last executed SAX event. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).
 
 ### STL-like access
 

docs/mkdocs/docs/api/basic_json/sax_parse.md

@@ -104,9 +104,7 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
 
 ## Return value
 
-`#!cpp true` if the input was parsed without errors and no SAX event returned `#!cpp false`; `#!cpp false` otherwise.
-In particular, the result is `#!cpp false` for input with errors, even if the SAX parser recovered from all of them
-(see [error recovery](../../features/parsing/error_recovery.md)).
+return value of the last processed SAX event
 
 ## Exception safety
 
@@ -163,7 +161,6 @@ use the same file with stdio functions, but it must not wait for another thread
 - Added `ignore_trailing_commas` in version 3.13.0.
 - Added `tag_handler` in version 3.13.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
-- Recovering from parse errors (see [`parse_error`](../json_sax/parse_error.md)) added in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave a `#!cpp std::istream` positioned right
   after the parsed value when `strict` is `#!cpp false`.

docs/mkdocs/docs/api/basic_json_document/erase.md

@@ -12,7 +12,7 @@ void erase(view_type array, I idx);
 std::size_t erase(const json_pointer& ptr);
 ```
 
-Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `erase`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 
 1. Removes every member of `object` whose key is `key` (see [Notes](#notes) on duplicate keys) and returns how many

docs/mkdocs/docs/api/basic_json_document/index.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_document;
 ```
 
@@ -20,9 +20,9 @@ is move-only: a copy would duplicate the whole index, the decoded-string buffer,
 enough in every use we know of. The index, the decoded strings, and the owned text live in one heap block that the
 document holds through a `#!cpp std::unique_ptr`; this is also why views survive a move of the document.
 
-With `#!cpp Editable == true`, the document also offers [`set`](set.md), [`push_back`](push_back.md),
+With `#!cpp Mode == view_mode::editable`, the document also offers [`set`](set.md), [`push_back`](push_back.md),
 [`insert`](insert.md), and [`erase`](erase.md) to change values in place, see [Edits](#edits) below. The source text
-itself is never written; a read-only document (`#!cpp Editable == false`, the default) does not carry any of the
+itself is never written; a read-only document (`#!cpp view_mode::read_only`, the default) does not carry any of the
 bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp static_assert`).
 
 ## Template parameters
@@ -32,9 +32,10 @@ bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp
     [`ordered_json`](../ordered_json.md). Only 64-bit `number_integer_t`/`number_unsigned_t` types are supported; this
     is checked with a `static_assert`.
 
-`Editable`
-:   whether the document supports [`set`](set.md), [`push_back`](push_back.md), [`insert`](insert.md), and
-    [`erase`](erase.md) (optional, `#!cpp false` by default). See [Edits](#edits) below.
+`Mode`
+:   a [`view_mode`](../view_mode.md): `#!cpp view_mode::editable` if the document supports [`set`](set.md),
+    [`push_back`](push_back.md), [`insert`](insert.md), and [`erase`](erase.md) (optional, `#!cpp view_mode::read_only`
+    by default). See [Edits](#edits) below.
 
 ## Specializations
 
@@ -47,7 +48,7 @@ bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp
 
 ## Member types
 
-- **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType, Editable>`)
+- **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType, Mode>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **image_check** - how [`load()`](load.md) validates an image (`full`, `bounds`, `none`), see [`image_check`](load.md#image_check)
 
@@ -80,15 +81,15 @@ bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp
 ### Edits
 
 - [**set**](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers
-  to (`#!cpp Editable` documents only)
-- [**push_back**](push_back.md) - append to an array (`#!cpp Editable` documents only)
-- [**insert**](insert.md) - insert an element into an array before a given position (`#!cpp Editable` documents only)
+  to (editable documents only)
+- [**push_back**](push_back.md) - append to an array (editable documents only)
+- [**insert**](insert.md) - insert an element into an array before a given position (editable documents only)
 - [**erase**](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
-  (`#!cpp Editable` documents only)
+  (editable documents only)
 
 ## Edits
 
-An editable document (`#!cpp Editable == true`) can be changed after parsing, with [`set`](set.md),
+An editable document (`#!cpp view_mode::editable`) can be changed after parsing, with [`set`](set.md),
 [`push_back`](push_back.md), [`insert`](insert.md), and [`erase`](erase.md);
 [`json_editable_document`](../json_editable_document.md) and
 [`ordered_json_editable_document`](../ordered_json_editable_document.md) are the corresponding specializations. A few

docs/mkdocs/docs/api/basic_json_document/insert.md

@@ -5,7 +5,7 @@ template<typename I, typename V>
 view_type insert(view_type array, I idx, V&& value);
 ```
 
-Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `insert`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 
 Inserts `value` into `array` as a new element before position `idx`, which must not be past the end

docs/mkdocs/docs/api/basic_json_document/load.md

@@ -55,10 +55,7 @@ validate with overload 2 first, if the original vector must survive a failed loa
 
 ## Exceptions
 
-On a big-endian target, throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) -- the same
-exception [`save()`](save.md#exceptions) throws there, since the image format is little-endian only.
-
-Otherwise throws [`parse_error.116`](../../home/exceptions.md#jsonexceptionparse_error116) if `image` is not one
+Throws [`parse_error.116`](../../home/exceptions.md#jsonexceptionparse_error116) if `image` is not one
 `save()` could have written, or fails the requested `check`:
 
 | message               | when                                                                                                |
@@ -95,6 +92,9 @@ are checked once, however many nodes refer to it.
 
 ## Notes
 
+**Little-endian targets only.** On a big-endian target, `load()` does not exist, just like
+[`save()`](save.md#notes): the image format is little-endian, so a call fails to compile.
+
 ### `image_check` { #image_check }
 
 ```cpp

docs/mkdocs/docs/api/basic_json_document/push_back.md

@@ -13,7 +13,7 @@ editable, and it does not have to be `array`'s own document -- which is copied s
 source document afterward; a `BasicJsonType` value; or anything `BasicJsonType` can be constructed from (numbers,
 strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
 
-Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `push_back`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 
 ## Template parameters

docs/mkdocs/docs/api/basic_json_document/save.md

@@ -12,7 +12,7 @@ An edited document is written in its *current* state, with its values in documen
 parser would have produced them for that JSON text: a member [`set`](set.md) added goes at the end, an
 [`erase`](erase.md)d member leaves no trace, and a float that is not finite (NaN or positive/negative infinity)
 becomes null, the same substitution [`dump()`](../basic_json_view/dump.md) makes. The same document always saves to
-the same bytes -- also across `BasicJsonType` and `#!cpp Editable`, since the image reflects document order and
+the same bytes -- also across `BasicJsonType` and the [`view_mode`](../view_mode.md), since the image reflects document order and
 values only, not which specialization produced them.
 
 ## Return value
@@ -31,9 +31,6 @@ Throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) i
 [discarded](is_discarded.md) -- a default-constructed document, or one a failed [`parse()`](parse.md)/
 [`read()`](read.md) with `allow_exceptions == false` left discarded.
 
-On a big-endian target, throws `type_error.320` with a different message instead: the image format is little-endian
-only (see [Notes](#notes)).
-
 Throws [`out_of_range.416`](../../home/exceptions.md#jsonexceptionout_of_range416) if the node count, the text, or
 the decoded strings of the image would individually reach 4 GiB -- the same 32-bit offsets
 [`parse()`](parse.md#exceptions) and, for edits, [`set`](set.md)/[`push_back`](push_back.md) are already limited to.
@@ -44,9 +41,6 @@ the decoded strings of the image would individually reach 4 GiB -- the same 32-b
     [json.exception.type_error.320] cannot save a discarded json_document
     ```
     ```
-    [json.exception.type_error.320] json_document images need a little-endian target
-    ```
-    ```
     [json.exception.out_of_range.416] images of 4 GiB or more are not supported by json_document
     ```
 
@@ -70,9 +64,9 @@ else -- see [`load`'s Exceptions](load.md#exceptions).
     the *same* build on the *same* (little-endian) machine -- not as a long-term storage format. Keep the original
     JSON text if you need to read a saved document back with a future library version.
 
-**Little-endian only.** The image is written as raw little-endian bytes, with no byte-swapping. `save()` (and
-[`load`](load.md)) throw `type_error.320` on a big-endian target rather than silently produce bytes a big-endian
-reader could not interpret correctly.
+**Little-endian targets only.** The image is written as raw little-endian bytes, with no byte-swapping. On a
+big-endian target, `save()` and [`load`](load.md) do not exist: a call fails to compile rather than produce bytes a
+big-endian reader could not interpret correctly.
 
 ## Examples
 

docs/mkdocs/docs/api/basic_json_document/set.md

@@ -18,7 +18,7 @@ template<typename V>
 view_type set(const json_pointer& ptr, V&& value);
 ```
 
-Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `set`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 
 1. Replaces the value `target` refers to with `value`.

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

@@ -19,16 +19,36 @@ 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>` -- 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 -- 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
+- `#!cpp std::vector<U, A>` of the types above -- 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, basic_json_view, C, A>` and `#!cpp std::unordered_map<K, basic_json_view, H, E, A>`, if `K` is
+  constructible from a `#!cpp (const char*, std::size_t)` pair -- views of the members of an object; with a repeated
+  key, the view of the *last* member is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) keeps its value
 
-Every other `T` -- `#!cpp std::list`, `#!cpp std::pair`, `#!cpp std::array`, enumerations, user types with a
-`from_json()`, ... -- is converted by `#!cpp materialize().get<T>()`: the subtree is built into a real `BasicJsonType`
+A default-constructible `T` whose `from_json()` accepts views reads the view directly as well, without building a
+`BasicJsonType` value. This covers the library's own conversions of the standard library types -- all other
+`#!cpp std::vector`s, `#!cpp std::map`/`#!cpp std::unordered_map` (also with other key types), `#!cpp std::list`,
+`#!cpp std::deque`, `#!cpp std::set`, `#!cpp std::forward_list`, `#!cpp std::valarray`, `#!cpp std::array`, C arrays,
+`#!cpp std::pair`, `#!cpp std::tuple`, `#!cpp std::optional`, enumerations, `#!cpp std::filesystem::path`, ... --
+which give the same values as `#!cpp materialize().get<T>()` (from an object, a repeated key keeps the *last* value,
+as [`BasicJsonType::parse()`](../basic_json/parse.md) does), as well as the types of the
+[`NLOHMANN_DEFINE_TYPE_*`](../macros/nlohmann_define_type_intrusive.md) and
+[`NLOHMANN_DEFINE_DERIVED_TYPE_*`](../macros/nlohmann_define_derived_type.md) macros and the enumerations of
+[`NLOHMANN_JSON_SERIALIZE_ENUM`](../macros/nlohmann_json_serialize_enum.md), and any `from_json()` constrained to
+accept views, e.g. with [`is_json_view`](../is_json_view.md). A `from_json()` that also accepts types that are no JSON
+values at all, such as the unconstrained `#!cpp template<typename BasicJsonType> void from_json(const BasicJsonType&,
+T&)` of [arbitrary type conversions](../../features/arbitrary_types.md), is not called with a view: it may use
+`BasicJsonType` functions a view does not have. See [json_view](../../features/json_view.md).
+
+!!! warning "Duplicate keys"
+
+    Such a `from_json()` looks members up in the view, where a repeated key finds the **first** member, while
+    `#!cpp materialize().get<T>()` sees the **last** one, as [`BasicJsonType::parse()`](../basic_json/parse.md)
+    keeps it: for `#!cpp {"x":1,"x":2}`, `#!cpp get<point>()` reads `#!cpp x == 1`. See
+    [Duplicate keys](../../features/json_view.md#duplicate-keys).
+
+Every other `T` -- user types whose `from_json()` is written for `BasicJsonType` only, types without a default
+constructor, `#!cpp std::tuple`s holding references, ... -- is converted by `#!cpp materialize().get<T>()`: the subtree is built into a real `BasicJsonType`
 value first (as [`BasicJsonType::parse()`](../basic_json/parse.md) would), and converted from there exactly as
 [`BasicJsonType::get<T>()`](../basic_json/get.md) would convert it.
 
@@ -53,12 +73,15 @@ Strong guarantee: there are no changes to the view or the document it refers to.
   throws for the same JSON type and `T`.
 - For `#!cpp std::vector<U, A>`: throws `type_error.302` if the value is not an array; otherwise, whatever converting
   an element to `U` throws.
-- For `#!cpp std::map`/`#!cpp std::unordered_map`: throws `type_error.302` if the value is not an object; otherwise,
-  whatever converting a member to the mapped type throws.
+- For `#!cpp std::map`/`#!cpp std::unordered_map` of views: throws `type_error.302` if the value is not an object.
+- For a `T` whose `from_json()` reads the view: whatever that `from_json()` throws; for the library's conversions and
+  the macros, the same exceptions with the same messages as [`BasicJsonType::get<T>()`](../basic_json/get.md) of the
+  same value.
 - For every other `T`: whatever [`materialize().get<T>()`](../basic_json/get.md) throws -- typically `type_error.302`,
   or whatever a user-provided `from_json()` throws.
 
-None of the exceptions thrown directly by this function (the first three bullets above) carry a
+None of the exceptions thrown directly by this function or by a `from_json()` that reads the view (the first four
+bullets above) carry a
 [`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.
@@ -76,6 +99,8 @@ document.
 - `#!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.
+- a `T` whose `from_json()` reads the view: the cost of that `from_json()`; for the macros, linear in the number of
+  members times the cost of a lookup, plus the cost of converting the members.
 - 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).
 

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

@@ -5,12 +5,13 @@ template<typename T>
 T& get_to(T& v) const;
 ```
 
-Converts the value to `T` and stores it in `v`, in one of two ways:
+Converts the value to `T` and stores it in `v`, in one of three ways:
 
 - 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>()`.
+  `basic_json_view`, vectors of these, and maps of views -- `v` is assigned: `#!cpp v = get<T>()`.
+- For a type whose `from_json()` accepts views (see [`get<T>()`](get.md)), that `from_json()` is called with the
+  view and the existing `v`, without building a `BasicJsonType` value.
 - 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.

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

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_view;
 ```
 
@@ -37,7 +37,7 @@ Moving the document itself does not invalidate its views: the index is heap-allo
 `#!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
+**editable** document (`#!cpp view_mode::editable`) sees every edit made through
 [`basic_json_document::set`](../basic_json_document/set.md) and
 [`basic_json_document::push_back`](../basic_json_document/push_back.md): once a value is changed, every view that
 still refers to it -- including ones taken before the change -- reads the new value. See
@@ -49,9 +49,10 @@ still refers to it -- including ones taken before the change -- reads the new va
 :   a specialization of [`basic_json`](../basic_json/index.md), matching the
     [`basic_json_document`](../basic_json_document/index.md) the view was taken from.
 
-`Editable`
-:   whether the view is of an editable document, matching the [`basic_json_document`](../basic_json_document/index.md)
-    it was taken from (optional, `#!cpp false` by default). See [Edits](../basic_json_document/index.md#edits).
+`Mode`
+:   a [`view_mode`](../view_mode.md): whether the view is of an editable document, matching the
+    [`basic_json_document`](../basic_json_document/index.md) it was taken from (optional, `#!cpp view_mode::read_only` by
+    default). See [Edits](../basic_json_document/index.md#edits).
 
 ## Specializations
 
@@ -63,6 +64,7 @@ still refers to it -- including ones taken before the change -- reads the new va
 
 ## Member types
 
+- **basic_json_type** - `BasicJsonType` (it also marks the class for [`is_json_view`](../is_json_view.md))
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **string_t**, **number_integer_t**, **number_unsigned_t**, **number_float_t**, **json_pointer** - the corresponding
   member types of `BasicJsonType`

docs/mkdocs/docs/api/is_json_view.md

@@ -0,0 +1,55 @@
+# <small>nlohmann::</small>is_json_view
+
+<small>Defined in header `<nlohmann/json_view.hpp>`</small>
+
+```cpp
+template<typename T>
+struct is_json_view;
+```
+
+A type trait: `#!cpp is_json_view<T>::value` is `#!cpp true` if `T` is a [`basic_json_view`](basic_json_view/index.md)
+of any `BasicJsonType` and any [`view_mode`](view_mode.md) -- [`json_view`](json_view.md),
+[`json_editable_view`](json_editable_view.md), [`ordered_json_view`](ordered_json_view.md), ... -- and
+`#!cpp false` otherwise, for [`basic_json`](basic_json/index.md) as well.
+
+It is meant for constraining templates that accept views, in particular a `from_json()` that should read views
+directly: [`get<T>()`](basic_json_view/get.md) on a view calls a `from_json()` with the view only if that `from_json()`
+accepts views but not arbitrary types.
+
+## Template parameters
+
+`T`
+:   the type to check (without cv-qualifiers or references)
+
+## Notes
+
+A view is recognized by its member type `basic_json_type` (a [`basic_json`](basic_json/index.md) specialization) and
+its [`materialize()`](basic_json_view/materialize.md) returning that type, so the trait needs no declaration of the
+view class.
+
+## Examples
+
+??? example
+
+    The example below shows the trait, and a `from_json()` constrained to `json` values and views: `get<T>()` on a view
+    reads the view directly.
+
+    ```cpp
+    --8<-- "examples/is_json_view.cpp"
+    ```
+
+    Output:
+
+    ```
+    --8<-- "examples/is_json_view.output"
+    ```
+
+## See also
+
+- [basic_json_view](basic_json_view/index.md) - a handle to one value of a document
+- [get](basic_json_view/get.md) - which conversions read the view directly
+- [view_mode](view_mode.md) - read-only or editable
+
+## Version history
+
+Added in version 3.13.0.

docs/mkdocs/docs/api/json_editable_document.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using json_editable_document = basic_json_document<json, true>;
+using json_editable_document = basic_json_document<json, view_mode::editable>;
 ```
 
 This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the default

docs/mkdocs/docs/api/json_editable_view.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using json_editable_view = basic_json_view<json, true>;
+using json_editable_view = basic_json_view<json, view_mode::editable>;
 ```
 
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a

docs/mkdocs/docs/api/json_sax/index.md

@@ -7,8 +7,7 @@ struct json_sax;
 
 This class describes the SAX interface used by [sax_parse](../basic_json/sax_parse.md). Each function is called in
 different situations while the input is parsed. The boolean return value informs the parser whether to continue
-processing the input; for [`parse_error`](parse_error.md), it decides whether to
-[recover from the error](../../features/parsing/error_recovery.md).
+processing the input.
 
 For instance, parsing the JSON text `{"a": [1, true]}` triggers the following callbacks, in order:
 

docs/mkdocs/docs/api/json_sax/parse_error.md

@@ -21,18 +21,11 @@ A parse error occurred.
 
 ## Return value
 
-Whether to recover from the error:
-
-- `#!cpp false` stops parsing.
-- `#!cpp true` recovers from the error: the error is repaired and parsing continues. If that is not possible, which
-  happens in the binary formats when the end of the item with the error is unknown, the value read so far is completed
-  and parsing stops. See [error recovery](../../features/parsing/error_recovery.md) for how errors are repaired.
-
-Either way, [`sax_parse`](../basic_json/sax_parse.md) returns `#!cpp false`.
+Whether parsing should proceed (**must return `#!cpp false`**).
 
 ## Examples
 
-??? example "Example: (1) the SAX interface"
+??? example
 
     The example below shows how the SAX interface is used.
 
@@ -46,29 +39,12 @@ Either way, [`sax_parse`](../basic_json/sax_parse.md) returns `#!cpp false`.
     --8<-- "examples/sax_parse.output"
     ```
 
-??? example "Example: (2) recovering from errors"
-
-    The example below shows how a SAX parser recovers from errors.
-
-    ```cpp
-    --8<-- "examples/sax_parse__error_recovery.cpp"
-    ```
-    
-    Output:
-    
-    ```
-    --8<-- "examples/sax_parse__error_recovery.output"
-    ```
-
 ## See also
 
 - [sax_parse](../basic_json/sax_parse.md) - SAX parser
 - [Parsing and Exceptions](../../features/parsing/parse_exceptions.md) - the article on handling parse errors without
   exceptions
-- [Error Recovery](../../features/parsing/error_recovery.md) - the article on recovering from parse errors
 
 ## Version history
 
 - Added in version 3.2.0.
-- Returning `#!cpp true` recovers from the error since version 3.13.0; before, parsing stopped, but the result of
-  [`sax_parse`](../basic_json/sax_parse.md) could be wrong.

docs/mkdocs/docs/api/macros/index.md

@@ -43,8 +43,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
-- [**JSON_VIEW_NO_SIMD**](json_view_no_simd.md) - use only portable code in the parser of `json_view.hpp`
-- [**JSON_VIEW_USE_SSSE3**](json_view_use_ssse3.md) - validate non-ASCII strings with SSSE3 in the parser of `json_view.hpp`
 
 ## Library version
 

docs/mkdocs/docs/api/macros/json_no_simd.md

@@ -5,7 +5,8 @@
 ```
 
 When defined, the library uses only portable C++ code where it would otherwise use vector instructions: when scanning
-strings during parsing, and when writing floating-point numbers during serialization.
+strings during parsing, and when writing floating-point numbers during serialization. This includes the parser of
+[`basic_json_document`](../basic_json_document/index.md) (`<nlohmann/json_view.hpp>`).
 
 The macro is an escape hatch, for example for toolchains that cannot compile the vector code, for sanitizers or
 analyzers that do not understand it, or to compare the speed of both variants. It does not change any result: values,
@@ -77,6 +78,7 @@ By default, `#!cpp JSON_NO_SIMD` is not defined, and vector instructions are use
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
 - [**JSON_DISABLE_STREAM_BULK_SCAN**](json_disable_stream_bulk_scan.md) - read a `std::istream` one character at a time
 - [Parsing: input sources and performance](../../features/parsing/index.md#input-sources-and-performance)
+- [json_view](../../features/json_view.md) - the zero-copy view, whose parser the macro also affects
 
 ## Version history
 

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

@@ -1,52 +0,0 @@
-# JSON_VIEW_NO_SIMD
-
-```cpp
-#define JSON_VIEW_NO_SIMD
-```
-
-When defined, the parser of [`basic_json_document`](../basic_json_document/index.md) (`<nlohmann/json_view.hpp>`)
-uses only portable C++ to scan strings. By default, it scans long runs of string bytes 16 at a time with NEON on
-AArch64 (with GCC and Clang) and SSE2 on x86-64, which are part of the baseline instruction sets of these
-architectures, and validates non-ASCII text with NEON (or SSSE3, see
-[`JSON_VIEW_USE_SSSE3`](json_view_use_ssse3.md)).
-
-The same input is accepted or rejected either way, with the same values, and errors are reported the same way; only
-the speed differs. The macro exists for platforms whose compilers lack the intrinsics headers, and to test the portable
-code.
-
-!!! note "ABI compatibility"
-
-    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
-
-By default, `#!cpp JSON_VIEW_NO_SIMD` is not defined, and the vector code is used where available.
-
-```cpp
-#undef JSON_VIEW_NO_SIMD
-```
-
-## Examples
-
-??? example
-
-    The code below uses the portable string scanning of the view.
-
-    ```cpp
-    #define JSON_VIEW_NO_SIMD
-    #include <nlohmann/json_view.hpp>
-
-    ...
-    ```
-
-## See also
-
-- [JSON_VIEW_USE_SSSE3](json_view_use_ssse3.md) - validate non-ASCII strings with SSSE3 on x86-64
-- [json_view](../../features/json_view.md) - the zero-copy view
-
-## Version history
-
-- Added in version 3.13.0.

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

@@ -1,53 +0,0 @@
-# JSON_VIEW_USE_SSSE3
-
-```cpp
-#define JSON_VIEW_USE_SSSE3
-```
-
-When defined on x86-64, the parser of [`basic_json_document`](../basic_json_document/index.md)
-(`<nlohmann/json_view.hpp>`) validates non-ASCII text in strings with SSSE3 without asking the CPU first.
-
-By default, the parser checks once at run time whether the CPU has SSSE3 (all x86-64 CPUs since about 2011 have it)
-and then validates non-ASCII text 16 bytes at a time, using the "lookup4" algorithm of
-[simdjson](https://github.com/simdjson/simdjson); on CPUs without SSSE3, it validates one UTF-8 sequence at a time.
-The vector check is compiled for SSSE3 with a function attribute (GCC 4.9 and later, Clang), so this needs no compiler
-option. With MSVC, the check uses `__cpuid`. On AArch64, the vector check uses NEON and is always on.
-
-Define the macro only together with a compiler option that enables SSSE3 (e.g. `-mssse3`, or `-march=` with a CPU that
-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.
-
-!!! note "ABI compatibility"
-
-    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
-
-By default, `#!cpp JSON_VIEW_USE_SSSE3` is not defined.
-
-```cpp
-#undef JSON_VIEW_USE_SSSE3
-```
-
-## Examples
-
-??? example
-
-    With CMake, for a program that only runs on CPUs with SSSE3:
-
-    ```cmake
-    target_compile_definitions(your_target PRIVATE JSON_VIEW_USE_SSSE3)
-    target_compile_options(your_target PRIVATE -mssse3)
-    ```
-
-## See also
-
-- [JSON_VIEW_NO_SIMD](json_view_no_simd.md) - use only portable code in the view's parser
-- [JSON_USE_SIMDUTF](json_use_simdutf.md) - validate UTF-8 with simdutf in `basic_json`'s parser
-
-## Version history
-
-- Added in version 3.13.0.

docs/mkdocs/docs/api/macros/nlohmann_define_derived_type.md

@@ -147,6 +147,13 @@ void to_json(BasicJsonType& j, const B& b) {
     See Implementation limits for [NLOHMANN_DEFINE_TYPE_INTRUSIVE](nlohmann_define_type_intrusive.md) and
     [NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE](nlohmann_define_type_non_intrusive.md), respectively.
 
+!!! info "Views"
+
+    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
+    (`<nlohmann/json_view.hpp>`): [`get<T>()`](../basic_json_view/get.md) on a view looks the members up in the
+    view, without building a `json` value first. The base part is read from the view as well if the base's
+    `from_json()` accepts views, and from [`materialize()`](../basic_json_view/materialize.md) otherwise.
+
 ## Examples
 
 ??? example "Example: (1) NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE"
@@ -192,3 +199,5 @@ void to_json(BasicJsonType& j, const B& b) {
 6. Added in version 3.12.0.
 
 All six macros were changed to allow an empty member list in version 3.13.0.
+
+The generated `from_json()` reads the views of `json_document`s since version 3.13.0.

docs/mkdocs/docs/api/macros/nlohmann_define_type_intrusive.md

@@ -81,6 +81,12 @@ See the examples below for the concrete generated code.
       that serializes a struct's members positionally into a JSON array; for that, write `to_json`/`from_json` by
       hand, building/reading a `json::array()` of the members in order.
 
+!!! info "Views"
+
+    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
+    (`<nlohmann/json_view.hpp>`): [`get<T>()`](../basic_json_view/get.md) on a view looks the members up in the
+    view, without building a `json` value first.
+
 ## Examples
 
 ??? example "Example: (1) NLOHMANN_DEFINE_TYPE_INTRUSIVE"
@@ -189,3 +195,5 @@ See the examples below for the concrete generated code.
 
 All three macros were changed to work with any `basic_json` specialization (not only `nlohmann::json`) in version 3.12.0,
 and to allow an empty member list in version 3.13.0.
+
+The generated `from_json()` reads the views of `json_document`s since version 3.13.0.

docs/mkdocs/docs/api/macros/nlohmann_define_type_non_intrusive.md

@@ -80,6 +80,12 @@ See the examples below for the concrete generated code.
       that serializes a struct's members positionally into a JSON array; for that, write `to_json`/`from_json` by
       hand, building/reading a `json::array()` of the members in order.
 
+!!! info "Views"
+
+    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
+    (`<nlohmann/json_view.hpp>`): [`get<T>()`](../basic_json_view/get.md) on a view looks the members up in the
+    view, without building a `json` value first.
+
 ## Examples
 
 ??? example "Example: (1) NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE"
@@ -188,3 +194,5 @@ See the examples below for the concrete generated code.
 
 All three macros were changed to work with any `basic_json` specialization (not only `nlohmann::json`) in version 3.12.0,
 and to allow an empty member list in version 3.13.0.
+
+The generated `from_json()` reads the views of `json_document`s since version 3.13.0.

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

@@ -39,6 +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`, `_ekmo`, `_dsbs`, `_dufio`, `_ns`, `_vns`,
-  and `_vssse3` in version 3.13.0; see
+  version 3.12.0, and the ABI tags `_bics`, `_psp`, `_snul`, `_sbu8`, `_ekmo`, `_dsbs`, `_dufio`, and `_ns` in
+  version 3.13.0; see
   [`nlohmann` Namespace](../../features/namespace.md#structure).

docs/mkdocs/docs/api/macros/nlohmann_json_serialize_enum.md

@@ -45,6 +45,12 @@ inline void from_json(const BasicJsonType& j, type& e);
       Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
       with the converted keys. Such maps can be read from both forms.
 
+!!! info "Views"
+
+    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
+    (`<nlohmann/json_view.hpp>`), comparing the view with the entries of the mapping, without building a `json` value
+    first.
+
 ## Examples
 
 ??? example "Example: Basic usage"
@@ -88,3 +94,5 @@ inline void from_json(const BasicJsonType& j, type& e);
 ## Version history
 
 Added in version 3.4.0.
+
+The generated `from_json()` reads the views of `json_document`s since version 3.13.0.

docs/mkdocs/docs/api/macros/nlohmann_json_serialize_enum_strict.md

@@ -48,6 +48,12 @@ inline void from_json(const BasicJsonType& j, type& e);
       Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
       with the converted keys. Such maps can be read from both forms.
 
+!!! info "Views"
+
+    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
+    (`<nlohmann/json_view.hpp>`), comparing the view with the entries of the mapping, without building a `json` value
+    first.
+
 ## Examples
 
 ??? example "Example: Basic usage"

docs/mkdocs/docs/api/ordered_json_editable_document.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using ordered_json_editable_document = basic_json_document<ordered_json, true>;
+using ordered_json_editable_document = basic_json_document<ordered_json, view_mode::editable>;
 ```
 
 This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the

docs/mkdocs/docs/api/ordered_json_editable_view.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using ordered_json_editable_view = basic_json_view<ordered_json, true>;
+using ordered_json_editable_view = basic_json_view<ordered_json, view_mode::editable>;
 ```
 
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an

docs/mkdocs/docs/api/view_mode.md

@@ -0,0 +1,80 @@
+# <small>nlohmann::</small>view_mode
+
+<small>Defined in header `<nlohmann/json_view.hpp>`</small>
+
+```cpp
+enum class view_mode : std::uint8_t
+{
+    read_only,
+    editable
+};
+```
+
+The second template parameter of [`basic_json_document`](basic_json_document/index.md) and
+[`basic_json_view`](basic_json_view/index.md): whether a document can be changed after parsing, and whether a view is
+of such a document.
+
+`read_only`
+:   the default: the document is parsed once and then only read. It carries none of the bookkeeping edits need, and
+    calling [`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md),
+    [`insert`](basic_json_document/insert.md), or [`erase`](basic_json_document/erase.md) on it fails to compile.
+
+`editable`
+:   the document also offers [`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md),
+    [`insert`](basic_json_document/insert.md), and [`erase`](basic_json_document/erase.md); its views see every edit,
+    see [Edits](basic_json_document/index.md#edits).
+
+The shortcuts name both modes: [`json_document`](json_document.md) and [`json_view`](json_view.md) are read-only,
+[`json_editable_document`](json_editable_document.md) and [`json_editable_view`](json_editable_view.md) are editable
+(and likewise for `ordered_json`).
+
+## Notes
+
+The mode is part of the view's type, and there is no conversion between the two modes: a read-only view reads a
+container in place, while a view of an editable document follows the links that edits leave behind. A function that
+accepts views therefore names the modes it accepts in its signature:
+
+```cpp
+// views of editable documents only
+template<typename BasicJsonType>
+void f(basic_json_view<BasicJsonType, view_mode::editable> v);
+
+// views of read-only documents only
+template<typename BasicJsonType>
+void f(basic_json_view<BasicJsonType, view_mode::read_only> v);
+
+// either
+template<typename BasicJsonType, view_mode Mode>
+void f(basic_json_view<BasicJsonType, Mode> v);
+```
+
+A function that takes a [`json_view`](json_view.md) accepts neither an [`ordered_json_view`](ordered_json_view.md)
+nor a [`json_editable_view`](json_editable_view.md). Views of the two modes still compare with
+[`operator==`](basic_json_view/operator_eq.md).
+
+## Examples
+
+??? example
+
+    The example below shows a function template that accepts the views of both modes, and one that accepts only
+    views of editable documents.
+
+    ```cpp
+    --8<-- "examples/view_mode.cpp"
+    ```
+
+    Output:
+
+    ```
+    --8<-- "examples/view_mode.output"
+    ```
+
+## See also
+
+- [basic_json_document](basic_json_document/index.md) - a parsed JSON text
+- [basic_json_view](basic_json_view/index.md) - a handle to one value of a document
+- [json_editable_document](json_editable_document.md) - an editable document of `json`
+
+## Version history
+
+Added in version 3.13.0.

docs/mkdocs/docs/examples/is_json_view.cpp

@@ -0,0 +1,34 @@
+#include <iostream>
+#include <type_traits>
+#include <nlohmann/json_view.hpp>
+
+using nlohmann::json;
+
+namespace ns
+{
+struct person
+{
+    std::string name;
+    int age = 0;
+};
+
+// reads json values and views (of any document type), but nothing else
+template < typename J, typename std::enable_if < nlohmann::is_json_view<J>::value || std::is_same<J, json>::value, int >::type = 0 >
+void from_json(const J& j, person& p)
+{
+    p.name = j.at("name").template get<std::string>();
+    p.age = j.at("age").template get<int>();
+}
+} // namespace ns
+
+int main()
+{
+    std::cout << std::boolalpha
+              << nlohmann::is_json_view<nlohmann::json_view>::value << ' '
+              << nlohmann::is_json_view<nlohmann::ordered_json_editable_view>::value << ' '
+              << nlohmann::is_json_view<json>::value << '\n';
+
+    const nlohmann::json_document doc = nlohmann::json_document::parse(R"({"name": "Ada", "age": 36})");
+    const auto p = doc.root().get<ns::person>(); // reads the view, no json value is built
+    std::cout << p.name << ' ' << p.age << '\n';
+}

docs/mkdocs/docs/examples/is_json_view.output

@@ -0,0 +1,2 @@
+true true false
+Ada 36

docs/mkdocs/docs/examples/ordered_json_editable_document.cpp

@@ -5,7 +5,7 @@ using ordered_json_editable_document = nlohmann::ordered_json_editable_document;
 
 int main()
 {
-    // ordered_json_editable_document is basic_json_document<nlohmann::ordered_json, true>
+    // ordered_json_editable_document is basic_json_document<nlohmann::ordered_json, nlohmann::view_mode::editable>
     ordered_json_editable_document doc = ordered_json_editable_document::parse(R"({"z": 1, "a": 2, "m": 3})");
     doc.set(doc.root(), "b", 4); // set() always appends a new member at the end
 

docs/mkdocs/docs/examples/sax_parse__error_recovery.cpp

@@ -1,43 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-// a SAX parser that creates a JSON value like json::parse does, but that
-// recovers from parse errors instead of stopping at the first one
-class recovering_parser : public nlohmann::detail::json_sax_dom_parser<json>
-{
-  public:
-    explicit recovering_parser(json& result)
-        : nlohmann::detail::json_sax_dom_parser<json>(result, false)
-    {}
-
-    bool parse_error(std::size_t position,
-                     const std::string& /*last_token*/,
-                     const json::exception& ex)
-    {
-        std::cout << "byte " << position << ": " << ex.what() << '\n';
-
-        // repair the input and continue
-        return true;
-    }
-};
-
-int main()
-{
-    // JSON text with several mistakes that ends too early
-    const std::string text = R"({
-    "name": "Hello World",
-    "tags": ["a" "b",],
-    "valid": tru,
-    "size": 1.,
-    "nested": {"x": 1)";
-
-    json result;
-    recovering_parser sax(result);
-    const bool valid = json::sax_parse(text, &sax);
-
-    std::cout << "\nvalid JSON: " << std::boolalpha << valid << '\n'
-              << std::setw(4) << result << std::endl;
-}

docs/mkdocs/docs/examples/sax_parse__error_recovery.output

@@ -1,19 +0,0 @@
-byte 49: [json.exception.parse_error.101] parse error at line 3, column 20: syntax error while parsing array - unexpected string literal; expected ']'
-byte 51: [json.exception.parse_error.101] parse error at line 3, column 22: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal
-byte 70: [json.exception.parse_error.101] parse error at line 4, column 17: syntax error while parsing value - invalid literal; last read: '"valid": tru,'
-byte 86: [json.exception.parse_error.101] parse error at line 5, column 15: syntax error while parsing value - invalid number; expected digit after '.'; last read: '1.,'
-byte 109: [json.exception.parse_error.101] parse error at line 6, column 22: syntax error while parsing object - unexpected end of input; expected '}'
-
-valid JSON: false
-{
-    "name": "Hello World",
-    "nested": {
-        "x": 1
-    },
-    "size": 1,
-    "tags": [
-        "a",
-        "b"
-    ],
-    "valid": null
-}

docs/mkdocs/docs/examples/view_mode.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using nlohmann::basic_json_view;
+using nlohmann::view_mode;
+
+// accepts the views of read-only and of editable documents, of json and of ordered_json
+template<typename BasicJsonType, view_mode Mode>
+std::size_t count_members(basic_json_view<BasicJsonType, Mode> v)
+{
+    return v.is_object() ? v.size() : 0;
+}
+
+// accepts only the views of editable documents
+template<typename BasicJsonType>
+bool is_edited(basic_json_view<BasicJsonType, view_mode::editable> v)
+{
+    return v.is_string() && v.get_string() == "edited";
+}
+
+int main()
+{
+    const nlohmann::json_document doc = nlohmann::json_document::parse(R"({"a": 1, "b": 2})");
+    nlohmann::json_editable_document edoc = nlohmann::json_editable_document::parse(R"({"a": 1})");
+    edoc.set(edoc.root()["a"], "edited");
+
+    std::cout << count_members(doc.root()) << ' ' << count_members(edoc.root()) << '\n';
+    std::cout << std::boolalpha << is_edited(edoc.root()["a"]) << '\n';
+}

docs/mkdocs/docs/examples/view_mode.output

@@ -0,0 +1,2 @@
+2 1
+true

docs/mkdocs/docs/features/json_view.md

@@ -185,6 +185,10 @@ key as well. Other zero-copy parsers that index the source text, such as yyjson
 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.
 
+The same holds for [`get<T>()`](../api/basic_json_view/get.md) of a type whose `from_json()` reads the view, such as
+the types of the `NLOHMANN_DEFINE_TYPE_*` macros: their members are looked up, so `#!cpp get<point>()` of
+`#!cpp {"x":1,"x":2}` reads `#!cpp x == 1`, while `#!cpp materialize().get<point>()` reads `#!cpp 2`.
+
 **What stays the same as `parse()`?** [`materialize()`](../api/basic_json_view/materialize.md) and
 [`get<std::map<...>>()`](../api/basic_json_view/get.md) replay every member in order, so they keep the *last* value
 exactly like `#!cpp basic_json::parse()` (at the position of the first occurrence of the key, for an
@@ -252,14 +256,14 @@ the stream's `width`/`fill` for indentation.
 ## Editing a document
 
 Everything above is read-only: a `json_document`/`json_view` lets you look at a parsed text without copying it, but
-not change it. [`basic_json_document<BasicJsonType, true>`](../api/basic_json_document/index.md) -- more conveniently
+not change it. [`basic_json_document<BasicJsonType, view_mode::editable>`](../api/basic_json_document/index.md) -- more conveniently
 spelled [`json_editable_document`](../api/json_editable_document.md) or
 [`ordered_json_editable_document`](../api/ordered_json_editable_document.md) -- also lets you
 [`set`](../api/basic_json_document/set.md) a value, [`push_back`](../api/basic_json_document/push_back.md) onto or
 [`insert`](../api/basic_json_document/insert.md) into an array, and [`erase`](../api/basic_json_document/erase.md)
 an object member or an array element, still without ever building a `basic_json` tree for parts you do not touch.
 
-`#!cpp Editable` defaults to `#!cpp false`, so `json_document`/`ordered_json_document` are unaffected -- they carry
+The [mode](../api/view_mode.md) defaults to `#!cpp view_mode::read_only`, so `json_document`/`ordered_json_document` are unaffected -- they carry
 none of the bookkeeping edits need, and calling `set`/`push_back`/`insert`/`erase` on one is a compile error, not a
 runtime one.
 
@@ -354,9 +358,10 @@ validation entirely, for an image trusted as much as the process's own memory. S
 !!! warning "Experimental"
 
     The image format is versioned but not yet stable, and may change in an incompatible way before it is declared
-    stable. It is little-endian only, and tied to the library build that wrote it -- use it to cache a document or to
-    hand one to another process running the *same* build, not as a long-term storage format; keep the original JSON
-    text if a saved document needs to be readable by a future library version.
+    stable. It is little-endian only (on big-endian targets, `save()` and `load()` do not exist), and tied to the
+    library build that wrote it -- use it to cache a document or to hand one to another process running the *same*
+    build, not as a long-term storage format; keep the original JSON text if a saved document needs to be readable by
+    a future library version.
 
 The idea of a document you can read without parsing comes from zero-copy formats such as
 [FlatBuffers](https://github.com/google/flatbuffers) and [YaFF](https://github.com/yandex/yaff); the check

docs/mkdocs/docs/features/macros.md

@@ -287,23 +287,6 @@ external dependency and is not defined by default.
 
 See [full documentation of `JSON_USE_SIMDUTF`](../api/macros/json_use_simdutf.md).
 
-## `JSON_VIEW_NO_SIMD`
-
-When defined, the parser of [`basic_json_document`](../api/basic_json_document/index.md)
-(`<nlohmann/json_view.hpp>`) uses only portable C++ to scan strings, instead of vector instructions (SSE2 on x86-64,
-NEON on AArch64). The same input is accepted or rejected either way; only the speed differs. It is not defined by
-default.
-
-See [full documentation of `JSON_VIEW_NO_SIMD`](../api/macros/json_view_no_simd.md).
-
-## `JSON_VIEW_USE_SSSE3`
-
-When defined on x86-64, the parser of [`basic_json_document`](../api/basic_json_document/index.md)
-(`<nlohmann/json_view.hpp>`) validates non-ASCII text in strings with SSSE3 without asking the CPU first. It is not
-defined by default.
-
-See [full documentation of `JSON_VIEW_USE_SSSE3`](../api/macros/json_view_use_ssse3.md).
-
 ## `NLOHMANN_DEFINE_TYPE_*(...)`, `NLOHMANN_DEFINE_DERIVED_TYPE_*(...)`
 
 The library defines 12 macros to simplify the serialization/deserialization of types. See the page on

docs/mkdocs/docs/features/namespace.md

@@ -28,8 +28,6 @@ The complete default namespace name is derived as follows:
     - [`JSON_DISABLE_UNLOCKED_FILE_IO`](../api/macros/json_disable_unlocked_file_io.md) defined non-zero appends
       `_dufio`.
     - [`JSON_NO_SIMD`](../api/macros/json_no_simd.md) defined appends `_ns`.
-    - [`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.
@@ -115,7 +113,5 @@ follows:
   ([`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)), `_dsbs`
   ([`JSON_DISABLE_STREAM_BULK_SCAN`](../api/macros/json_disable_stream_bulk_scan.md)), `_dufio`
-  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../api/macros/json_disable_unlocked_file_io.md)), `_ns`
-  ([`JSON_NO_SIMD`](../api/macros/json_no_simd.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.
+  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../api/macros/json_disable_unlocked_file_io.md)), and `_ns`
+  ([`JSON_NO_SIMD`](../api/macros/json_no_simd.md)) in version 3.13.0.

docs/mkdocs/docs/features/parsing/error_recovery.md

@@ -1,122 +0,0 @@
-# Error Recovery
-
-By default, parsing stops at the first error. With the [SAX interface](sax_interface.md), you can instead ask the
-parser to *recover*: to repair the error and continue, so that you get as much as possible out of malformed input, for
-instance a file that was cut off, JSON edited by hand, or the output of a language model.
-
-## Recovering from errors
-
-The SAX parser's [`parse_error`](../../api/json_sax/parse_error.md) function is called for every error. Its return value
-decides what happens next:
-
-- `#!cpp false` stops parsing. This is what the SAX parsers of the library do, so [`parse`](../../api/basic_json/parse.md)
-  and [`accept`](../../api/basic_json/accept.md) never recover.
-- `#!cpp true` repairs the error and continues parsing.
-
-When recovering, the SAX parser still receives well-formed events: every `start_object` or `start_array` is followed by
-the matching `end_object` or `end_array`, and every `key` is followed by exactly one value. A SAX parser that creates a
-JSON value, such as the one in the example below, therefore gets a complete value. Parsing always ends, and
-[`sax_parse`](../../api/basic_json/sax_parse.md) returns `#!cpp false` for input that is not valid JSON, even if every
-error was repaired. Each token is reported at most once, and the SAX parser can stop at any error by returning
-`#!cpp false`.
-
-!!! example
-
-    The example below derives a SAX parser from the library's parser for `json` values (`json_sax_dom_parser`),
-    and recovers from all errors.
-
-    ```cpp
-    --8<-- "examples/sax_parse__error_recovery.cpp"
-    ```
-    
-    Output:
-    
-    ```
-    --8<-- "examples/sax_parse__error_recovery.output"
-    ```
-
-## How errors are repaired
-
-Each error is repaired with the smallest local edit: a missing separator is inserted, a stray token is removed, what can
-be read of a broken string or number is kept, and a value that cannot be read at all becomes `#!json null`.
-
-| Mistake                   | Repair                                                                         | Example                                  | Result                     |
-|---------------------------|--------------------------------------------------------------------------------|------------------------------------------|----------------------------|
-| missing `,` or `:`        | inserted                                                                       | `#!json [1 2]`, `#!json {"a" 1}`         | `[1,2]`, `{"a":1}`         |
-| missing value             | `#!json null` for an object key or between commas in an array                  | `#!json {"a":}`, `#!json [1,,2]`         | `{"a":null}`, `[1,null,2]` |
-| trailing comma            | removed                                                                        | `#!json [1,2,]`                          | `[1,2]`                    |
-| broken string             | invalid escapes and bytes are replaced (see below); a line break ends the string | `#!json ["a\qb"]`                        | `["aqb"]`                  |
-| broken number             | the longest valid beginning is kept                                            | `#!json [1., 2e+]`                       | `[1,2]`                    |
-| unreadable value          | `#!json null`                                                                  | `#!json [1, NaN, tru]`                   | `[1,null,null]`            |
-| number too large          | passed as infinity, together with its text                                     | `#!json [1e999]`                         | infinity (see below)       |
-| stray `:`                 | removed                                                                        | `#!json ["a":1]`                         | `["a",1]`                  |
-| member without a key      | skipped up to the next `,` or `}`                                              | `#!json {1:2, "b":3}`                    | `{"b":3}`                  |
-| wrong closing bracket     | closes the innermost array or object                                           | `#!json {"a":[1,2}, "b":3}`              | `{"a":[1,2],"b":3}`        |
-| input ends too early      | all open arrays and objects are closed                                         | `#!json {"a":[1,2`                       | `{"a":[1,2]}`              |
-| text before the value     | skipped                                                                        | `#!json )]}'{"a":1}`                     | `{"a":1}`                  |
-
-In a string, an unknown escape like `\q` stands for the escaped character (`q`), as in JavaScript. An invalid `\u`
-escape, a lone surrogate, and ill-formed UTF-8 are each replaced by U+FFFD (REPLACEMENT CHARACTER), and control
-characters are kept. A string without its closing quote ends at the next line break or at the end of the input.
-
-The input after the top-level value is not repaired: as without recovery, it is reported as an error, and parsing stops.
-
-## Binary formats
-
-The binary formats ([BJData](../binary_formats/bjdata.md), [BON8](../binary_formats/bon8.md),
-[BSON](../binary_formats/bson.md), [CBOR](../binary_formats/cbor.md), [MessagePack](../binary_formats/messagepack.md),
-and [UBJSON](../binary_formats/ubjson.md)) have no delimiters to find the next value by. So what can be repaired depends
-on whether the end of the item with the error is known, a distinction that
-[RFC 8949, Section 5.3](https://www.rfc-editor.org/rfc/rfc8949.html#section-5.3) makes for CBOR, too.
-
-If the item is complete, but cannot be passed on as it is, it is replaced, and parsing continues after it:
-
-| Mistake                                                             | Formats                 | Repair                                                                  |
-|---------------------------------------------------------------------|-------------------------|-------------------------------------------------------------------------|
-| tag, if `tag_handler` is `cbor_tag_handler_t::error` (the default)  | CBOR                    | ignored                                                                 |
-| simple value other than `false`, `true`, and `null`, like undefined | CBOR                    | `#!json null`                                                           |
-| number too large for a custom `number_float_t`, like `float`        | all                     | infinity                                                                |
-| character (`C`) that is not ASCII                                   | BJData, UBJSON          | U+FFFD                                                                  |
-| invalid high-precision number (`H`)                                 | BJData, UBJSON          | the longest valid beginning is kept, as for JSON text, or `#!json null` |
-| high-precision number too large                                     | BJData, UBJSON          | passed as infinity, together with its text                              |
-| object key that is not a string                                     | BON8, CBOR, MessagePack | the member is skipped                                                   |
-| element of a type the library does not read, like ObjectId or date  | BSON                    | `#!json null`                                                           |
-| string without its terminator                                       | BSON                    | kept                                                                    |
-| document whose size does not match its content                      | BSON                    | kept                                                                    |
-
-CBOR tags and simple values are repaired as [RFC 8949, Section 6.1](https://www.rfc-editor.org/rfc/rfc8949.html#section-6.1)
-suggests for converting CBOR to JSON. By default, [`sax_parse`](../../api/basic_json/sax_parse.md) reports every tag as
-an error; when recovering, tags are then ignored like with
-[`cbor_tag_handler_t::ignore`](../../api/basic_json/cbor_tag_handler_t.md). Strings that are not valid UTF-8 are no
-error: like [`from_cbor`](../../api/basic_json/from_cbor.md) and the other functions by default, `sax_parse` passes
-them on as they are.
-
-After any other error, the end of the item is unknown: the input ended, a byte is not a valid type marker, or a size
-cannot be right. Parsing then stops, and the value read so far is completed: a key that waits for its value gets
-`#!json null`, and all open arrays and objects are closed. This keeps everything before the error of an input that was
-cut off. The exception is BSON, which stores the size of every document: an element whose end is unknown gets
-`#!json null`, the rest of its document is skipped, and parsing continues after the document.
-
-## Limitations
-
-- A repair is a guess. For example, `#!json {"a" "b": 1}` could be meant as `#!json {"a": "b"}` or as
-  `#!json {"a": null, "b": 1}`; it is repaired to the former. Treat recovered values as a best effort, and check the
-  reported errors.
-- A closing bracket always closes the innermost array or object. If a bracket is missing rather than wrong, the
-  repair differs from the intention: `#!json {"a": {"b": [1, 2}, "c": 3}` is repaired to
-  `#!json {"a": {"b": [1, 2], "c": 3}}`, although `#!json {"a": {"b": [1, 2]}, "c": 3}` may have been meant.
-- Keys without quotes, and strings in single quotes, are not supported; such members are skipped.
-- In the binary formats, a member that is skipped because its key is not a string is lost, and so are the elements of a
-  BSON document after one whose end is unknown.
-- A number that is too large for `number_float_t` is passed as positive or negative infinity. The SAX parser's
-  `number_float` also gets the number's text, but a JSON value cannot store it, and
-  [`dump`](../../api/basic_json/dump.md) serializes infinity as `#!json null`.
-- When parsing is not strict (see [`sax_parse`](../../api/basic_json/sax_parse.md)), a repair may read parts of the
-  input after the value, for instance of the next value in a stream of concatenated values.
-
-## See also
-
-- [SAX interface](sax_interface.md) - implement a custom SAX handler
-- [`parse_error`](../../api/json_sax/parse_error.md) - the SAX event for parse errors
-- [`sax_parse`](../../api/basic_json/sax_parse.md) - generate SAX events
-- [parsing and exceptions](parse_exceptions.md) - control error handling

docs/mkdocs/docs/features/parsing/index.md

@@ -130,7 +130,7 @@ See [Zero-copy JSON views](../json_view.md) for the concept and the trade-offs.
 When the input is not valid JSON, the `parse` function throws an exception by default. If exceptions are undesired or
 unavailable, the parser can instead return a discarded value, or [`accept`](../../api/basic_json/accept.md) can be used
 to only check whether an input is valid JSON. See [parsing and exceptions](parse_exceptions.md) for the available
-options. To get as much as possible out of malformed input, a SAX parser can [recover from errors](error_recovery.md).
+options.
 
 ## See also
 
@@ -142,6 +142,5 @@ options. To get as much as possible out of malformed input, a SAX parser can [re
 - [parser callbacks](parser_callbacks.md) - influence the parsing by a callback function
 - [SAX interface](sax_interface.md) - implement a custom SAX handler
 - [parsing and exceptions](parse_exceptions.md) - control error handling
-- [error recovery](error_recovery.md) - get as much as possible out of malformed input
 - [parsing untrusted input](untrusted_input.md) - what to consider when parsing input from untrusted sources
 - [Zero-copy JSON views](../json_view.md) - parse into a document and read it through a view

docs/mkdocs/docs/features/parsing/parse_exceptions.md

@@ -64,8 +64,7 @@ bool parse_error(std::size_t position,
                  const json::exception& ex);
 ```
 
-The return value decides whether to stop parsing (`#!cpp false`) or to repair the error and continue
-(`#!cpp true`); see [error recovery](error_recovery.md) for the latter.
+The return value indicates whether the parsing should continue, so the function should usually return `#!cpp false`.
 
 ??? example "Example: report parse errors without exceptions"
 

docs/mkdocs/docs/features/parsing/sax_interface.md

@@ -60,8 +60,7 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex);
 ```
 
-The return value of each function determines whether parsing should proceed. For `parse_error`, returning
-`#!cpp true` [recovers from the error](error_recovery.md).
+The return value of each function determines whether parsing should proceed.
 
 To implement your own SAX handler, proceed as follows:
 
@@ -69,7 +68,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `#!cpp bool json::sax_parse(input, &my_sax);` where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.
 
-Note the `sax_parse` function only returns a `#!cpp bool` indicating whether the input was parsed without errors and no SAX event returned `#!cpp false`. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.
+Note the `sax_parse` function only returns a `#!cpp bool` indicating the result of the last executed SAX event. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.
 
 ## See also
 

docs/mkdocs/docs/home/debugging.md

@@ -21,10 +21,10 @@ ABI tags are not covered and may show raw internal fields instead. To generate a
     ```
 
 3. Generate a Natvis file with the tags of your configuration, for example for `JSON_DIAGNOSTICS`,
-    `JSON_DIAGNOSTIC_POSITIONS`, and `JSON_VIEW_NO_SIMD`:
+    `JSON_DIAGNOSTIC_POSITIONS`, and `JSON_NO_SIMD`:
 
     ```shell
-    make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my_nlohmann_json.natvis"
+    make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my_nlohmann_json.natvis"
     ```
 
 4. Use the generated file instead of `nlohmann_json.natvis`.

docs/mkdocs/docs/home/exceptions.md

@@ -853,17 +853,12 @@ from JSON text.
 
 [`basic_json_document::save()`](../api/basic_json_document/save.md) cannot write an
 [image](../features/json_view.md#images) of a [discarded](../api/basic_json_document/is_discarded.md) document.
-[`save()`](../api/basic_json_document/save.md) and [`load()`](../api/basic_json_document/load.md) also throw this
-exception on a big-endian target, since the image format is little-endian only.
 
 !!! failure "Example messages"
 
     ```
     [json.exception.type_error.320] cannot save a discarded json_document
     ```
-    ```
-    [json.exception.type_error.320] json_document images need a little-endian target
-    ```
 
 !!! note
 

docs/mkdocs/mkdocs.yml

@@ -134,7 +134,6 @@ nav:
       - features/performance.md
       - Parsing:
           - features/parsing/index.md
-          - features/parsing/error_recovery.md
           - features/parsing/json_lines.md
           - features/parsing/parse_exceptions.md
           - features/parsing/parser_callbacks.md
@@ -359,6 +358,7 @@ nav:
           - 'Overview': api/adl_serializer/index.md
           - 'from_json': api/adl_serializer/from_json.md
           - 'to_json': api/adl_serializer/to_json.md
+      - 'is_json_view': api/is_json_view.md
       - 'json': api/json.md
       - 'json_document': api/json_document.md
       - 'json_editable_document': api/json_editable_document.md
@@ -408,6 +408,7 @@ nav:
       - 'ordered_json_editable_view': api/ordered_json_editable_view.md
       - 'ordered_json_view': api/ordered_json_view.md
       - 'ordered_map': api/ordered_map.md
+      - 'view_mode': api/view_mode.md
       - macros:
           - 'Overview': api/macros/index.md
           - 'JSON_ASSERT': api/macros/json_assert.md
@@ -442,8 +443,6 @@ nav:
           - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
           - 'JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS': api/macros/json_use_objects_for_enum_keyed_maps.md
           - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
-          - 'JSON_VIEW_NO_SIMD': api/macros/json_view_no_simd.md
-          - 'JSON_VIEW_USE_SSSE3': api/macros/json_view_use_ssse3.md
           - 'NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_derived_type.md
           - 'NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_intrusive.md
           - 'NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_non_intrusive.md

include/nlohmann/detail/abi_macros.hpp

@@ -128,26 +128,14 @@
     #define NLOHMANN_JSON_ABI_TAG_NO_SIMD
 #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, i, j, k, l, m) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k ## l ## m
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k, l, m) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k, l, m)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -161,9 +149,7 @@
             NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS,       \
             NLOHMANN_JSON_ABI_TAG_DISABLE_STREAM_BULK_SCAN,          \
             NLOHMANN_JSON_ABI_TAG_DISABLE_UNLOCKED_FILE_IO,          \
-            NLOHMANN_JSON_ABI_TAG_NO_SIMD,                           \
-            NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD,                      \
-            NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3)
+            NLOHMANN_JSON_ABI_TAG_NO_SIMD)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

include/nlohmann/detail/conversions/from_json.hpp

@@ -10,6 +10,7 @@
 
 #include <algorithm> // min, transform
 #include <array> // array
+#include <cstddef> // nullptr_t
 #include <forward_list> // forward_list
 #include <iterator> // inserter, front_inserter, end
 #include <map> // map
@@ -27,6 +28,7 @@
 #include <nlohmann/detail/meta/identity_tag.hpp>
 #include <nlohmann/detail/meta/std_fs.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/output/error_handler.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 #include <nlohmann/detail/value_t.hpp>
 
@@ -43,6 +45,65 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
 
+// The from_json() overloads below read basic_json values and the views of
+// <nlohmann/json_view.hpp> (BasicJsonType is then a view, and
+// json_type_of_t<BasicJsonType> its basic_json type). The helpers below are
+// the accesses that differ between the two.
+
+// the boolean of j, a boolean
+template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+typename BasicJsonType::boolean_t boolean_value(const BasicJsonType& j)
+{
+    return *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
+bool boolean_value(const View& v)
+{
+    return v.template get<bool>();
+}
+
+// the string of j, a string
+template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+const typename BasicJsonType::string_t& string_value(const BasicJsonType& j)
+{
+    return *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
+typename View::string_t string_value(const View& v)
+{
+    const auto s = v.get_string();
+    return typename View::string_t(s.data(), s.size());
+}
+
+// the binary value of j, a binary value (never a view: a view of a JSON text
+// holds no binary values)
+template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+const typename BasicJsonType::binary_t& binary_value(const BasicJsonType& j)
+{
+    return *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
+typename View::basic_json_type::binary_t binary_value(const View& /*unused*/)
+{
+    return {}; // LCOV_EXCL_LINE
+}
+
+// the elements of j, an array, for a range-based for loop
+template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+const typename BasicJsonType::array_t& array_elements(const BasicJsonType& j)
+{
+    return *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
+View array_elements(const View& v) noexcept
+{
+    return v; // (a view is two pointers)
+}
+
 template<typename BasicJsonType>
 inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
 {
@@ -71,7 +132,7 @@ void from_json(const BasicJsonType& j, std::optional<T>& opt)
 
 // read a number value of any of the three number types into val;
 // returns false (leaving val untouched) if j is not a number
-template<typename BasicJsonType, typename ArithmeticType>
+template < typename BasicJsonType, typename ArithmeticType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
 bool get_number_value(const BasicJsonType& j, ArithmeticType& val)
 {
     switch (static_cast<value_t>(j))
@@ -108,10 +169,22 @@ bool get_number_value(const BasicJsonType& j, ArithmeticType& val)
     }
 }
 
+// a view converts numbers itself (as basic_json does)
+template<typename View, typename ArithmeticType, enable_if_t<is_json_view<View>::value, int> = 0>
+bool get_number_value(const View& v, ArithmeticType& val)
+{
+    if (!v.is_number())
+    {
+        return false;
+    }
+    val = v.template get<ArithmeticType>();
+    return true;
+}
+
 // overloads for basic_json template parameters
 template < typename BasicJsonType, typename ArithmeticType,
            enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
-                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::boolean_t>::value,
                          int > = 0 >
 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
 {
@@ -122,31 +195,31 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
 }
 
 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::boolean_t& b)
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
     {
         throw_type_must_be("boolean", j);
     }
-    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+    b = boolean_value(j);
 }
 
 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::string_t& s)
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
     {
         throw_type_must_be("string", j);
     }
-    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+    s = string_value(j);
 }
 
 template <
     typename BasicJsonType, typename StringType,
     enable_if_t <
-        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
-        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
-        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
+        std::is_assignable<StringType&, const typename json_type_of_t<BasicJsonType>::string_t>::value
+        && is_detected_exact<typename json_type_of_t<BasicJsonType>::string_t::value_type, value_type_t, StringType>::value
+        && !std::is_same<typename json_type_of_t<BasicJsonType>::string_t, StringType>::value
         && !is_json_ref<StringType>::value, int > = 0 >
 inline void from_json(const BasicJsonType& j, StringType& s)
 {
@@ -155,23 +228,23 @@ inline void from_json(const BasicJsonType& j, StringType& s)
         throw_type_must_be("string", j);
     }
 
-    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+    s = string_value(j);
 }
 
 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::number_float_t& val)
 {
     get_arithmetic_value(j, val);
 }
 
 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, number_unsigned_overload_t<BasicJsonType>& val)
+inline void from_json(const BasicJsonType& j, number_unsigned_overload_t<json_type_of_t<BasicJsonType>>& val)
 {
     get_arithmetic_value(j, val);
 }
 
 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::number_integer_t& val)
 {
     get_arithmetic_value(j, val);
 }
@@ -183,8 +256,8 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
 {
     using underlying_type = typename std::underlying_type<EnumType>::type;
     // get_arithmetic_value() does not accept boolean_t; read the number that to_json() wrote instead
-    using value_type = typename std::conditional<std::is_same<underlying_type, typename BasicJsonType::boolean_t>::value,
-          typename BasicJsonType::number_unsigned_t, underlying_type>::type;
+    using value_type = typename std::conditional<std::is_same<underlying_type, typename json_type_of_t<BasicJsonType>::boolean_t>::value,
+          typename json_type_of_t<BasicJsonType>::number_unsigned_t, underlying_type>::type;
     value_type val;
     get_arithmetic_value(j, val);
     e = static_cast<EnumType>(bool_aware_static_cast<underlying_type>(val));
@@ -193,7 +266,7 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
 
 // forward_list doesn't have an insert method
 template<typename BasicJsonType, typename T, typename Allocator,
-         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+         enable_if_t<is_getable<json_type_of_t<BasicJsonType>, T>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
@@ -201,16 +274,16 @@ inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l
         throw_type_must_be("array", j);
     }
     l.clear();
-    std::transform(j.rbegin(), j.rend(),
-                   std::front_inserter(l), [](const BasicJsonType & i)
+    auto pos = l.before_begin();
+    for (const auto& elem : array_elements(j))
     {
-        return i.template get<T>();
-    });
+        pos = l.insert_after(pos, elem.template get<T>());
+    }
 }
 
 // valarray doesn't have an insert method
 template<typename BasicJsonType, typename T,
-         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+         enable_if_t<is_getable<json_type_of_t<BasicJsonType>, T>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
@@ -218,11 +291,11 @@ inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
         throw_type_must_be("array", j);
     }
     l.resize(j.size());
-    std::transform(j.begin(), j.end(), std::begin(l),
-                   [](const BasicJsonType & elem)
+    std::size_t i = 0;
+    for (const auto& elem : array_elements(j))
     {
-        return elem.template get<T>();
-    });
+        l[i++] = elem.template get<T>();
+    }
 }
 
 // element is not itself a C array: read it directly
@@ -250,7 +323,8 @@ auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines
     from_json_c_array_element(j, arr);
 }
 
-template<typename BasicJsonType>
+// (for a view, array_t is read element by element below)
+template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
 inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
 {
     arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
@@ -259,7 +333,7 @@ inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType:
 // fill a std::array from the JSON array j: the size is checked once and the
 // elements are read in order, so a short array converts the elements it has and
 // then throws the out_of_range error at() would throw for the first missing one
-template<typename BasicJsonType, typename T, std::size_t N>
+template < typename BasicJsonType, typename T, std::size_t N, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
 void from_json_std_array(const BasicJsonType& j, std::array<T, N>& arr)
 {
     const auto& inner_array = *j.template get_ptr<const typename BasicJsonType::array_t*>();
@@ -274,6 +348,21 @@ void from_json_std_array(const BasicJsonType& j, std::array<T, N>& arr)
     }
 }
 
+// (a view has no random access to the elements: they are read in order)
+template<typename View, typename T, std::size_t N, enable_if_t<is_json_view<View>::value, int> = 0>
+void from_json_std_array(const View& v, std::array<T, N>& arr)
+{
+    std::size_t size = 0;
+    for (auto it = v.begin(); size < N && it != v.end(); ++it)
+    {
+        arr[size++] = (*it).template get<T>();
+    }
+    if (JSON_HEDLEY_UNLIKELY(size < N))
+    {
+        static_cast<void>(v.at(size));
+    }
+}
+
 template<typename BasicJsonType, typename T, std::size_t N>
 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
                           priority_tag<2> /*unused*/)
@@ -322,9 +411,8 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p
     void())
 {
     ConstructibleArrayType ret;
-    const auto* inner_array = j.template get_ptr<const typename BasicJsonType::array_t*>();
-    reserve_if_possible(ret, inner_array->size(), priority_tag<1> {});
-    for (const auto& elem : *inner_array)
+    reserve_if_possible(ret, j.size(), priority_tag<1> {});
+    for (const auto& elem : array_elements(j))
     {
         // get<BasicJsonType>() returns *this, this won't call a from_json
         // method when value_type is BasicJsonType
@@ -335,11 +423,11 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p
 
 template < typename BasicJsonType, typename ConstructibleArrayType,
            enable_if_t <
-               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
-               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
-               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
-               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
-               !is_compatible_binary_type<BasicJsonType, ConstructibleArrayType>::value&&
+               is_constructible_array_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename json_type_of_t<BasicJsonType>::binary_t>::value&&
+               !is_compatible_binary_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
                !is_basic_json<ConstructibleArrayType>::value,
                int > = 0 >
 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
@@ -406,24 +494,24 @@ auto from_json(const BasicJsonType& j, identity_tag<std::array<T, N>> tag)
 }
 
 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::binary_t& bin)
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
     {
         throw_type_must_be("binary", j);
     }
 
-    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+    bin = binary_value(j);
 }
 
 template < typename BasicJsonType, typename CompatibleArrayType,
-           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
+           enable_if_t < is_compatible_binary_type<json_type_of_t<BasicJsonType>, CompatibleArrayType>::value,
                          int > = 0 >
 inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
 {
     if (j.is_binary())
     {
-        bin = static_cast<CompatibleArrayType>(*j.template get_ptr<const typename BasicJsonType::binary_t*>());
+        bin = static_cast<CompatibleArrayType>(binary_value(j));
     }
     else if (j.is_array())
     {
@@ -452,8 +540,47 @@ void from_json_object_emplace(ConstructibleObjectType& obj, Key&& key, Value&& v
     obj.emplace(std::forward<Key>(key), std::forward<Value>(value));
 }
 
+// a member of a view's object: a later member with the same key replaces an
+// earlier one, as parse() keeps the last value of a repeated key (containers
+// without operator[] keep the first)
+template<typename ConstructibleObjectType, typename Key, typename Value>
+auto from_json_object_assign(ConstructibleObjectType& obj, Key&& key, Value&& value, priority_tag<1> /*unused*/)
+-> decltype(obj[std::forward<Key>(key)] = std::forward<Value>(value), void())
+{
+    obj[std::forward<Key>(key)] = std::forward<Value>(value);
+}
+
+template<typename ConstructibleObjectType, typename Key, typename Value>
+void from_json_object_assign(ConstructibleObjectType& obj, Key&& key, Value&& value, priority_tag<0> /*unused*/)
+{
+    obj.emplace(std::forward<Key>(key), std::forward<Value>(value));
+}
+
+template < typename BasicJsonType, typename ConstructibleObjectType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+void from_json_object_impl(const BasicJsonType& j, ConstructibleObjectType& ret)
+{
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    reserve_if_possible(ret, inner_object->size(), priority_tag<1> {});
+    for (const auto& p : *inner_object)
+    {
+        from_json_object_emplace(ret, p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>(), priority_tag<1> {});
+    }
+}
+
+template<typename View, typename ConstructibleObjectType, enable_if_t<is_json_view<View>::value, int> = 0>
+void from_json_object_impl(const View& v, ConstructibleObjectType& ret)
+{
+    using string_t = typename View::basic_json_type::object_t::key_type;
+    reserve_if_possible(ret, v.size(), priority_tag<1> {});
+    for (const auto item : v.items())
+    {
+        const auto key = item.key();
+        from_json_object_assign(ret, string_t(key.data(), key.size()), item.value().template get<typename ConstructibleObjectType::mapped_type>(), priority_tag<1> {});
+    }
+}
+
 template<typename BasicJsonType, typename ConstructibleObjectType,
-         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+         enable_if_t<is_constructible_object_type<json_type_of_t<BasicJsonType>, ConstructibleObjectType>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
@@ -462,12 +589,7 @@ inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
     }
 
     ConstructibleObjectType ret;
-    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
-    reserve_if_possible(ret, inner_object->size(), priority_tag<1> {});
-    for (const auto& p : *inner_object)
-    {
-        from_json_object_emplace(ret, p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>(), priority_tag<1> {});
-    }
+    from_json_object_impl(j, ret);
     obj = std::move(ret);
 }
 
@@ -476,10 +598,10 @@ inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
 template < typename BasicJsonType, typename ArithmeticType,
            enable_if_t <
                std::is_arithmetic<ArithmeticType>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
-               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::boolean_t>::value,
                int > = 0 >
 inline void from_json(const BasicJsonType& j, ArithmeticType& val)
 {
@@ -493,7 +615,7 @@ inline void from_json(const BasicJsonType& j, ArithmeticType& val)
     {
         throw_type_must_be("number", j);
     }
-    val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+    val = static_cast<ArithmeticType>(boolean_value(j));
 }
 
 template<typename BasicJsonType, typename Type>
@@ -503,7 +625,7 @@ detail::uncvref_t<Type> from_json_tuple_get_impl(BasicJsonType&& j, detail::iden
 }
 
 template<typename BasicJsonType, typename Type,
-         detail::enable_if_t<detail::is_compatible_reference_type<BasicJsonType, Type>::value, int> = 0>
+         detail::enable_if_t<conjunction<is_basic_json<uncvref_t<BasicJsonType>>, is_compatible_reference_type<BasicJsonType, Type>>::value, int> = 0>
 Type from_json_tuple_get_impl(BasicJsonType && j, detail::identity_tag<Type> /*unused*/, detail::priority_tag<1> /*unused*/)
 {
     return std::forward<BasicJsonType>(j).template get_ref<Type>();
@@ -547,7 +669,7 @@ inline void from_json_tuple_impl(const BasicJsonType& j, std::pair<A1, A2>& p, p
 template<typename BasicJsonType, typename... Args>
 std::tuple<Args...> from_json_tuple_impl(const BasicJsonType& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
 {
-    static_assert(conjunction<disjunction<negation<std::is_reference<Args>>, is_compatible_reference_type<const BasicJsonType&, Args>>...>::value,
+    static_assert(conjunction<disjunction<negation<std::is_reference<Args>>, conjunction<is_basic_json<BasicJsonType>, is_compatible_reference_type<const BasicJsonType&, Args>>>...>::value,
                   "Can not return a tuple containing references to types not contained in a Json, try Json::get_to()");
     return from_json_tuple_impl_base<1, Args...>(j, index_sequence_for<Args...> {});
 }
@@ -593,7 +715,7 @@ void from_json_pair_array_to_map(const BasicJsonType& j, MapType& m)
 // read a map with enum keys from an object, using the enum's own from_json for
 // the keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); this is the form written
 // with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template<typename BasicJsonType, typename Map>
+template < typename BasicJsonType, typename Map, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
 inline bool from_json_enum_keyed_object(const BasicJsonType& j, Map& m, std::true_type /*key is enum*/)
 {
     if (!j.is_object())
@@ -608,6 +730,24 @@ inline bool from_json_enum_keyed_object(const BasicJsonType& j, Map& m, std::tru
     return true;
 }
 
+template<typename View, typename Map, enable_if_t<is_json_view<View>::value, int> = 0>
+inline bool from_json_enum_keyed_object(const View& v, Map& m, std::true_type /*key is enum*/)
+{
+    using json_t = typename View::basic_json_type;
+    if (!v.is_object())
+    {
+        return false;
+    }
+    m.clear();
+    for (const auto item : v.items())
+    {
+        const auto key = item.key();
+        from_json_object_assign(m, json_t(typename json_t::string_t(key.data(), key.size())).template get<typename Map::key_type>(),
+                                item.value().template get<typename Map::mapped_type>(), priority_tag<1> {});
+    }
+    return true;
+}
+
 template<typename BasicJsonType, typename Map>
 inline bool from_json_enum_keyed_object(const BasicJsonType& /*j*/, Map& /*m*/, std::false_type /*key is enum*/)
 {
@@ -616,7 +756,7 @@ inline bool from_json_enum_keyed_object(const BasicJsonType& /*j*/, Map& /*m*/,
 
 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
            typename = enable_if_t < !std::is_constructible <
-                                        typename BasicJsonType::string_t, Key >::value >>
+                                        typename json_type_of_t<BasicJsonType>::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
 {
     // NOLINTNEXTLINE(modernize-type-traits) we use C++11
@@ -629,7 +769,7 @@ void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>&
 
 template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
            typename = enable_if_t < !std::is_constructible <
-                                        typename BasicJsonType::string_t, Key >::value >>
+                                        typename json_type_of_t<BasicJsonType>::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 {
     // NOLINTNEXTLINE(modernize-type-traits) we use C++11
@@ -653,7 +793,7 @@ inline void from_json(const BasicJsonType& j, std_fs::path& p)
     {
         throw_type_must_be("string", j);
     }
-    const auto& s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+    const auto& s = string_value(j);
     // Checking for C++20 standard or later can be insufficient in case the
     // library support for char8_t is either incomplete or was disabled
     // altogether. Use the __cpp_lib_char8_t feature test instead.
@@ -665,16 +805,99 @@ inline void from_json(const BasicJsonType& j, std_fs::path& p)
 }
 #endif
 
-struct from_json_fn
+namespace from_json_adl
 {
-    template<typename BasicJsonType, typename T>
-    auto operator()(const BasicJsonType& j, T&& val) const
+// hides the library's from_json() overloads above (and the from_json object):
+// a call from this namespace finds only the from_json() functions of the
+// arguments' own namespaces and classes (ADL); the declaration is never viable
+// and never defined (not "= delete", which GCC before 6 reports as a use)
+struct hidden;
+void from_json(const hidden&);
+
+// a type no from_json() written for JSON values accepts: a from_json() that
+// accepts it is not constrained to them (see has_view_from_json; it lives
+// here, so that ADL finds no other from_json() for it)
+struct probe
+{};
+
+struct fn
+{
+    template<typename SourceType, typename T>
+    auto operator()(const SourceType& j, T&& val) const
     noexcept(noexcept(from_json(j, std::forward<T>(val))))
     -> decltype(from_json(j, std::forward<T>(val)))
     {
         return from_json(j, std::forward<T>(val));
     }
 };
+}  // namespace from_json_adl
+
+// the sources whose from_json() is only looked up by ADL: the probe
+template<typename T>
+struct is_adl_only_from_json_source : std::is_same<T, from_json_adl::probe> {};
+
+struct from_json_fn
+{
+    template < typename BasicJsonType, typename T,
+               enable_if_t < !is_adl_only_from_json_source<BasicJsonType>::value, int > = 0 >
+    auto operator()(const BasicJsonType& j, T && val) const
+    noexcept(noexcept(from_json(j, std::forward<T>(val))))
+    -> decltype(from_json(j, std::forward<T>(val)))
+    {
+        return from_json(j, std::forward<T>(val));
+    }
+
+    template < typename SourceType, typename T,
+               enable_if_t < is_adl_only_from_json_source<SourceType>::value, int > = 0 >
+    auto operator()(const SourceType& j, T && val) const
+    noexcept(noexcept(from_json_adl::fn {}(j, std::forward<T>(val))))
+    -> decltype(from_json_adl::fn {}(j, std::forward<T>(val)))
+    {
+        return from_json_adl::fn {}(j, std::forward<T>(val));
+    }
+};
+
+// Whether JSONSerializer::from_json(view, T&) reads T from a view (of
+// <nlohmann/json_view.hpp>) directly: it must accept the view but not the
+// probe. An unconstrained from_json() template (written for basic_json, but
+// accepting anything) is thus not called with a view, nor are the library's
+// own conversions; the view converts such types through materialize().
+template<typename Serializer, typename SourceType, typename T>
+using serializer_from_json_t = decltype(Serializer::from_json(std::declval<const SourceType&>(), std::declval<T&>()));
+
+template<typename Serializer, typename View, typename T>
+struct has_view_from_json
+    : conjunction < is_detected<serializer_from_json_t, Serializer, View, T>,
+      negation<is_detected<serializer_from_json_t, Serializer, from_json_adl::probe, T>>> {};
+
+// the base part of a type of the NLOHMANN_DEFINE_DERIVED_TYPE_* macros: from a
+// view through its get_to(), which reads the base from the view where the
+// base's from_json() accepts views, and from materialize() otherwise
+template<typename BasicJsonType, typename T, enable_if_t<is_basic_json<BasicJsonType>::value, int> = 0>
+void from_json_base(const BasicJsonType& j, T& base)
+{
+    from_json_fn {}(j, base);
+}
+
+template<typename View, typename T, enable_if_t<is_json_view<View>::value, int> = 0>
+void from_json_base(const View& v, T& base)
+{
+    v.get_to(base);
+}
+
+// a value as an exception message shows it (invalid UTF-8 replaced; the
+// strings of a view are always valid UTF-8)
+template<typename BasicJsonType, enable_if_t<is_basic_json<BasicJsonType>::value, int> = 0>
+typename BasicJsonType::string_t from_json_dump(const BasicJsonType& j)
+{
+    return j.dump(-1, ' ', false, error_handler_t::replace);
+}
+
+template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
+typename View::string_t from_json_dump(const View& v)
+{
+    return v.dump();
+}
 
 }  // namespace detail
 

include/nlohmann/detail/exceptions.hpp

@@ -102,7 +102,7 @@ enum class exception_id : int
     type_not_serializable = 317, ///< a value cannot be serialized to the requested binary format
     enum_key_duplicate = 318, ///< an enum-keyed map has two keys that serialize to the same string
     document_binary_value = 319, ///< a binary value is stored in a json_document
-    document_image_unsupported = 320, ///< a json_document image cannot be saved or loaded (discarded document, big-endian target)
+    document_image_unsupported = 320, ///< a discarded json_document cannot be saved as an image
     discarded_value_used = 321, ///< a discarded value is used
     // out_of_range
     array_index_out_of_range = 401, ///< an array index is out of range
@@ -417,6 +417,20 @@ void templated_json_throw(ExceptionType exception)
     (void)exception;
 }
 
+// the context of an exception about j: j itself for a basic_json value (whose
+// path JSON_DIAGNOSTICS shows), none for a view of <nlohmann/json_view.hpp>
+template<typename BasicJsonType, enable_if_t<is_basic_json<BasicJsonType>::value, int> = 0>
+const BasicJsonType * exception_context(const BasicJsonType& j) noexcept
+{
+    return &j;
+}
+
+template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
+std::nullptr_t exception_context(const View& /*unused*/) noexcept
+{
+    return nullptr;
+}
+
 /*!
 @brief throws because @a j does not have the type a conversion expects
 @param[in] expected  the expected type(s), e.g. "array" or "binary or array"
@@ -428,7 +442,7 @@ JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE void throw_type_must_be(const cha
 {
     static_cast<void>(expected); // unused when JSON_NOEXCEPTION is defined
     static_cast<void>(j);
-    JSON_THROW(type_error::create(exception_id::type_mismatch, concat("type must be ", expected, ", but is ", j.type_name()), &j));
+    JSON_THROW(type_error::create(exception_id::type_mismatch, concat("type must be ", expected, ", but is ", j.type_name()), exception_context(j)));
 }
 
 /*!

include/nlohmann/detail/input/input_adapters.hpp

@@ -796,22 +796,17 @@ class iterator_input_adapter
         return get_consumed_count() + eof_reads;
     }
 
-    // number of newlines in the consumed range [first_index, last_index); if
-    // there is one, @a line_start is set to the index after the last of them,
-    // otherwise it is left unchanged; only valid when supports_seek
-    std::size_t count_consumed_lines(std::size_t first_index, std::size_t last_index, std::size_t& line_start) const
+    // number of newlines in the consumed range [0, last_index); @a line_start
+    // is set to the index after the last of them (0 if there is none); only
+    // valid when supports_seek
+    std::size_t count_consumed_lines(std::size_t last_index, std::size_t& line_start) const
     {
-        using difference_type = typename std::iterator_traits<IteratorType>::difference_type;
-        const auto from = std::next(begin, static_cast<difference_type>(first_index));
-        const auto to = std::next(from, static_cast<difference_type>(last_index - first_index));
+        const auto to = std::next(begin, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(last_index));
         const auto newline = char_traits<char_type>::to_char_type('\n');
         using reverse_it = std::reverse_iterator<IteratorType>;
-        const auto last_newline = std::find(reverse_it(to), reverse_it(from), newline);
-        if (last_newline.base() != from)
-        {
-            line_start = static_cast<std::size_t>(std::distance(begin, last_newline.base()));
-        }
-        return static_cast<std::size_t>(std::count(from, last_newline.base(), newline));
+        const auto last_newline = std::find(reverse_it(to), reverse_it(begin), newline);
+        line_start = static_cast<std::size_t>(std::distance(begin, last_newline.base()));
+        return static_cast<std::size_t>(std::count(begin, last_newline.base(), newline));
     }
 
     // append the already-consumed characters in the half-open range

include/nlohmann/detail/input/json_sax.hpp

@@ -138,9 +138,7 @@ struct json_sax
     @param[in] position    the position in the input where the error occurs
     @param[in] last_token  the last read token
     @param[in] ex          an exception object describing the error
-    @return whether to recover from the error: false stops parsing; true
-            repairs the error and continues, or, if that is not possible,
-            stops after completing the value read so far
+    @return whether parsing should proceed (must return false)
     */
     virtual bool parse_error(std::size_t position,
                              const std::string& last_token,
@@ -471,15 +469,12 @@ constructor contains the parsed value. Without @a Collect, every value is
 stored in place as it arrives, so after a parse error the value holds what was
 read up to it.
 
-@tparam BasicJsonType     the JSON type
-@tparam InputAdapterType  the input adapter of the lexer that can be passed to
-                          the constructor to record diagnostic positions; it
-                          does not matter if no lexer is passed
-@tparam Collect           whether to collect the values of containers of
-                          unknown size on a stack (only for a caller that does
-                          not use the value after a parse error)
+@tparam BasicJsonType  the JSON type
+@tparam Collect  whether to collect the values of containers of unknown size on
+                 a stack (only for a caller that does not use the value after a
+                 parse error)
 */
-template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type, bool Collect = false>
+template<typename BasicJsonType, typename InputAdapterType, bool Collect = false>
 class json_sax_dom_parser : public json_sax_dom_error_state
 {
   public:
@@ -777,8 +772,6 @@ class json_sax_dom_parser : public json_sax_dom_error_state
         JSON_HEDLEY_NEVER_INLINE
         void grow()
         {
-            // the stack starts with local_capacity frames and only grows
-            JSON_ASSERT(capacity != 0);
             const std::size_t new_capacity = capacity * 2;
             std::unique_ptr<frame[]> new_heap(new frame[new_capacity]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
             std::copy(data, data + count, new_heap.get());
@@ -1588,7 +1581,7 @@ class json_sax_dom_binary_parser : public json_sax_dom_error_state
     lexer_t* m_lexer_ref = nullptr;
 };
 
-template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type>
+template<typename BasicJsonType, typename InputAdapterType>
 class json_sax_dom_callback_parser : public json_sax_dom_error_state
 {
   public:

include/nlohmann/detail/input/lexer.hpp

@@ -10,7 +10,7 @@
 
 #include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint8_t, uint32_t
+#include <cstdint> // uint32_t
 #include <cstdio> // snprintf
 #include <cstring> // memcmp
 #include <initializer_list> // initializer_list
@@ -381,20 +381,6 @@ class lexer : public lexer_base<BasicJsonType>
         return codepoint;
     }
 
-    /// the code point of the surrogate pair @a high (U+D800..U+DBFF) and @a low (U+DC00..U+DFFF)
-    static constexpr int combine_surrogates(const int high, const int low) noexcept
-    {
-        return static_cast<int>(
-                   // high surrogate occupies the most significant 22 bits
-                   (static_cast<unsigned int>(high) << 10u)
-                   // low surrogate occupies the least significant 15 bits
-                   + static_cast<unsigned int>(low)
-                   // there is still the 0xD800, 0xDC00, and 0x10000 noise
-                   // in the result, so we have to subtract with:
-                   // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
-                   - 0x35FDC00u);
-    }
-
     /*!
     @brief check if the next byte(s) are inside a given range
 
@@ -425,7 +411,6 @@ class lexer : public lexer_base<BasicJsonType>
             else
             {
                 error_message = "invalid string: ill-formed UTF-8 byte";
-                error_cause = error_kind::string_ill_formed_utf8;
                 return false;
             }
         }
@@ -541,7 +526,6 @@ class lexer : public lexer_base<BasicJsonType>
                 case char_traits<char_type>::eof():
                 {
                     error_message = "invalid string: missing closing quote";
-                    error_cause = error_kind::string;
                     return token_type::parse_error;
                 }
 
@@ -598,7 +582,6 @@ class lexer : public lexer_base<BasicJsonType>
                             if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
                             {
                                 error_message = "invalid string: '\\u' must be followed by 4 hex digits";
-                                error_cause = error_kind::string_invalid_escape;
                                 return token_type::parse_error;
                             }
 
@@ -606,23 +589,13 @@ class lexer : public lexer_base<BasicJsonType>
                             if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
                             {
                                 // expect next \uxxxx entry
-                                if (JSON_HEDLEY_LIKELY(get() == '\\'))
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
                                 {
-                                    if (JSON_HEDLEY_UNLIKELY(get() != 'u'))
-                                    {
-                                        // current is the character escaped by the backslash
-                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
-                                        error_cause = error_kind::string_invalid_escape;
-                                        string_error_resume = resume_kind::escaped_character;
-                                        return token_type::parse_error;
-                                    }
-
                                     const int codepoint2 = get_codepoint();
 
                                     if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
                                     {
                                         error_message = "invalid string: '\\u' must be followed by 4 hex digits";
-                                        error_cause = error_kind::string_invalid_escape;
                                         return token_type::parse_error;
                                     }
 
@@ -630,23 +603,25 @@ class lexer : public lexer_base<BasicJsonType>
                                     if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
                                     {
                                         // overwrite codepoint
-                                        codepoint = combine_surrogates(codepoint1, codepoint2);
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00, and 0x10000 noise
+                                                        // in the result, so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
                                     }
                                     else
                                     {
-                                        // the second escape was read completely and is a
-                                        // code point of its own
                                         error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
-                                        error_cause = error_kind::string_invalid_escape;
-                                        string_error_resume = resume_kind::after_escape;
-                                        string_error_codepoint = codepoint2;
                                         return token_type::parse_error;
                                     }
                                 }
                                 else
                                 {
                                     error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
-                                    error_cause = error_kind::string_invalid_escape;
                                     return token_type::parse_error;
                                 }
                             }
@@ -654,10 +629,7 @@ class lexer : public lexer_base<BasicJsonType>
                             {
                                 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
                                 {
-                                    // the escape was read completely
                                     error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
-                                    error_cause = error_kind::string_invalid_escape;
-                                    string_error_resume = resume_kind::after_escape;
                                     return token_type::parse_error;
                                 }
                             }
@@ -666,7 +638,10 @@ class lexer : public lexer_base<BasicJsonType>
                             JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
 
                             // translate codepoint into bytes
-                            add_codepoint(codepoint);
+                            encode_utf8(static_cast<std::uint32_t>(codepoint), [this](std::uint32_t byte)
+                            {
+                                add(static_cast<char_int_type>(byte));
+                            });
 
                             break;
                         }
@@ -674,7 +649,6 @@ class lexer : public lexer_base<BasicJsonType>
                         // other characters after escape
                         default:
                             error_message = "invalid string: forbidden character after backslash";
-                            error_cause = error_kind::string;
                             return token_type::parse_error;
                     }
 
@@ -751,7 +725,6 @@ class lexer : public lexer_base<BasicJsonType>
                         }
                     };
                     error_message = control_character_messages[static_cast<std::size_t>(current)];
-                    error_cause = error_kind::string;
                     return token_type::parse_error;
                 }
 
@@ -974,7 +947,6 @@ class lexer : public lexer_base<BasicJsonType>
                 default:
                 {
                     error_message = "invalid string: ill-formed UTF-8 byte";
-                    error_cause = error_kind::string_ill_formed_utf8;
                     return token_type::parse_error;
                 }
             }
@@ -1030,7 +1002,6 @@ class lexer : public lexer_base<BasicJsonType>
                         case char_traits<char_type>::eof():
                         {
                             error_message = "invalid comment; missing closing '*/'";
-                            error_cause = error_kind::unclosed_comment;
                             return false;
                         }
 
@@ -1061,7 +1032,6 @@ class lexer : public lexer_base<BasicJsonType>
             default:
             {
                 error_message = "invalid comment; expecting '/' or '*' after '/'";
-                error_cause = error_kind::other;
                 return false;
             }
         }
@@ -1187,7 +1157,6 @@ scan_number_minus:
             default:
             {
                 error_message = "invalid number; expected digit after '-'";
-                error_cause = error_kind::number;
                 return token_type::parse_error;
             }
         }
@@ -1274,7 +1243,6 @@ scan_number_decimal1:
             default:
             {
                 error_message = "invalid number; expected digit after '.'";
-                error_cause = error_kind::number;
                 return token_type::parse_error;
             }
         }
@@ -1343,7 +1311,6 @@ scan_number_exponent:
             {
                 error_message =
                     "invalid number; expected '+', '-', or digit after exponent";
-                error_cause = error_kind::number;
                 return token_type::parse_error;
             }
         }
@@ -1370,7 +1337,6 @@ scan_number_sign:
             default:
             {
                 error_message = "invalid number; expected digit after exponent sign";
-                error_cause = error_kind::number;
                 return token_type::parse_error;
             }
         }
@@ -1798,7 +1764,6 @@ scan_number_done:
             if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != static_cast<char_type>(rest[i])))
             {
                 error_message = "invalid literal";
-                error_cause = error_kind::other;
                 return token_type::parse_error;
             }
         }
@@ -2189,25 +2154,17 @@ scan_number_done:
         return position.chars_read_total;
     }
 
-    /// seekable adapter: count the lines in the consumed input. Only the
-    /// input consumed since the previous call is scanned, so a parse that
-    /// reports many errors (a SAX parser recovering from them) stays linear
-    /// in the input instead of rescanning it for every error.
+    /// seekable adapter: count the lines in the consumed input; O(input read
+    /// so far), but only called on errors
     position_t get_position_impl(std::true_type /*lazy*/) const
     {
         position_t result;
         result.chars_read_total = get_chars_read_total();
         // reads at EOF count as characters but are not part of the input
         const std::size_t consumed = (std::min)(result.chars_read_total, ia.get_consumed_count());
-        if (JSON_HEDLEY_UNLIKELY(consumed < position_cache.consumed))
-        {
-            // the consumed input never shrinks; recount from the start if it did
-            position_cache = {};
-        }
-        position_cache.lines += ia.count_consumed_lines(position_cache.consumed, consumed, position_cache.line_start);
-        position_cache.consumed = consumed;
-        result.lines_read = position_cache.lines;
-        result.chars_read_current_line = result.chars_read_total - position_cache.line_start;
+        std::size_t line_start = 0;
+        result.lines_read = ia.count_consumed_lines(consumed, line_start);
+        result.chars_read_current_line = result.chars_read_total - line_start;
         return result;
     }
 
@@ -2391,7 +2348,6 @@ scan_number_done:
         if (get_chars_read_total() == 0 && !skip_bom())
         {
             error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
-            error_cause = error_kind::other;
             return token_type::parse_error;
         }
 
@@ -2499,583 +2455,10 @@ scan_number_done:
             // error
             default:
                 error_message = "invalid literal";
-                error_cause = error_kind::other;
                 return token_type::parse_error;
         }
     }
 
-  public:
-    /////////////////////
-    // error recovery
-    /////////////////////
-
-    /*!
-    @brief make the best of the token that scan() rejected
-
-    Called by the parser after scan() returned token_type::parse_error and the
-    SAX parser asked to recover from the error (see #3989). Keeps what can be
-    read of the token and skips the rest:
-
-    - A string keeps its characters. An unknown escape stands for the escaped
-      character itself (as in JavaScript), an invalid Unicode escape and ill-formed
-      UTF-8 become U+FFFD, and a control character is kept. A line break or the
-      end of the input ends a string that lacks its closing quote.
-    - A number keeps its longest valid prefix, e.g. `1` for `1.` or `1e+`.
-    - A block comment that is not closed runs to the end of the input.
-    - Anything else is skipped.
-
-    The rest of an invalid token is skipped up to the next delimiter
-    (whitespace, a structural character, or a quote). A delimiter that the
-    invalid token consumed is returned to the input, so that the next scan()
-    reads it.
-
-    @return token_type::value_string or a number token type if a string or a
-            number could be read, token_type::end_of_input for a block comment
-            that is not closed, token_type::uninitialized otherwise
-    */
-    token_type recover_token()
-    {
-        const resume_kind resume = string_error_resume;
-        const int codepoint = string_error_codepoint;
-        string_error_resume = resume_kind::character;
-        string_error_codepoint = -1;
-
-        const error_kind cause = error_cause;
-        error_cause = error_kind::other;
-
-        switch (cause)
-        {
-            case error_kind::string:
-            case error_kind::string_invalid_escape:
-            case error_kind::string_ill_formed_utf8:
-                return recover_string(cause, resume, codepoint);
-
-            case error_kind::number:
-                return recover_number();
-
-            case error_kind::unclosed_comment:
-                // the comment runs to the end of the input
-                return token_type::end_of_input;
-
-            case error_kind::other:
-            default:
-                skip_to_delimiter();
-                return token_type::uninitialized;
-        }
-    }
-
-    /*!
-    @brief return the token that scan() read last to the input, so that the
-           next scan() reads it again
-
-    Called by the parser when recovering from an error. The token must be a
-    single character (',', ':', '[', ']', '{', or '}') or the end of the
-    input, and scan() must have read it last.
-    */
-    void unget_token()
-    {
-        JSON_ASSERT(!next_unget);
-        unget();
-    }
-
-    /*!
-    @brief let the token string for the next error begin at the current character
-
-    The token string of an error reaches back to the beginning of the last
-    string or number. After an error, the parser calls this function so that
-    the next error does not report (and, with many errors, copy) everything
-    read since then.
-    */
-    void restart_token_string()
-    {
-        restart_token_string_impl(std::integral_constant<bool, lazy_token_string> {});
-    }
-
-  private:
-    /// how recover_string() continues after the error scan_string() reported
-    enum class resume_kind : std::uint8_t
-    {
-        /// current is the next character of the string (or the end of input)
-        character,
-        /// current is the character escaped by the preceding backslash
-        escaped_character,
-        /// current is the last character of a complete escape
-        after_escape
-    };
-
-    /// what kind of token scan() rejected, which decides how recover_token() repairs it
-    enum class error_kind : std::uint8_t
-    {
-        /// anything not listed below; skipped up to the next delimiter
-        other,
-        /// a string
-        string,
-        /// a string with an invalid Unicode escape, which becomes U+FFFD
-        string_invalid_escape,
-        /// a string with ill-formed UTF-8, which becomes U+FFFD
-        string_ill_formed_utf8,
-        /// a number
-        number,
-        /// a block comment that is not closed
-        unclosed_comment
-    };
-
-    /// whether current ends an invalid token (see recover_token())
-    bool current_is_delimiter() const noexcept
-    {
-        switch (current)
-        {
-            case ' ':
-            case '\t':
-            case '\n':
-            case '\r':
-            case '[':
-            case ']':
-            case '{':
-            case '}':
-            case ',':
-            case ':':
-            case '\"':
-#if !JSON_STRICT_NUL_HANDLING
-            case '\0':
-#endif
-            case char_traits<char_type>::eof():
-                return true;
-
-            case '/':
-                return ignore_comments;
-
-            default:
-                return false;
-        }
-    }
-
-    /// skip the rest of an invalid token and return its delimiter to the input
-    void skip_to_delimiter()
-    {
-        while (!current_is_delimiter())
-        {
-            get();
-        }
-
-        if (current != char_traits<char_type>::eof())
-        {
-            unget();
-        }
-    }
-
-    /// append U+FFFD REPLACEMENT CHARACTER to token_buffer
-    void add_replacement_character()
-    {
-        add_codepoint(0xFFFD);
-    }
-
-    /// append the UTF-8 encoding of @a codepoint (not a surrogate) to token_buffer
-    void add_codepoint(const int codepoint)
-    {
-        JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
-        encode_utf8(static_cast<std::uint32_t>(codepoint), [this](std::uint32_t byte)
-        {
-            add(static_cast<char_int_type>(byte));
-        });
-    }
-
-    /// append a code point read from a Unicode escape; a surrogate becomes U+FFFD
-    void add_escaped_codepoint(const int codepoint)
-    {
-        if (0xD800 <= codepoint && codepoint <= 0xDFFF)
-        {
-            add_replacement_character();
-        }
-        else
-        {
-            add_codepoint(codepoint);
-        }
-    }
-
-    /*!
-    @brief remove an incomplete UTF-8 sequence from the end of token_buffer
-
-    next_byte_in_range() adds the bytes of a sequence as it checks them, so
-    when it rejects a byte, the beginning of the sequence is already in
-    token_buffer, which otherwise holds only complete sequences.
-
-    @return whether an incomplete sequence was removed
-    */
-    bool remove_incomplete_utf8_sequence()
-    {
-        std::size_t lead = token_buffer.size();
-        std::size_t continuation_bytes = 0;
-        while (lead > 0 && continuation_bytes < 3
-                && (static_cast<unsigned char>(token_buffer[lead - 1]) & 0xC0u) == 0x80u)
-        {
-            --lead;
-            ++continuation_bytes;
-        }
-        if (lead == 0)
-        {
-            return false;
-        }
-
-        const auto lead_byte = static_cast<unsigned char>(token_buffer[lead - 1]);
-        std::size_t expected = 0;
-        if (lead_byte >= 0xF0)
-        {
-            expected = 3;
-        }
-        else if (lead_byte >= 0xE0)
-        {
-            expected = 2;
-        }
-        else if (lead_byte >= 0xC0)
-        {
-            expected = 1;
-        }
-        if (continuation_bytes >= expected)
-        {
-            return false;
-        }
-
-        token_buffer.resize(lead - 1);
-        return true;
-    }
-
-    /*!
-    @brief read the UTF-8 sequence that begins with current, which is not ASCII
-    @return whether the next character must be read; false if current still
-            needs to be handled, because it does not belong to the sequence
-    */
-    bool recover_utf8_sequence()
-    {
-        // the number of continuation bytes and the range of the first one;
-        // see the ranges in scan_string()
-        std::size_t count = 0;
-        char_int_type low = 0x80;
-        char_int_type high = 0xBF;
-        if (current >= 0xC2 && current <= 0xDF)
-        {
-            count = 1;
-        }
-        else if (current >= 0xE0 && current <= 0xEF)
-        {
-            count = 2;
-            low = (current == 0xE0) ? 0xA0 : 0x80;
-            high = (current == 0xED) ? 0x9F : 0xBF;
-        }
-        else if (current >= 0xF0 && current <= 0xF4)
-        {
-            count = 3;
-            low = (current == 0xF0) ? 0x90 : 0x80;
-            high = (current == 0xF4) ? 0x8F : 0xBF;
-        }
-        else
-        {
-            // an ill-formed byte
-            add_replacement_character();
-            return true;
-        }
-
-        const std::size_t start = token_buffer.size();
-        add(current);
-        for (std::size_t i = 0; i < count; ++i)
-        {
-            get();
-            if (current < low || current > high)
-            {
-                token_buffer.resize(start);
-                add_replacement_character();
-                return false;
-            }
-            add(current);
-            low = 0x80;
-            high = 0xBF;
-        }
-        return true;
-    }
-
-    /*!
-    @brief read the low surrogate that must follow the high surrogate @a high
-    @return whether the next character must be read; false if current still
-            needs to be handled
-    */
-    bool recover_low_surrogate(int high)
-    {
-        while (true)
-        {
-            if (get() != '\\')
-            {
-                add_replacement_character();
-                return false;
-            }
-            if (get() != 'u')
-            {
-                add_replacement_character();
-                // not 'u', so this does not come back here
-                return recover_escape();
-            }
-
-            const int low = get_codepoint();
-            if (low == -1)
-            {
-                add_replacement_character();
-                return false;
-            }
-            if (0xDC00 <= low && low <= 0xDFFF)
-            {
-                add_codepoint(combine_surrogates(high, low));
-                return true;
-            }
-
-            // high has no low surrogate
-            add_replacement_character();
-            if (low < 0xD800 || low > 0xDBFF)
-            {
-                add_codepoint(low);
-                return true;
-            }
-            // another high surrogate
-            high = low;
-        }
-    }
-
-    /*!
-    @brief read the escape whose backslash was read; current is the escaped character
-    @return whether the next character must be read; false if current still
-            needs to be handled
-    */
-    bool recover_escape()
-    {
-        switch (current)
-        {
-            case '\"':
-                add('\"');
-                return true;
-            case '\\':
-                add('\\');
-                return true;
-            case '/':
-                add('/');
-                return true;
-            case 'b':
-                add('\b');
-                return true;
-            case 'f':
-                add('\f');
-                return true;
-            case 'n':
-                add('\n');
-                return true;
-            case 'r':
-                add('\r');
-                return true;
-            case 't':
-                add('\t');
-                return true;
-
-            case 'u':
-            {
-                const int codepoint = get_codepoint();
-                if (codepoint == -1)
-                {
-                    add_replacement_character();
-                    return false;
-                }
-                if (0xD800 <= codepoint && codepoint <= 0xDBFF)
-                {
-                    return recover_low_surrogate(codepoint);
-                }
-                add_escaped_codepoint(codepoint);
-                return true;
-            }
-
-            // an unknown escape stands for the escaped character
-            default:
-                return false;
-        }
-    }
-
-    /*!
-    @brief read the rest of a string after scan_string() rejected it
-
-    token_buffer holds what scan_string() read before the error. See
-    recover_token() for how errors are repaired.
-
-    @param[in] cause      the kind of error scan_string() reported
-    @param[in] resume     how to continue, see resume_kind
-    @param[in] codepoint  for a high surrogate followed by an escape of another
-                          code point: that code point; -1 otherwise
-    */
-    token_type recover_string(const error_kind cause, const resume_kind resume, const int codepoint)
-    {
-        // whether the next character must be read before it can be handled
-        bool fetch = false;
-
-        if (cause == error_kind::string_invalid_escape
-                || (cause == error_kind::string_ill_formed_utf8 && remove_incomplete_utf8_sequence()))
-        {
-            add_replacement_character();
-        }
-
-        switch (resume)
-        {
-            case resume_kind::escaped_character:
-                fetch = recover_escape();
-                break;
-            case resume_kind::after_escape:
-                if (0xD800 <= codepoint && codepoint <= 0xDBFF)
-                {
-                    fetch = recover_low_surrogate(codepoint);
-                }
-                else
-                {
-                    if (codepoint != -1)
-                    {
-                        add_escaped_codepoint(codepoint);
-                    }
-                    fetch = true;
-                }
-                break;
-            case resume_kind::character:
-            default:
-                break;
-        }
-
-        while (true)
-        {
-            if (fetch)
-            {
-                get();
-            }
-            fetch = true;
-
-            switch (current)
-            {
-                case '\"':
-                // a line break or the end of the input ends a string that
-                // lacks its closing quote
-                case '\n':
-                case '\r':
-                case char_traits<char_type>::eof():
-                    return token_type::value_string;
-
-#if !JSON_STRICT_NUL_HANDLING
-                case '\0':
-                    // the end of the input, see scan()
-                    unget();
-                    return token_type::value_string;
-#endif
-
-                case '\\':
-                    get();
-                    fetch = recover_escape();
-                    break;
-
-                default:
-                    if (current < 0x80)
-                    {
-                        // including control characters
-                        add(current);
-                    }
-                    else
-                    {
-                        fetch = recover_utf8_sequence();
-                    }
-                    break;
-            }
-        }
-    }
-
-    /*!
-    @brief keep the longest valid prefix of a number that scan_number() rejected
-
-    token_buffer holds the characters scan_number() accepted before the error,
-    so the prefix ends at its last digit.
-    */
-    token_type recover_number()
-    {
-        // only size(), operator[], and resize() are used, which every string
-        // type the library supports provides
-        std::size_t length = token_buffer.size();
-        while (length != 0 && (token_buffer[length - 1] < '0' || token_buffer[length - 1] > '9'))
-        {
-            --length;
-        }
-        token_buffer.resize(length);
-
-        if (length == 0)
-        {
-            skip_to_delimiter();
-            return token_type::uninitialized;
-        }
-
-        if (decimal_point_position >= length)
-        {
-            decimal_point_position = std::string::npos;
-        }
-
-        std::size_t exponent = std::string::npos;
-        for (std::size_t i = 0; i < length; ++i)
-        {
-            if (token_buffer[i] == 'e' || token_buffer[i] == 'E')
-            {
-                exponent = i;
-                break;
-            }
-        }
-        const std::size_t mantissa_end = (exponent == std::string::npos) ? length : exponent;
-        token_type number_type = token_type::value_unsigned;
-        if (decimal_point_position != std::string::npos || exponent != std::string::npos)
-        {
-            number_type = token_type::value_float;
-        }
-        else if (token_buffer[0] == '-')
-        {
-            number_type = token_type::value_integer;
-        }
-
-        const token_type result = convert_number(number_type, mantissa_end);
-        skip_to_delimiter();
-        return result;
-    }
-
-    /// seekable or token-tracking adapter: the token string begins at current
-    void restart_token_string_impl(std::true_type /*lazy*/)
-    {
-        restart_token_string_lazy(std::integral_constant<bool, adapter_token> {});
-    }
-
-    /// seekable adapter: the token string begins at current, which was consumed
-    void restart_token_string_lazy(std::false_type /*adapter_token*/) noexcept
-    {
-        const std::size_t consumed = ia.get_consumed_count();
-        token_string_start = (consumed > 0 && current != char_traits<char_type>::eof()) ? consumed - 1 : consumed;
-    }
-
-    /// token-tracking adapter: the token begins with current, or with the next
-    /// character if current was put back or is the end of input
-    void restart_token_string_lazy(std::true_type /*adapter_token*/)
-    {
-        if (!next_unget && current != char_traits<char_type>::eof())
-        {
-            ia.mark_token_start(current);
-        }
-        else
-        {
-            ia.begin_token();
-        }
-    }
-
-    /// streaming adapter: the token string begins at current; a character
-    /// that was put back is copied again when it is read again
-    void restart_token_string_impl(std::false_type /*lazy*/)
-    {
-        token_string.clear();
-        if (!next_unget && current != char_traits<char_type>::eof())
-        {
-            token_string.push_back(char_traits<char_type>::to_char_type(current));
-        }
-    }
-
     /// input adapter
     InputAdapterType ia;
 
@@ -3100,19 +2483,6 @@ scan_number_done:
     /// that unget() can restore the column instead of leaving it at 0
     std::size_t chars_read_before_newline = 0;
 
-    /// seekable adapter: what get_position() counted last, so that the next
-    /// call only scans the input consumed since
-    struct position_cache_t
-    {
-        /// consumed characters scanned so far
-        std::size_t consumed = 0;
-        /// newlines among them
-        std::size_t lines = 0;
-        /// index after the last of these newlines
-        std::size_t line_start = 0;
-    };
-    mutable position_cache_t position_cache {};
-
     /// raw input token string for error messages; only populated for streaming
     /// adapters (seekable adapters reconstruct it lazily via token_string_start)
     std::vector<char_type> token_string {};
@@ -3133,15 +2503,6 @@ scan_number_done:
     /// a description of occurred lexer errors
     const char* error_message = "";
 
-    /// what kind of token scan() rejected; set together with error_message
-    error_kind error_cause = error_kind::other;
-    /// how recover_token() continues a string that scan_string() rejected;
-    /// set only on the error paths that need more than error_message
-    resume_kind string_error_resume = resume_kind::character;
-    /// the code point of the second escape when a high surrogate is followed
-    /// by an escape that is not a low surrogate; -1 otherwise
-    int string_error_codepoint = -1;
-
     // number values
     number_integer_t value_integer = 0;
     number_unsigned_t value_unsigned = 0;

include/nlohmann/detail/input/parser.hpp

@@ -153,72 +153,25 @@ class parser
     bool accept(const bool strict = true)
     {
         json_sax_acceptor<BasicJsonType> sax_acceptor;
-        return sax_parse_impl<false>(&sax_acceptor, strict);
+        return sax_parse(&sax_acceptor, strict);
     }
 
-    /*!
-    @brief public SAX interface
-
-    If the SAX parser's parse_error() returns true, the parser recovers from
-    the error: it repairs the input and continues (see #3989).
-
-    @param[in] sax     the SAX parser
-    @param[in] strict  whether to expect the last token to be EOF
-    @return whether the input was parsed without errors and no SAX event
-            returned false
-    */
     template<typename SAX>
     JSON_HEDLEY_NON_NULL(2)
     bool sax_parse(SAX* sax, const bool strict = true)
-    {
-        return sax_parse_impl<true>(sax, strict);
-    }
-
-  private:
-    /// what sax_parse_internal() does after an object key was expected
-    enum class next_step : std::uint8_t
-    {
-        /// stop parsing
-        stop,
-        /// parse a value that begins with last_token
-        parse_value,
-        /// evaluate the state of the innermost container, which reads
-        /// last_token again
-        evaluate_state
-    };
-
-    template<bool AllowRecovery, typename SAX>
-    JSON_HEDLEY_NON_NULL(2)
-    bool sax_parse_impl(SAX* sax, const bool strict)
     {
         (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
-        const bool result = sax_parse_internal<AllowRecovery>(sax);
+        const bool result = sax_parse_internal(sax);
 
         if (result)
         {
-            if (strict)
-            {
-                // strict mode: next byte must be EOF; after recovering from an
-                // error, the end of the input may already have been read
-                if (last_token != token_type::end_of_input && get_token() != token_type::end_of_input)
-                {
-                    // the value is complete, so there is nothing to recover
-                    static_cast<void>(report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr),
-                                                   std::integral_constant<bool, AllowRecovery> {}));
-                    return false;
-                }
-            }
-            else
-            {
-                // the caller keeps using the input: position it right after
-                // the value by leaving the character that terminated it
-                m_lexer.release_lookahead();
-            }
+            return finish_input(*sax, strict);
         }
 
-        return result && !error_reported;
+        return false;
     }
 
+  private:
     /// the text of the current float token for @a sax (see sax_ignores_number_text)
     template<typename SAX>
     const string_t& number_float_text(SAX* /*sax*/)
@@ -286,26 +239,17 @@ class parser
     template<typename DomSax>
     bool parse_dom(DomSax& sdp, const bool strict)
     {
-        sax_parse_internal<false>(&sdp);
+        sax_parse_internal(&sdp);
 
         static_cast<void>(finish_input(sdp, strict));
 
         return !sdp.is_errored();
     }
 
-    /*!
-    @brief parse a JSON value and pass it to a SAX parser
-
-    @tparam AllowRecovery  whether to recover from an error if the SAX parser's
-                           parse_error() returns true; false for the SAX parsers
-                           of parse() and accept(), which never do, so that no
-                           code for recovering is generated for them
-    */
-    template<bool AllowRecovery, typename SAX>
+    template<typename SAX>
     JSON_HEDLEY_NON_NULL(2)
     bool sax_parse_internal(SAX* sax)
     {
-        const std::integral_constant<bool, AllowRecovery> allow_recovery{};
         // value to avoid a goto (see comment where set to true)
         bool skip_to_state_evaluation = false;
 
@@ -344,18 +288,10 @@ class parser
                             break;
                         }
 
-                        // remember we are now inside an object
-                        states.push_back(0);
-
-                        // parse key (the steps of parse_key(), which are
-                        // repeated here and below for speed)
+                        // parse key
                         if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                         {
-                            if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
-                            {
-                                return false;
-                            }
-                            continue;
+                            return syntax_error(*sax, exception_message(token_type::value_string, "object key"));
                         }
                         if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string_token())))
                         {
@@ -365,13 +301,12 @@ class parser
                         // parse separator (:)
                         if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                         {
-                            if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
-                            {
-                                return false;
-                            }
-                            continue;
+                            return syntax_error(*sax, exception_message(token_type::name_separator, "object separator"));
                         }
 
+                        // remember we are now inside an object
+                        states.push_back(0);
+
                         // parse values
                         get_token();
                         continue;
@@ -407,11 +342,9 @@ class parser
 
                         if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
                         {
-                            if (!overflow_error(sax, res, allow_recovery))
-                            {
-                                return false;
-                            }
-                            break;
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
                         }
 
                         if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, number_float_text(sax))))
@@ -479,63 +412,16 @@ class parser
                     case token_type::parse_error:
                     {
                         // using "uninitialized" to avoid an "expected" message
-                        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr), allow_recovery))
-                        {
-                            return false;
-                        }
-
-                        // recover: keep what can be read of the token
-                        recover_token(allow_recovery);
-                        if (last_token != token_type::uninitialized)
-                        {
-                            // a string or a number
-                            continue;
-                        }
-                        if (states.empty())
-                        {
-                            // look for the value after the garbage
-                            if (!skip_to_value(allow_recovery))
-                            {
-                                return false;
-                            }
-                            continue;
-                        }
-                        // nothing could be read
-                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
-                        {
-                            return false;
-                        }
-                        break;
+                        return syntax_error(*sax, exception_message(token_type::uninitialized, "value"));
                     }
                     case token_type::end_of_input:
                     {
                         if (JSON_HEDLEY_UNLIKELY(m_lexer.get_chars_read_total() == 1))
                         {
-                            // there is nothing to recover
-                            static_cast<void>(report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(),
-                                                           empty_input_message(), nullptr), allow_recovery));
-                            return false;
+                            return syntax_error(*sax, empty_input_message());
                         }
 
-                        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
-                        {
-                            return false;
-                        }
-
-                        // recover: the input ends where a value is missing
-                        if (states.empty())
-                        {
-                            // there is no value
-                            return false;
-                        }
-                        if (!recover_missing_value(sax, states, allow_recovery))
-                        {
-                            return false;
-                        }
-                        // the state evaluation reads the token again
-                        unget_token(allow_recovery);
-                        skip_to_state_evaluation = true;
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::literal_or_value, "value"));
                     }
                     case token_type::uninitialized:
                     case token_type::end_array:
@@ -545,35 +431,7 @@ class parser
                     case token_type::literal_or_value:
                     default: // the last token was unexpected
                     {
-                        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
-                        {
-                            return false;
-                        }
-
-                        // recover
-                        if (states.empty())
-                        {
-                            // look for the value after the garbage
-                            if (!skip_to_value(allow_recovery))
-                            {
-                                return false;
-                            }
-                            continue;
-                        }
-                        if (last_token == token_type::name_separator)
-                        {
-                            // a stray ':'; the value may follow
-                            get_token();
-                            continue;
-                        }
-                        if (!recover_missing_value(sax, states, allow_recovery))
-                        {
-                            return false;
-                        }
-                        // the state evaluation reads the token again
-                        unget_token(allow_recovery);
-                        skip_to_state_evaluation = true;
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::literal_or_value, "value"));
                     }
                 }
             }
@@ -624,30 +482,7 @@ class parser
                     continue;
                 }
 
-                if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr), allow_recovery))
-                {
-                    return false;
-                }
-
-                // recover
-                if (last_token == token_type::end_of_input)
-                {
-                    // the input ends inside the array
-                    return close_containers(sax, states, allow_recovery);
-                }
-                if (last_token == token_type::end_object)
-                {
-                    // a wrong closing bracket closes the innermost container
-                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
-                    {
-                        return false;
-                    }
-                    states.pop_back();
-                    skip_to_state_evaluation = true;
-                }
-                // otherwise, a missing ',' (or a stray ':', which value
-                // parsing drops): the next value begins here
-                continue;
+                return syntax_error(*sax, exception_message(token_type::end_array, "array"));
             }
 
             // states.back() is false -> object
@@ -664,12 +499,9 @@ class parser
                     // parse key
                     if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                     {
-                        if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
-                        {
-                            return false;
-                        }
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::value_string, "object key"));
                     }
+
                     if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string_token())))
                     {
                         return false;
@@ -678,11 +510,7 @@ class parser
                     // parse separator (:)
                     if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                     {
-                        if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
-                        {
-                            return false;
-                        }
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::name_separator, "object separator"));
                     }
 
                     // parse values
@@ -710,546 +538,10 @@ class parser
                 continue;
             }
 
-            if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr), allow_recovery))
-            {
-                return false;
-            }
-
-            // recover
-            if (last_token == token_type::end_of_input)
-            {
-                // the input ends inside the object
-                return close_containers(sax, states, allow_recovery);
-            }
-            if (last_token == token_type::end_array)
-            {
-                // a wrong closing bracket closes the innermost container
-                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
-                {
-                    return false;
-                }
-                states.pop_back();
-                skip_to_state_evaluation = true;
-                continue;
-            }
-            if (!continue_after(recover_member(sax, allow_recovery), skip_to_state_evaluation))
-            {
-                return false;
-            }
+            return syntax_error(*sax, exception_message(token_type::end_object, "object"));
         }
     }
 
-    /*!
-    @brief continue sax_parse_internal() after a recovery
-    @return whether to continue parsing
-    */
-    bool continue_after(const next_step step, bool& skip_to_state_evaluation)
-    {
-        if (step == next_step::evaluate_state)
-        {
-            // the state evaluation reads the token again
-            m_lexer.unget_token();
-            skip_to_state_evaluation = true;
-        }
-        return step != next_step::stop;
-    }
-
-    /// the parser for parse() and accept() never recovers: stop parsing
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type continue_after(std::false_type /*step*/, bool& /*skip_to_state_evaluation*/) noexcept
-    {
-        return {};
-    }
-
-    /*!
-    @brief parse an object key and the name separator (:) after it
-
-    last_token is the token where the key is expected. sax_parse_internal()
-    repeats these steps rather than calling this function, which is used
-    when recovering from an error.
-
-    @return next_step::parse_value if the value follows, with last_token its
-            first token; next_step::evaluate_state if the object's state is
-            to be evaluated after recovering from an error; next_step::stop
-            to stop parsing
-    */
-    template<typename SAX>
-    next_step parse_key(SAX* sax)
-    {
-        const std::true_type allow_recovery{};
-
-        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
-        {
-            return key_error(sax, allow_recovery, false);
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string_token())))
-        {
-            return next_step::stop;
-        }
-
-        // parse separator (:)
-        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
-        {
-            return key_error(sax, allow_recovery, true);
-        }
-
-        // the value begins with the next token
-        get_token();
-        return next_step::parse_value;
-    }
-
-    /*!
-    @brief report a number that is too large for number_float_t, and recover
-           from the error by passing the value on; the SAX parser gets the
-           number's text as well
-
-    This is a separate function, as reading other numbers is measurably
-    slower if the error is handled where they are read.
-
-    @param[in] sax    the SAX parser
-    @param[in] value  the value that is not finite
-    @return whether to continue parsing
-    */
-    template<typename SAX>
-    bool overflow_error(SAX* sax, const number_float_t value, std::true_type allow_recovery)
-    {
-        if (!report_error(sax, out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr), allow_recovery))
-        {
-            return false;
-        }
-        return sax->number_float(value, number_float_text(sax));
-    }
-
-    /// @copydoc overflow_error
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type overflow_error(SAX* sax, const number_float_t /*value*/, std::false_type allow_recovery)
-    {
-        return report_error(sax, out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr), allow_recovery);
-    }
-
-    /*!
-    @brief report a missing key, or a missing name separator (:) after the
-           key; the parser for parse() and accept() never recovers
-
-    @param[in] key_read  whether the key was read, so that the name separator
-                         is missing
-    @return std::false_type, see report_error()
-    */
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type key_error(SAX* sax, std::false_type allow_recovery, const bool key_read)
-    {
-        return report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), key_read
-                            ? exception_message(token_type::name_separator, "object separator")
-                            : exception_message(token_type::value_string, "object key"), nullptr), allow_recovery);
-    }
-
-    /*!
-    @brief report a missing key, or a missing name separator (:) after the
-           key, and recover from it
-
-    @param[in] key_read  whether the key was read, so that the name separator
-                         is missing
-    */
-    template<typename SAX>
-    next_step key_error(SAX* sax, std::true_type allow_recovery, const bool key_read)
-    {
-        if (!key_read)
-        {
-            if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr), allow_recovery))
-            {
-                return next_step::stop;
-            }
-            return recover_key(sax);
-        }
-
-        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr), allow_recovery))
-        {
-            return next_step::stop;
-        }
-        return recover_name_separator(sax);
-    }
-
-    /////////////////////
-    // error recovery
-    /////////////////////
-
-    /*
-    The functions below repair an error after the SAX parser's parse_error()
-    returned true (see #3989). Each mistake is repaired by the smallest local
-    edit: a missing ',' or ':' is inserted, a stray token is removed, what can
-    be read of an invalid string or number is kept (see
-    lexer::recover_token()), a missing value becomes null, a wrong closing
-    bracket closes the innermost container, and the end of the input closes
-    all of them. The events stay balanced, and every key() is followed by
-    exactly one value.
-
-    A repair hands a token to the state evaluation, by returning it to the
-    lexer (lexer::unget_token()) so that the state evaluation reads it again,
-    only if it is ',', ']', '}', or the end of the input. The state evaluation
-    hands a token to value or key parsing only if it is none of them, so a
-    token is never handed back and forth. Every other step reads a token or
-    closes a container, so parsing always ends.
-    */
-
-    /*!
-    @brief report an error to the SAX parser; the parser for parse() and
-           accept() never recovers
-
-    @return std::false_type rather than false: its value is known where the
-            function is called even if the call is not inlined, so the code
-            for recovering is not generated
-    */
-    template<typename SAX, typename Exception>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type report_error(SAX* sax, const Exception& ex, std::false_type /*allow_recovery*/)
-    {
-        static_cast<void>(sax); // MSVC 2015 does not count calling a static parse_error() as using it
-        error_reported = true;
-        static_cast<void>(sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex));
-        return {};
-    }
-
-    /*!
-    @brief report an error to the SAX parser
-    @return whether to recover from the error
-    */
-    template<typename SAX, typename Exception>
-    bool report_error(SAX* sax, const Exception& ex, std::true_type /*allow_recovery*/)
-    {
-        static_cast<void>(sax); // MSVC 2015 does not count calling a static parse_error() as using it
-        const std::size_t position = m_lexer.get_position().chars_read_total;
-        if (error_reported && position == last_error_position && last_token == last_error_token)
-        {
-            // a repair handed on the token of the error it repaired; the
-            // token was reported already, and the SAX parser asked to recover
-            return true;
-        }
-
-        error_reported = true;
-        last_error_position = position;
-        last_error_token = last_token;
-
-        if (!sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex))
-        {
-            return false;
-        }
-
-        // the token string of the next error begins here
-        m_lexer.restart_token_string();
-        return true;
-    }
-
-    /*!
-    @brief keep what can be read of the token that the lexer rejected
-
-    The error was reported for the rejected token, so it is not reported again
-    for the token it is repaired to (see lexer::recover_token()).
-    */
-    token_type recover_token()
-    {
-        last_token = m_lexer.recover_token();
-        last_error_position = m_lexer.get_position().chars_read_total;
-        last_error_token = last_token;
-        return last_token;
-    }
-
-    // The functions below are called from sax_parse_internal() after an error
-    // was reported. The parser for parse() and accept() stopped there, so for
-    // it they are stubs: the code for recovering is then not even referenced,
-    // and unoptimized builds do not emit it either.
-
-    /// @copydoc recover_token()
-    JSON_INTERNAL_ALWAYS_INLINE
-    token_type recover_token(std::true_type /*allow_recovery*/)
-    {
-        return recover_token();
-    }
-
-    /// @copydoc recover_token()
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type recover_token(std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /// return the token that was read last to the lexer (see lexer::unget_token())
-    JSON_INTERNAL_ALWAYS_INLINE
-    void unget_token(std::true_type /*allow_recovery*/)
-    {
-        m_lexer.unget_token();
-    }
-
-    /// @copydoc unget_token(std::true_type)
-    JSON_INTERNAL_ALWAYS_INLINE
-    static void unget_token(std::false_type /*allow_recovery*/) noexcept {}
-
-    /// @copydoc skip_to_value
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type skip_to_value(std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /// @copydoc recover_missing_value
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type recover_missing_value(SAX* /*sax*/, const std::vector<std::uint8_t>& /*states*/, std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /// pass the end events of all open containers
-    template<typename SAX>
-    bool close_containers(SAX* sax, std::vector<std::uint8_t>& states, std::true_type /*allow_recovery*/)
-    {
-        while (!states.empty())
-        {
-            const bool is_array = states.back() != 0;
-            states.pop_back();
-            if (JSON_HEDLEY_UNLIKELY(is_array ? !sax->end_array() : !sax->end_object()))
-            {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /// @copydoc close_containers
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type close_containers(SAX* /*sax*/, std::vector<std::uint8_t>& /*states*/, std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /*!
-    @brief read tokens until one begins a value, skipping everything before
-           the top-level value
-    @return whether a value begins with last_token
-    */
-    bool skip_to_value(std::true_type /*allow_recovery*/)
-    {
-        while (true)
-        {
-            switch (get_token())
-            {
-                case token_type::begin_array:
-                case token_type::begin_object:
-                case token_type::literal_false:
-                case token_type::literal_null:
-                case token_type::literal_true:
-                case token_type::value_float:
-                case token_type::value_integer:
-                case token_type::value_string:
-                case token_type::value_unsigned:
-                    return true;
-
-                case token_type::end_of_input:
-                    return false;
-
-                case token_type::parse_error:
-                    recover_token();
-                    if (last_token != token_type::uninitialized)
-                    {
-                        return true;
-                    }
-                    break;
-
-                case token_type::uninitialized:
-                case token_type::end_array:
-                case token_type::end_object:
-                case token_type::name_separator:
-                case token_type::value_separator:
-                case token_type::literal_or_value:
-                default:
-                    break;
-            }
-        }
-    }
-
-    /*!
-    @brief skip the rest of an object member that cannot be read
-
-    Reads tokens, beginning with last_token, until a ',', '}', or ']' that is
-    not inside a container that begins in the skipped tokens, or the end of
-    the input.
-    */
-    void skip_member()
-    {
-        std::size_t depth = 0;
-        while (true)
-        {
-            switch (last_token)
-            {
-                case token_type::begin_array:
-                case token_type::begin_object:
-                    ++depth;
-                    break;
-
-                case token_type::end_array:
-                case token_type::end_object:
-                    if (depth == 0)
-                    {
-                        return;
-                    }
-                    --depth;
-                    break;
-
-                case token_type::value_separator:
-                    if (depth == 0)
-                    {
-                        return;
-                    }
-                    break;
-
-                case token_type::end_of_input:
-                    return;
-
-                case token_type::parse_error:
-                    recover_token();
-                    break;
-
-                case token_type::uninitialized:
-                case token_type::literal_true:
-                case token_type::literal_false:
-                case token_type::literal_null:
-                case token_type::value_string:
-                case token_type::value_unsigned:
-                case token_type::value_integer:
-                case token_type::value_float:
-                case token_type::name_separator:
-                case token_type::literal_or_value:
-                default:
-                    break;
-            }
-            get_token();
-        }
-    }
-
-    /*!
-    @brief pass a value where it is missing
-
-    last_token is ',', ']', '}', or the end of the input, where a value was
-    expected. In an object, the key gets null; in an array, a ',' where a
-    value is missing stands for null (as in JavaScript), while an array that
-    ends there just ends.
-    */
-    template<typename SAX>
-    bool recover_missing_value(SAX* sax, const std::vector<std::uint8_t>& states, std::true_type /*allow_recovery*/)
-    {
-        JSON_ASSERT(!states.empty());
-        if (states.back() == 0 || last_token == token_type::value_separator)
-        {
-            return sax->null();
-        }
-        return true;
-    }
-
-    /// recover from a missing key; last_token is where it was expected
-    template<typename SAX>
-    next_step recover_key(SAX* sax)
-    {
-        switch (last_token)
-        {
-            case token_type::value_separator:
-            case token_type::end_object:
-            case token_type::end_array:
-            case token_type::end_of_input:
-                // no member: the object's state handles the token
-                return next_step::evaluate_state;
-
-            case token_type::parse_error:
-                recover_token();
-                if (last_token == token_type::value_string)
-                {
-                    // a key that could be repaired
-                    return parse_key(sax);
-                }
-                skip_member();
-                return next_step::evaluate_state;
-
-            case token_type::uninitialized:
-            case token_type::literal_true:
-            case token_type::literal_false:
-            case token_type::literal_null:
-            case token_type::value_string:
-            case token_type::value_unsigned:
-            case token_type::value_integer:
-            case token_type::value_float:
-            case token_type::begin_array:
-            case token_type::begin_object:
-            case token_type::name_separator:
-            case token_type::literal_or_value:
-            default:
-                // a member without a key
-                skip_member();
-                return next_step::evaluate_state;
-        }
-    }
-
-    /// recover from a missing name separator (:) after the key; last_token
-    /// is where it was expected
-    template<typename SAX>
-    next_step recover_name_separator(SAX* sax)
-    {
-        switch (last_token)
-        {
-            case token_type::value_separator:
-            case token_type::end_object:
-            case token_type::end_array:
-            case token_type::end_of_input:
-                // the value is missing as well
-                return sax->null() ? next_step::evaluate_state : next_step::stop;
-
-            case token_type::uninitialized:
-            case token_type::literal_true:
-            case token_type::literal_false:
-            case token_type::literal_null:
-            case token_type::value_string:
-            case token_type::value_unsigned:
-            case token_type::value_integer:
-            case token_type::value_float:
-            case token_type::begin_array:
-            case token_type::begin_object:
-            case token_type::name_separator:
-            case token_type::parse_error:
-            case token_type::literal_or_value:
-            default:
-                // a missing ':'; the value begins here
-                return next_step::parse_value;
-        }
-    }
-
-    /// recover from a token after an object member that is neither ',' nor
-    /// '}' (nor ']' or the end of the input, which the caller handles)
-    template<typename SAX>
-    next_step recover_member(SAX* sax, std::true_type /*allow_recovery*/)
-    {
-        if (last_token == token_type::parse_error)
-        {
-            recover_token();
-        }
-        if (last_token == token_type::value_string)
-        {
-            // a missing ','; the next key begins here
-            return parse_key(sax);
-        }
-        skip_member();
-        return next_step::evaluate_state;
-    }
-
-    /// the parser for parse() and accept() never recovers (and does not come
-    /// here, as report_error() returned false)
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type recover_member(SAX* /*sax*/, std::false_type /*allow_recovery*/) const noexcept
-    {
-        return {};
-    }
-
     /// get next token from lexer
     token_type get_token()
     {
@@ -1320,12 +612,6 @@ class parser
     const bool allow_exceptions = true;
     /// whether trailing commas in objects and arrays should be ignored (true) or signaled as errors (false)
     const bool ignore_trailing_commas = false;
-    /// whether an error was reported to the SAX parser
-    bool error_reported = false;
-    /// the position of the last reported error
-    std::size_t last_error_position = 0;
-    /// the token of the last reported error
-    token_type last_error_token = token_type::uninitialized;
 };
 
 }  // namespace detail

include/nlohmann/detail/macro_scope.hpp

@@ -215,17 +215,6 @@
     #define JSON_NO_UNIQUE_ADDRESS
 #endif
 
-// Inlines small functions even in unoptimized builds, so that they are not
-// emitted. The parsers for parse(), accept(), and from_*() use it for the
-// functions that stand in for the code recovering from errors (see #3989).
-// MSVC is left to decide, as it warns (C4714) where it does not inline a
-// __forceinline function.
-#if defined(_MSC_VER) && !defined(__clang__)
-    #define JSON_INTERNAL_ALWAYS_INLINE
-#else
-    #define JSON_INTERNAL_ALWAYS_INLINE JSON_HEDLEY_ALWAYS_INLINE
-#endif
-
 // Clang targeting MinGW does not survive the thread_local storage the copy
 // constructor uses to bound its descent: every test that copies a value
 // segfaults with clang 11.0.1 and clang 18.1.8, while the same tests pass with
@@ -302,15 +291,17 @@
         });                                                                                     \
         j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
     }                                                                                           \
-    template<typename BasicJsonType>                                                            \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json_or_view<BasicJsonType>::value, int> = 0> \
     inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
     {                                                                                           \
         /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
         static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        /* (for a view, the table holds basic_json values, which compare with the view) */      \
+        using nlohmann_json_value_t = nlohmann::detail::json_type_of_t<BasicJsonType>;          \
         /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
-        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        static const std::pair<ENUM_TYPE, nlohmann_json_value_t> m[] = __VA_ARGS__;             \
         auto it = std::find_if(std::begin(m), std::end(m),                                      \
-                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+                               [&j](const std::pair<ENUM_TYPE, nlohmann_json_value_t>& ej_pair) -> bool \
         {                                                                                       \
             return ej_pair.second == j;                                                         \
         });                                                                                     \
@@ -341,20 +332,22 @@
         if (it != std::end(m)) j = it->second;                                                  \
         else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range,"enum value out of range for " #ENUM_TYPE, nullptr)); \
     }                                                                                           \
-    template<typename BasicJsonType>                                                            \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json_or_view<BasicJsonType>::value, int> = 0> \
     inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
     {                                                                                           \
         /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
         static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        /* (for a view, the table holds basic_json values, which compare with the view) */      \
+        using nlohmann_json_value_t = nlohmann::detail::json_type_of_t<BasicJsonType>;          \
         /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
-        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        static const std::pair<ENUM_TYPE, nlohmann_json_value_t> m[] = __VA_ARGS__;             \
         auto it = std::find_if(std::begin(m), std::end(m),                                      \
-                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+                               [&j](const std::pair<ENUM_TYPE, nlohmann_json_value_t>& ej_pair) -> bool \
         {                                                                                       \
             return ej_pair.second == j;                                                         \
         });                                                                                     \
         if (it != std::end(m)) e = it->first;                                                   \
-        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range, nlohmann::detail::concat("enum value out of range for " #ENUM_TYPE ": ", j.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace)), &j)); \
+        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range, nlohmann::detail::concat("enum value out of range for " #ENUM_TYPE ": ", nlohmann::detail::from_json_dump(j)), nlohmann::detail::exception_context(j))); \
     }
 
 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
@@ -614,6 +607,8 @@
 #define NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME(v1, v2) nlohmann_json_t.v2 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(v1, nlohmann_json_default_obj.v2) : nlohmann_json_default_obj.v2;
 
 #define NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(...) template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> __VA_ARGS__
+// from_json() also reads from the views of <nlohmann/json_view.hpp>
+#define NLOHMANN_JSON_FROM_TYPE_TEMPLATE(...) template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json_or_view<BasicJsonType>::value, int> = 0> __VA_ARGS__
 
 // Helpers used to dispatch the NLOHMANN_DEFINE_TYPE_*/NLOHMANN_DEFINE_DERIVED_TYPE_*
 // macros below between a zero-member and a one-or-more-member implementation
@@ -666,18 +661,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_MEMBERS(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
 
 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY(Type)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
     /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType&, Type&) noexcept { })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType&, Type&) noexcept { })
 
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_TYPE_BODY(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))
 
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro
@@ -687,7 +682,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
 
 // identical to NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_EMPTY(Type) NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY(Type)
@@ -696,7 +691,7 @@
 
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro
@@ -723,18 +718,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_MEMBERS(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
 
 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY(Type)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
     /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType&, Type&) noexcept { })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType&, Type&) noexcept { })
 
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_TYPE_BODY(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))
 
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro
@@ -744,7 +739,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
 
 // identical to NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_EMPTY(Type) NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY(Type)
@@ -753,7 +748,7 @@
 
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro
@@ -780,18 +775,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_MEMBERS(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
 
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY(Type, BaseType)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
     /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
 
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DERIVED_TYPE_BODY(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))
 
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro
@@ -801,7 +796,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
 
 // identical to NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_EMPTY(Type, BaseType) NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY(Type, BaseType)
@@ -810,7 +805,7 @@
 
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro
@@ -838,18 +833,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_MEMBERS(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
 
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY(Type, BaseType)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
     /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
 
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DERIVED_TYPE_BODY(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))
 
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro
@@ -859,7 +854,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
 
 // identical to NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_EMPTY(Type, BaseType) NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY(Type, BaseType)
@@ -868,7 +863,7 @@
 
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
     NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
 
 /*!
 @brief macro

include/nlohmann/detail/macro_unscope.hpp

@@ -19,7 +19,6 @@
 #undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
 #undef JSON_INLINE_VARIABLE
 #undef JSON_NO_UNIQUE_ADDRESS
-#undef JSON_INTERNAL_ALWAYS_INLINE
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
 #undef JSON_UNLOCKED_FILE_IO

include/nlohmann/detail/meta/type_traits.hpp

@@ -340,6 +340,47 @@ template<class B> struct negation : std::integral_constant < bool, !B::value > {
 
 #endif
 
+///////////////////////
+// json_view helpers //
+///////////////////////
+
+template<typename T>
+using basic_json_type_t = typename T::basic_json_type;
+
+template<typename T>
+using materialize_function_t = decltype(std::declval<const T&>().materialize());
+
+// a basic_json_view of <nlohmann/json_view.hpp> (detected by its member type
+// basic_json_type, a basic_json, and materialize() returning that type, so that
+// json.hpp needs no declaration of the view)
+template<typename T, typename = void>
+struct is_json_view : std::false_type {};
+
+template<typename T>
+struct is_json_view<T, enable_if_t<is_basic_json<detected_t<basic_json_type_t, T>>::value>>
+    : std::is_same<detected_t<materialize_function_t, T>, basic_json_type_t<T>> {};
+
+// the types from_json() functions of the NLOHMANN_DEFINE_TYPE_* and
+// NLOHMANN_JSON_SERIALIZE_ENUM macros read from
+template<typename T>
+struct is_basic_json_or_view : disjunction<is_basic_json<T>, is_json_view<T>> {};
+
+// the basic_json type of a basic_json value or of a view
+template<typename T, typename = void>
+struct json_type_of
+{
+    using type = T;
+};
+
+template<typename T>
+struct json_type_of<T, enable_if_t<is_json_view<T>::value>>
+{
+    using type = typename T::basic_json_type;
+};
+
+template<typename T>
+using json_type_of_t = typename json_type_of<T>::type;
+
 // Reimplementation of is_constructible and is_default_constructible, due to them being broken for
 // std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
 // This causes compile errors in e.g., Clang 3.5 or GCC 4.9.

include/nlohmann/detail/string_utils.hpp

@@ -13,7 +13,6 @@
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <string> // string, to_string
-#include <utility> // move
 
 #include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/macro_scope.hpp>

include/nlohmann/detail/view/builder.hpp

@@ -978,7 +978,7 @@ indent_done:
             std::memcpy(reinterpret_cast<unsigned char*>(n), &first, 8);
             std::memcpy(reinterpret_cast<unsigned char*>(n) + 8, &second, 8);
 #else
-            n->kind = static_cast<std::uint8_t>(k);
+            n->kind = static_cast<node_kind>(k);
             n->flags = flags;
             n->extra = extra;
             n->off = static_cast<std::uint32_t>(off);

include/nlohmann/detail/view/document_data.hpp

@@ -232,7 +232,7 @@ struct document_data
     /// following loads.
     static NLOHMANN_VIEW_ALWAYS_INLINE const node* deref(const node* n) noexcept
     {
-        return NLOHMANN_VIEW_LIKELY(n->kind != kind_link) ? n : follow_link(n);
+        return NLOHMANN_VIEW_LIKELY(n->kind != node_kind::link) ? n : follow_link(n);
     }
 
     static NLOHMANN_VIEW_NOINLINE const node* follow_link(const node* n) noexcept

include/nlohmann/detail/view/edit.hpp

@@ -26,12 +26,10 @@
 #include <nlohmann/detail/view/lookup.hpp>
 #include <nlohmann/detail/view/macro_scope.hpp>
 #include <nlohmann/detail/view/node.hpp>
+#include <nlohmann/detail/view/view_mode.hpp>
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 
-template<typename BasicJsonType, bool Editable>
-class basic_json_view;
-
 namespace detail
 {
 namespace view
@@ -120,13 +118,13 @@ class editor
     View set(const View& object, string_view_t key, V&& value)
     {
         node* const o = own(object);
-        if (o->kind != static_cast<std::uint8_t>(value_t::object) && o->kind != static_cast<std::uint8_t>(value_t::null))
+        if (o->kind != node_kind::object && o->kind != node_kind::null)
         {
             throw_type_error(exception_id::subscript_wrong_type, "cannot use operator[] with a string argument with ", object.type_name());
         }
         check_utf8(key.data(), key.size());
         const encoded e = encode(std::forward<V>(value));
-        if (o->kind == static_cast<std::uint8_t>(value_t::null))
+        if (o->kind == node_kind::null)
         {
             become_empty(o, value_t::object);
         }
@@ -171,7 +169,7 @@ class editor
     View set(const View& array, std::size_t idx, V&& value)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array))
+        if (a->kind != node_kind::array)
         {
             throw_type_error(exception_id::subscript_wrong_type, "cannot use operator[] with a numeric argument with ", array.type_name());
         }
@@ -188,12 +186,12 @@ class editor
     View push_back(const View& array, V&& value)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array) && a->kind != static_cast<std::uint8_t>(value_t::null))
+        if (a->kind != node_kind::array && a->kind != node_kind::null)
         {
             throw_type_error(exception_id::push_back_wrong_type, "cannot use push_back() with ", array.type_name());
         }
         const encoded e = encode(std::forward<V>(value));
-        if (a->kind == static_cast<std::uint8_t>(value_t::null))
+        if (a->kind == node_kind::null)
         {
             become_empty(a, value_t::array);
         }
@@ -212,7 +210,7 @@ class editor
     View insert(const View& array, std::size_t idx, V&& value)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array))
+        if (a->kind != node_kind::array)
         {
             throw_type_error(exception_id::insert_wrong_type, "cannot use insert() with ", array.type_name());
         }
@@ -232,7 +230,7 @@ class editor
     std::size_t erase(const View& object, string_view_t key)
     {
         node* const o = own(object);
-        if (o->kind != static_cast<std::uint8_t>(value_t::object))
+        if (o->kind != node_kind::object)
         {
             throw_type_error(exception_id::erase_wrong_type, "cannot use erase() with ", object.type_name());
         }
@@ -250,7 +248,7 @@ class editor
     void erase(const View& array, std::size_t idx)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array))
+        if (a->kind != node_kind::array)
         {
             throw_type_error(exception_id::erase_wrong_type, "cannot use erase() with ", array.type_name());
         }
@@ -328,7 +326,7 @@ class editor
     {
         const std::uint8_t linked = n->flags & node_flags::linked;
         *n = node{};
-        n->kind = static_cast<std::uint8_t>(k);
+        n->kind = static_cast<node_kind>(k);
         n->flags = static_cast<std::uint8_t>(node_flags::is_new | linked);
         n->next = 1;
     }
@@ -405,8 +403,8 @@ class editor
     template<typename T>
     struct is_view : std::false_type {};
 
-    template<typename J, bool E>
-    struct is_view<basic_json_view<J, E>> : std::true_type {};
+    template<typename J, view_mode M>
+    struct is_view<basic_json_view<J, M>> : std::true_type {};
 
     template<typename V>
     encoded encode(V&& v)
@@ -421,8 +419,8 @@ class editor
     }
 
     /// a view of any document (copied; nothing is shared with it)
-    template<typename J, bool E>
-    encoded encode_impl(const basic_json_view<J, E>& v, encode_tag<0> /*view*/)
+    template<typename J, view_mode M>
+    encoded encode_impl(const basic_json_view<J, M>& v, encode_tag<0> /*view*/)
     {
         if (NLOHMANN_VIEW_UNLIKELY(v.m_node == nullptr))
         {
@@ -434,8 +432,8 @@ class editor
             r.scalar = copy_scalar(*v.m_doc, *v.m_node);
             return r;
         }
-        r.region = alloc_nodes(m_doc, count_nodes<E>(*v.m_doc, v.m_node));
-        fill_nodes<E>(*v.m_doc, v.m_node, r.region);
+        r.region = alloc_nodes(m_doc, count_nodes<M == view_mode::editable>(*v.m_doc, v.m_node));
+        fill_nodes<M == view_mode::editable>(*v.m_doc, v.m_node, r.region);
         edit_state_of(m_doc).regions.emplace(r.region, nullptr);
         return r;
     }
@@ -496,7 +494,7 @@ class editor
     static node plain_node(value_t k) noexcept
     {
         node n{};
-        n.kind = static_cast<std::uint8_t>(k);
+        n.kind = static_cast<node_kind>(k);
         n.flags = node_flags::is_new;
         return n;
     }
@@ -681,7 +679,7 @@ class editor
             ++r;
             if (is_container(*n))
             {
-                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == static_cast<std::uint8_t>(value_t::object)});
+                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == node_kind::object});
             }
             // the next value: close finished containers, then step over the key
             for (;;)
@@ -730,7 +728,7 @@ class editor
                 node* const self = out++;
                 *self = plain_node(static_cast<value_t>(n->kind));
                 self->len = n->len;
-                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == static_cast<std::uint8_t>(value_t::object), self});
+                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == node_kind::object, self});
             }
             else
             {

include/nlohmann/detail/view/edit_storage.hpp

@@ -27,7 +27,7 @@
 // live in chunks that never move; strings and number tokens written by edits
 // live in the edit arena. An array/object whose elements change gets
 // node_flags::moved: its elements then live in a separate sequence (a header
-// node, then the entries), whose entries link to the values (kind_link).
+// node, then the entries), whose entries link to the values (node_kind::link).
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -185,7 +185,7 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
         return nh;
     }
     reserve_moved(d); // (so that set_moved() below cannot throw: the links are marked before)
-    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+    const bool object = n->kind == node_kind::object;
     const std::size_t used = 1 + (static_cast<std::size_t>(n->len) * (object ? 2 : 1));
     const std::size_t cap = used + extra;
     node* const h = alloc_nodes(d, cap);
@@ -251,7 +251,7 @@ inline node* find_parent(const document_data& d, const node* target)
         {
             return nullptr; // LCOV_EXCL_LINE (the value is inside c)
         }
-        const bool object = c->kind == static_cast<std::uint8_t>(value_t::object);
+        const bool object = c->kind == node_kind::object;
         const node* down = nullptr;
         for (const node* p = d.first_child_edited(c), *e = d.child_end_edited(c); p != e;)
         {

include/nlohmann/detail/view/errors.hpp

@@ -144,21 +144,11 @@ struct throwing_sax
 
     /// (a template, as in json_sax_dom_parser: the parser passes the concrete
     /// exception type, which is thrown as is)
-    ///
-    /// It is not [[noreturn]]: sax_parse() recovers from an error if
-    /// parse_error() returns true, and MSVC reports that code as unreachable
-    /// (C4702) for a handler that never returns. The flag hides that from it.
     template<class Exception>
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const Exception& ex)
+    [[noreturn]] bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const Exception& ex)
     {
-        if (throwing)
-        {
-            NLOHMANN_VIEW_THROW(ex);
-        }
-        return false; // LCOV_EXCL_LINE
+        NLOHMANN_VIEW_THROW(ex);
     }
-
-    bool throwing = true;
 };
 
 /*!

include/nlohmann/detail/view/image.hpp

@@ -117,7 +117,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
                 r.off = (v->flags & (node_flags::moved | node_flags::is_new)) != 0 ? 0 : v->off;
                 r.len = 0;  // counted below
                 r.next = 0; // set when the container is complete
-                stack.push_back(frame{d.first_child_edited(v), d.child_end_edited(v), out.size(), 0, v->kind == static_cast<std::uint8_t>(value_t::object)});
+                stack.push_back(frame{d.first_child_edited(v), d.child_end_edited(v), out.size(), 0, v->kind == node_kind::object});
                 break;
             case value_t::string:
                 r = string_node(*v);
@@ -138,7 +138,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
                     if (t[0] == 'n' || t[0] == 'i' || (v->len > 1 && t[1] == 'i'))
                     {
                         r = node{}; // nan and infinity: null, as dump() writes them
-                        r.kind = static_cast<std::uint8_t>(value_t::null);
+                        r.kind = node_kind::null;
                         break;
                     }
                     r.off = static_cast<std::uint32_t>(d.size + text_tail.size());
@@ -182,12 +182,10 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
     }
 }
 
+#if NLOHMANN_VIEW_LITTLE_ENDIAN // (the image format is little-endian: no save() elsewhere)
 /// the document as an image
 inline std::vector<std::uint8_t> save_image(const document_data& d)
 {
-#if !NLOHMANN_VIEW_LITTLE_ENDIAN
-    throw_type_error(exception_id::document_image_unsupported, "json_document images need a little-endian target"); // LCOV_EXCL_LINE
-#endif
     const std::size_t arena_size = d.arena_size;
     std::vector<node> compacted;
     std::string text_tail;
@@ -221,7 +219,7 @@ inline std::vector<std::uint8_t> save_image(const document_data& d)
     // extra of an object, and the same document saves to the same bytes
     for (std::size_t i = 0; i < count; ++i)
     {
-        if (nodes[i].kind == static_cast<std::uint8_t>(value_t::object) && nodes[i].extra != 0)
+        if (nodes[i].kind == node_kind::object && nodes[i].extra != 0)
         {
             std::memset(o + (i * sizeof(node)) + offsetof(node, extra), 0, sizeof(nodes[i].extra));
         }
@@ -243,6 +241,7 @@ inline std::vector<std::uint8_t> save_image(const document_data& d)
     *o = 0;
     return image;
 }
+#endif
 
 /// the parts of a number token that the checks need
 struct number_token
@@ -337,7 +336,7 @@ inline bool float_token_finite(const unsigned char* s, std::size_t len, const nu
     if (static_cast<std::int64_t>(t.int_digits) + t.exponent > 300)
     {
         node n{};
-        n.kind = static_cast<std::uint8_t>(value_t::number_float);
+        n.kind = node_kind::number_float;
         n.len = static_cast<std::uint32_t>(len);
         const auto v = float_value<double>(reinterpret_cast<const char*>(s), n); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
         return v <= (std::numeric_limits<double>::max)() && v >= -(std::numeric_limits<double>::max)();
@@ -358,7 +357,7 @@ inline bool check_integer(const node& n, const unsigned char* text)
     }
     // the token's value is the stored one; number_integer nodes of edits can
     // be non-negative (as basic_json keeps the type of a value)
-    const bool integer = n.kind == static_cast<std::uint8_t>(value_t::number_integer);
+    const bool integer = n.kind == node_kind::number_integer;
     if (t.is_float || t.int_digits > 20 || (t.negative && !integer))
     {
         return false;
@@ -540,7 +539,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
         {
             return false;
         }
-        if (n.kind != static_cast<std::uint8_t>(value_t::number_float))
+        if (n.kind != node_kind::number_float)
         {
             return (n.extra >> 8u) == 0;
         }
@@ -581,7 +580,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
         const node& n = nodes[i];
         if (!stack.empty() && stack.back().object && stack.back().expect_key)
         {
-            if (n.kind != static_cast<std::uint8_t>(value_t::string) || !check_string(n))
+            if (n.kind != node_kind::string || !check_string(n))
             {
                 return false;
             }
@@ -622,7 +621,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
                 {
                     // (the contents of float tokens are checked later; the token of an
                     // integer has at most 256 characters)
-                    if (n.kind == static_cast<std::uint8_t>(value_t::number_float))
+                    if (n.kind == node_kind::number_float)
                     {
                         floats.push_back(float_range{n.off, n.len, n.extra});
                     }
@@ -640,7 +639,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
                 {
                     return false;
                 }
-                stack.push_back(frame{i + n.next, n.len, 0, n.kind == static_cast<std::uint8_t>(value_t::object), true});
+                stack.push_back(frame{i + n.next, n.len, 0, n.kind == node_kind::object, true});
                 complete = false;
                 break;
             }
@@ -663,13 +662,11 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
     throw_parse_error(exception_id::invalid_document_image, concat("invalid json_document image: ", what));
 }
 
+#if NLOHMANN_VIEW_LITTLE_ENDIAN // (the image format is little-endian: no load() elsewhere)
 /// Read an image into d. The text and the decoded strings stay in the image;
 /// the nodes are copied (so that they are aligned, and edits can change them).
 inline void load_image(document_data& d, const std::uint8_t* image, std::size_t size, image_check check)
 {
-#if !NLOHMANN_VIEW_LITTLE_ENDIAN
-    throw_type_error(exception_id::document_image_unsupported, "json_document images need a little-endian target"); // LCOV_EXCL_LINE
-#endif
     if (image == nullptr || size < sizeof(image_header))
     {
         throw_invalid_image("too short");
@@ -729,7 +726,7 @@ inline void load_image(document_data& d, const std::uint8_t* image, std::size_t
     for (std::size_t i = 0; i < count; ++i)
     {
         const node& n = d.nodes[i];
-        if (n.kind == static_cast<std::uint8_t>(value_t::object) && n.len >= document_data::index_min_members)
+        if (n.kind == node_kind::object && n.len >= document_data::index_min_members)
         {
             d.large_objects.push_back(static_cast<std::uint32_t>(i));
         }
@@ -738,6 +735,7 @@ inline void load_image(document_data& d, const std::uint8_t* image, std::size_t
     std::vector<std::uint32_t>().swap(d.large_objects); // (only needed while building)
     d.discarded = false;
 }
+#endif
 
 }  // namespace view
 }  // namespace detail

include/nlohmann/detail/view/lookup.hpp

@@ -182,7 +182,7 @@ const node* element_at(const document_data& d, const node* array, std::size_t id
 template<bool Editable>
 const node* last_child(const document_data& d, const node* container) noexcept
 {
-    const std::size_t value_offset = container->kind == static_cast<std::uint8_t>(value_t::object) ? 1 : 0;
+    const std::size_t value_offset = container->kind == node_kind::object ? 1 : 0;
     const node* const end = navigation<Editable>::end(d, container);
     const node* last = navigation<Editable>::first(d, container);
     if (value_offset == 0 && container->next == container->len + 1u && (!navigation<Editable>::editable() || (container->flags & node_flags::moved) == 0))

include/nlohmann/detail/view/materialize.hpp

@@ -101,7 +101,7 @@ BasicJsonType materialize(const document_data& d, const node* n)
             case value_t::object:
             case value_t::array:
             {
-                const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                const bool object = n->kind == node_kind::object;
                 if (object)
                 {
                     sax.start_object(n->len);

include/nlohmann/detail/view/node.hpp

@@ -41,9 +41,21 @@ struct node_flags
     static constexpr std::uint8_t linked = 32; ///< an entry of a moved sequence links to this value (editable documents): its extent in the parsed layout no longer matters
 };
 
-/// kind of an entry of an edited sequence that stands for a value stored
-/// elsewhere (the address of the value's node is kept in the len/next bytes)
-constexpr std::uint8_t kind_link = 10;
+/// the kind of a node: the value_t of its value, or link
+enum class node_kind : std::uint8_t
+{
+    null = static_cast<std::uint8_t>(value_t::null),
+    object = static_cast<std::uint8_t>(value_t::object),
+    array = static_cast<std::uint8_t>(value_t::array),
+    string = static_cast<std::uint8_t>(value_t::string),
+    boolean = static_cast<std::uint8_t>(value_t::boolean),
+    number_integer = static_cast<std::uint8_t>(value_t::number_integer),
+    number_unsigned = static_cast<std::uint8_t>(value_t::number_unsigned),
+    number_float = static_cast<std::uint8_t>(value_t::number_float),
+    /// an entry of an edited sequence that stands for a value stored elsewhere
+    /// (the address of the value's node is kept in the len/next bytes)
+    link = static_cast<std::uint8_t>(value_t::discarded) + 1,
+};
 
 /// One entry of the flat index, in document order. An object's members are
 /// stored as key node followed by the value's subtree. Integers keep their
@@ -51,7 +63,7 @@ constexpr std::uint8_t kind_link = 10;
 /// always the next one, and the token length follows from `extra`).
 struct node
 {
-    std::uint8_t kind;   ///< value_t, or kind_link
+    node_kind kind;      ///< value_t, or 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 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
@@ -60,8 +72,9 @@ struct node
 };
 static_assert(sizeof(node) == 16, "node must stay 16 bytes");
 
-// the node kinds are value_t values; the test below (object and array are 1
-// and 2) and those of the number kinds depend on this numbering
+// the node kinds are value_t values, and images store them as bytes; the test
+// below (object and array are 1 and 2) and those of the number kinds depend
+// on this numbering
 static_assert(static_cast<std::uint8_t>(value_t::null) == 0 && static_cast<std::uint8_t>(value_t::object) == 1
               && static_cast<std::uint8_t>(value_t::array) == 2 && static_cast<std::uint8_t>(value_t::string) == 3
               && static_cast<std::uint8_t>(value_t::boolean) == 4 && static_cast<std::uint8_t>(value_t::number_integer) == 5
@@ -86,7 +99,7 @@ inline void make_link(node& n, node* target) noexcept
 {
     target->flags = static_cast<std::uint8_t>(target->flags | node_flags::linked);
     n = node{};
-    n.kind = kind_link;
+    n.kind = node_kind::link;
     std::memcpy(reinterpret_cast<unsigned char*>(&n) + 8, static_cast<const void*>(&target), sizeof(const node*)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
@@ -116,8 +129,8 @@ NLOHMANN_VIEW_ALWAYS_INLINE void set_integer_bits(node& n, std::uint64_t v) noex
 /// token length of a number node
 NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t number_length(const node& n) noexcept
 {
-    return n.kind == static_cast<std::uint8_t>(value_t::number_float) ? n.len
-           : (n.extra & 0xFFu) + (n.kind == static_cast<std::uint8_t>(value_t::number_integer) ? 1u : 0u);
+    return n.kind == node_kind::number_float ? n.len
+           : (n.extra & 0xFFu) + (n.kind == node_kind::number_integer ? 1u : 0u);
 }
 
 /// estimated number of nodes for an input of `size` bytes (one node per ~12

include/nlohmann/detail/view/serializer.hpp

@@ -874,7 +874,7 @@ class view_serializer
                 case value_t::object:
                 case value_t::array:
                 {
-                    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                    const bool object = n->kind == node_kind::object;
                     room(8);
                     if (n->len == 0)
                     {

include/nlohmann/detail/view/simd.hpp

@@ -24,25 +24,25 @@
 // with different flags would have different definitions of the same inline
 // functions): the check is compiled for SSSE3 with a function attribute and
 // used where the CPU has SSSE3 (all x86-64 CPUs since about 2011), else the
-// portable check. JSON_VIEW_USE_SSSE3 skips the CPU check (for code compiled
-// for SSSE3 anyway); JSON_VIEW_NO_SIMD selects the portable code.
+// portable check. Code compiled for SSSE3 anyway (-mssse3 or more) skips the
+// CPU check. JSON_NO_SIMD selects the portable code, as in the lexer.
 // NLOHMANN_VIEW_NO_TARGET_ATTRIBUTE (set by the GCC module interface, where GCC
 // ignores the target attribute and then rejects the SSSE3 intrinsics) keeps the
 // check portable without disabling the SSE2 code.
-#if !defined(JSON_VIEW_NO_SIMD) && defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__)) && NLOHMANN_VIEW_LITTLE_ENDIAN
+#if !defined(JSON_NO_SIMD) && defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__)) && NLOHMANN_VIEW_LITTLE_ENDIAN
     #include <arm_neon.h>
     #define NLOHMANN_VIEW_NEON 1
 #else
     #define NLOHMANN_VIEW_NEON 0
 #endif
 // (x86 only: other targets can define __SSE2__ as well, e.g., WebAssembly with -msse2, but have no <cpuid.h>)
-#if !defined(JSON_VIEW_NO_SIMD) && !NLOHMANN_VIEW_NEON && (defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)) && (defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2))
+#if !defined(JSON_NO_SIMD) && !NLOHMANN_VIEW_NEON && (defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)) && (defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2))
     #include <emmintrin.h>
     #define NLOHMANN_VIEW_SSE2 1
 #else
     #define NLOHMANN_VIEW_SSE2 0
 #endif
-#if NLOHMANN_VIEW_SSE2 && defined(JSON_VIEW_USE_SSSE3)
+#if NLOHMANN_VIEW_SSE2 && defined(__SSSE3__)
     #include <tmmintrin.h>
     #define NLOHMANN_VIEW_SSSE3 1 // NOLINT(cppcoreguidelines-macro-to-enum,modernize-macro-to-enum)
 #else

include/nlohmann/detail/view/value.hpp

@@ -130,14 +130,16 @@ struct is_direct_value : std::integral_constant < bool,
 template<typename Traits, typename Alloc, typename BasicJsonType, typename View>
 struct is_direct_value<std::basic_string<char, Traits, Alloc>, BasicJsonType, View> : std::true_type {};
 
+// (vectors of these, which are faster than through from_json(), and containers
+// of views; other containers are read by the library's from_json())
 template<typename U, typename A, typename BasicJsonType, typename View>
-struct is_direct_value<std::vector<U, A>, BasicJsonType, View> : std::true_type {};
+struct is_direct_value<std::vector<U, A>, BasicJsonType, View> : is_direct_value<U, BasicJsonType, View> {};
 
-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 C, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::map<K, View, 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> {};
+template<typename K, typename H, typename E, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::unordered_map<K, View, H, E, A>, BasicJsonType, View> : is_string_key<K> {};
 
 }  // namespace view
 }  // namespace detail

include/nlohmann/detail/view/view_mode.hpp

@@ -0,0 +1,27 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstdint> // uint8_t
+
+#include <nlohmann/json.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// whether a basic_json_document and its views can be edited
+enum class view_mode : std::uint8_t
+{
+    read_only, ///< parsed once, then only read (the default)
+    editable,  ///< also has set(), push_back(), insert(), and erase()
+};
+
+template<typename BasicJsonType, view_mode Mode>
+class basic_json_view;
+
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/json.hpp

@@ -157,7 +157,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     friend class ::nlohmann::detail::iter_impl;
     template<typename BasicJsonType, typename CharType, typename OutputSinkType>
     friend class ::nlohmann::detail::binary_writer;
-    template<typename BasicJsonType, typename InputType, typename SAX, bool AllowRecovery>
+    template<typename BasicJsonType, typename InputType, typename SAX>
     friend class ::nlohmann::detail::binary_reader;
     template<typename BasicJsonType, typename InputAdapterType, bool Collect>
     friend class ::nlohmann::detail::json_sax_dom_parser;
@@ -3133,8 +3133,7 @@ public:
         {
             return parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict);
         }
-        // the SAX parser may recover from errors (see parse_error())
-        return detail::binary_reader<basic_json, InputAdapterType, SAX, true>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
+        return detail::binary_reader<basic_json, InputAdapterType, SAX>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
     }
 
     /// serialize @a j into a new vector; @a write receives the vector-backed writer

include/nlohmann/json_view.hpp

@@ -84,6 +84,7 @@
 #include <nlohmann/detail/view/serializer.hpp>
 #include <nlohmann/detail/view/string_ref.hpp>
 #include <nlohmann/detail/view/value.hpp>
+#include <nlohmann/detail/view/view_mode.hpp>
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 
@@ -93,15 +94,20 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
 Trivially copyable (two pointers). Valid as long as the document is alive and
 has not been re-parsed, and as long as a borrowed source text is alive.
 */
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_view
 {
+    /// whether this is a view of an editable document
+    static constexpr bool is_editable = Mode == view_mode::editable;
+
     using node = detail::view::node;
     using document_data = detail::view::document_data;
     /// how the index is walked (with edits only for editable documents)
-    using navigation = detail::view::navigation<Editable>;
+    using navigation = detail::view::navigation<is_editable>;
 
   public:
+    /// the basic_json type of the document (it also marks views for is_json_view)
+    using basic_json_type = BasicJsonType;
     using value_t = detail::value_t;
     using string_t = typename BasicJsonType::string_t;
     using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -446,7 +452,7 @@ class basic_json_view
         if (is_structured() && m_node->len != 0)
         {
             return unedited() ? basic_json_view(m_doc, detail::view::last_child<false>(*m_doc, m_node) + (is_object() ? 1 : 0))
-                   : basic_json_view(m_doc, navigation::value(detail::view::last_child<Editable>(*m_doc, m_node) + (is_object() ? 1 : 0)));
+                   : basic_json_view(m_doc, navigation::value(detail::view::last_child<is_editable>(*m_doc, m_node) + (is_object() ? 1 : 0)));
         }
         return front();
     }
@@ -504,7 +510,7 @@ class basic_json_view
     /// more than once); 0 if this is not an object
     size_type count(string_view_t key) const
     {
-        return is_object() ? detail::view::count_members<Editable>(*m_doc, m_node, key.data(), key.size()) : 0;
+        return is_object() ? detail::view::count_members<is_editable>(*m_doc, m_node, key.data(), key.size()) : 0;
     }
 
     size_type count(const char* key) const
@@ -563,8 +569,10 @@ class basic_json_view
 
     /// the value converted to T, as BasicJsonType::get<T>(): arithmetic types,
     /// strings (string_view_t without a copy), std::nullptr_t, std::vector,
-    /// maps with string keys, and views are converted directly; other types
-    /// through materialize().get<T>()
+    /// maps with string keys, and views are converted directly; types whose
+    /// from_json() accepts views (those of the NLOHMANN_DEFINE_TYPE_* and
+    /// NLOHMANN_JSON_SERIALIZE_ENUM macros, say) read the view; other types
+    /// go through materialize().get<T>()
     template<typename T>
     NLOHMANN_VIEW_ALWAYS_INLINE T get() const
     {
@@ -572,11 +580,12 @@ class basic_json_view
     }
 
     /// as BasicJsonType::get_to(): the types get<T>() converts directly are
-    /// assigned, all others are passed to from_json with v as it is
+    /// assigned, all others are passed to from_json with v as it is (with
+    /// the view if from_json() accepts views, else with materialize())
     template<typename T>
     T& get_to(T& v) const
     {
-        get_to_impl(v, detail::view::is_direct_value<T, BasicJsonType, basic_json_view> {});
+        get_to_impl(v, get_to_kind<T> {});
         return v;
     }
 
@@ -646,7 +655,7 @@ class basic_json_view
         }
         else
         {
-            detail::view::view_serializer<BasicJsonType, Editable>(*m_doc, out, estimate, style).dump(m_node);
+            detail::view::view_serializer<BasicJsonType, is_editable>(*m_doc, out, estimate, style).dump(m_node);
         }
         return out;
     }
@@ -682,14 +691,14 @@ class basic_json_view
     }
 
     /// a view of an editable document compares with one of a read-only document
-    template < bool E, typename std::enable_if < E != Editable, int >::type = 0 >
-    friend bool operator==(const basic_json_view& a, const basic_json_view<BasicJsonType, E>& b)
+    template < view_mode M, typename std::enable_if < M != Mode, int >::type = 0 >
+    friend bool operator==(const basic_json_view& a, const basic_json_view<BasicJsonType, M>& b)
     {
-        return detail::view::equal<BasicJsonType>(side(a), detail::view::view_side<BasicJsonType, basic_json_view<BasicJsonType, E>>(b));
+        return detail::view::equal<BasicJsonType>(side(a), detail::view::view_side<BasicJsonType, basic_json_view<BasicJsonType, M>>(b));
     }
 
-    template < bool E, typename std::enable_if < E != Editable, int >::type = 0 >
-    friend bool operator!=(const basic_json_view& a, const basic_json_view<BasicJsonType, E>& b)
+    template < view_mode M, typename std::enable_if < M != Mode, int >::type = 0 >
+    friend bool operator!=(const basic_json_view& a, const basic_json_view<BasicJsonType, M>& b)
     {
         return !(a == b);
     }
@@ -727,7 +736,7 @@ class basic_json_view
         {
             return BasicJsonType(value_t::discarded);
         }
-        return unedited() ? detail::view::materialize<BasicJsonType, false>(*m_doc, m_node) : detail::view::materialize<BasicJsonType, Editable>(*m_doc, m_node);
+        return unedited() ? detail::view::materialize<BasicJsonType, false>(*m_doc, m_node) : detail::view::materialize<BasicJsonType, is_editable>(*m_doc, m_node);
     }
 
     /// byte offset of this value in the source text (for strings: of the
@@ -740,8 +749,8 @@ class basic_json_view
     }
 
   private:
-    template<typename, bool> friend class basic_json_document;
-    template<typename, bool> friend class basic_json_view;
+    template<typename, view_mode> friend class basic_json_document;
+    template<typename, view_mode> friend class basic_json_view;
     template<typename, typename> friend class detail::view::editor;
     friend iterator;
 
@@ -757,11 +766,11 @@ class basic_json_view
     }
 
     /// the template argument as a runtime condition: testing it directly in
-    /// `Editable && ...` makes the condition constant, which MSVC reports as
+    /// `is_editable && ...` makes the condition constant, which MSVC reports as
     /// C4127
     static bool editable() noexcept
     {
-        return Editable;
+        return is_editable;
     }
 
     /// the number of source bytes of this value (estimated for values with
@@ -810,7 +819,7 @@ class basic_json_view
             const node* const k = detail::view::find_member<false>(*m_doc, m_node, key.data(), key.size());
             return k != nullptr ? basic_json_view(m_doc, k + 1) : basic_json_view();
         }
-        const node* const k = detail::view::find_member<Editable>(*m_doc, m_node, key.data(), key.size());
+        const node* const k = detail::view::find_member<is_editable>(*m_doc, m_node, key.data(), key.size());
         return k != nullptr ? basic_json_view(m_doc, navigation::value(k + 1)) : basic_json_view();
     }
 
@@ -824,7 +833,7 @@ class basic_json_view
     /// the member of this object with @a key (the last one if the key occurs more than once), or nullptr
     NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const
     {
-        return find_key(key, std::integral_constant<bool, Editable> {});
+        return find_key(key, std::integral_constant<bool, is_editable> {});
     }
 
     NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key, std::true_type /*editable*/) const
@@ -846,7 +855,7 @@ class basic_json_view
         {
             return basic_json_view(m_doc, detail::view::element_at<false>(*m_doc, m_node, idx));
         }
-        return basic_json_view(m_doc, navigation::value(detail::view::element_at<Editable>(*m_doc, m_node, idx)));
+        return basic_json_view(m_doc, navigation::value(detail::view::element_at<is_editable>(*m_doc, m_node, idx)));
     }
 
     // --- get() dispatch ---
@@ -901,22 +910,45 @@ class basic_json_view
         return *this;
     }
 
-    template<typename U, typename A>
+    /// vectors of the types converted directly (faster than the library's
+    /// from_json()) and containers of views (no from_json() reads them: a view
+    /// is no value of BasicJsonType); other containers are read by from_json()
+    template < typename U, typename A, typename std::enable_if < detail::view::is_direct_value<U, BasicJsonType, basic_json_view>::value, int >::type = 0 >
     std::vector<U, A> get_impl(detail::view::value_tag<std::vector<U, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
     {
         return detail::view::vector_value<basic_json_view, U, A>(*this);
     }
 
-    template<typename K, typename V, typename C, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
-    std::map<K, V, C, A> get_impl(detail::view::value_tag<std::map<K, V, C, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
+    template<typename K, typename C, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
+    std::map<K, basic_json_view, C, A> get_impl(detail::view::value_tag<std::map<K, basic_json_view, C, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
     {
-        return detail::view::map_value<std::map<K, V, C, A>>(*this);
+        return detail::view::map_value<std::map<K, basic_json_view, C, A>>(*this);
     }
 
-    template<typename K, typename V, typename H, typename E, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
-    std::unordered_map<K, V, H, E, A> get_impl(detail::view::value_tag<std::unordered_map<K, V, H, E, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
+    template<typename K, typename H, typename E, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
+    std::unordered_map<K, basic_json_view, H, E, A> get_impl(detail::view::value_tag<std::unordered_map<K, basic_json_view, H, E, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
     {
-        return detail::view::map_value<std::unordered_map<K, V, H, E, A>>(*this);
+        return detail::view::map_value<std::unordered_map<K, basic_json_view, H, E, A>>(*this);
+    }
+
+    /// whether the from_json() of T's serializer reads views (see
+    /// detail::has_view_from_json)
+    template<typename T>
+    using reads_view = detail::has_view_from_json<typename BasicJsonType::template json_serializer<T, void>, basic_json_view, T>;
+
+    /// how get_to() converts: 2 directly, 1 with a from_json() that reads
+    /// views, 0 through materialize()
+    template<typename T>
+    using get_to_kind = std::integral_constant < int, detail::view::is_direct_value<T, BasicJsonType, basic_json_view>::value
+                        ? 2 : static_cast<int>(reads_view<T>::value) >;
+
+    /// types whose from_json() reads views, without materialize()
+    template < typename T, typename std::enable_if < reads_view<T>::value && std::is_default_constructible<T>::value, int >::type = 0 >
+    T get_impl(detail::view::value_tag<T> /*unused*/, detail::priority_tag<1> /*unused*/) const
+    {
+        auto v = T();
+        BasicJsonType::template json_serializer<T, void>::from_json(*this, v);
+        return v;
     }
 
     /// everything else through the BasicJsonType value (from_json included)
@@ -929,14 +961,20 @@ class basic_json_view
     // --- get_to() dispatch ---
 
     template<typename T>
-    void get_to_impl(T& v, std::true_type /*direct*/) const
+    void get_to_impl(T& v, std::integral_constant<int, 2> /*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
+    void get_to_impl(T& v, std::integral_constant<int, 1> /*from_json reads views*/) const
+    {
+        BasicJsonType::template json_serializer<T, void>::from_json(*this, v);
+    }
+
+    template<typename T>
+    void get_to_impl(T& v, std::integral_constant<int, 0> /*through materialize()*/) const
     {
         materialize().get_to(v);
     }
@@ -952,16 +990,19 @@ Borrowed parses keep a pointer to the caller's text, which must outlive the
 document. Owned parses (parse_copy, rvalue std::string, streams, and inputs
 that are not contiguous byte ranges) keep their own copy.
 */
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_document
 {
+    /// whether the document can be edited
+    static constexpr bool is_editable = Mode == view_mode::editable;
+
     using document_data = detail::view::document_data;
 
     static_assert(sizeof(typename BasicJsonType::number_integer_t) == 8 && sizeof(typename BasicJsonType::number_unsigned_t) == 8,
                   "json_view supports 64-bit integer types only");
 
   public:
-    using view_type = basic_json_view<BasicJsonType, Editable>;
+    using view_type = basic_json_view<BasicJsonType, Mode>;
     using value_t = detail::value_t;
 
     /// an empty (discarded) document
@@ -1175,6 +1216,10 @@ class basic_json_document
     /// how load() checks an image (full, bounds, or none)
     using image_check = detail::view::image_check;
 
+#if NLOHMANN_VIEW_LITTLE_ENDIAN
+    // (the image format is little-endian: big-endian targets have no save()
+    // and load(), so that a call fails to compile instead of always throwing)
+
     /// The document as an image that load() reads without parsing: the node
     /// index, the text, and the decoded strings. An edited document is
     /// written in its current state (floats that are not finite become null,
@@ -1216,6 +1261,7 @@ class basic_json_document
         detail::view::load_image(*d.m_data, d.m_data->owned_image.data(), d.m_data->owned_image.size(), check);
         return d;
     }
+#endif
 
     ///////////
     // edits //
@@ -1357,7 +1403,7 @@ class basic_json_document
 
     detail::view::editor<BasicJsonType, view_type> editor()
     {
-        static_assert(Editable, "only an editable document can be edited: use basic_json_document<BasicJsonType, true> (json_editable_document)");
+        static_assert(is_editable, "only an editable document can be edited: use basic_json_document<BasicJsonType, view_mode::editable> (json_editable_document)");
         if (NLOHMANN_VIEW_UNLIKELY(!m_data || m_data->discarded))
         {
             detail::view::throw_invalid_iterator(detail::exception_id::iterator_from_other_value, "view does not belong to this document");
@@ -1633,6 +1679,15 @@ class basic_json_document
     std::unique_ptr<document_data, document_data::deleter> m_data{}; // NOLINT(readability-redundant-member-init)
 };
 
+/*!
+@brief whether T is a basic_json_view (of any BasicJsonType and view_mode)
+
+For constraining templates that accept views, e.g. a from_json() written for
+both basic_json values and views.
+*/
+template<typename T>
+struct is_json_view : detail::is_json_view<T> {};
+
 /// a parsed JSON text for json
 using json_document = basic_json_document<json>;
 /// a value of a json_document
@@ -1642,13 +1697,13 @@ using ordered_json_document = basic_json_document<ordered_json>;
 /// a value of an ordered_json_document
 using ordered_json_view = basic_json_view<ordered_json>;
 /// an editable parsed JSON text for json
-using json_editable_document = basic_json_document<json, true>;
+using json_editable_document = basic_json_document<json, view_mode::editable>;
 /// a value of a json_editable_document
-using json_editable_view = basic_json_view<json, true>;
+using json_editable_view = basic_json_view<json, view_mode::editable>;
 /// an editable parsed JSON text for ordered_json
-using ordered_json_editable_document = basic_json_document<ordered_json, true>;
+using ordered_json_editable_document = basic_json_document<ordered_json, view_mode::editable>;
 /// a value of an ordered_json_editable_document
-using ordered_json_editable_view = basic_json_view<ordered_json, true>;
+using ordered_json_editable_view = basic_json_view<ordered_json, view_mode::editable>;
 
 NLOHMANN_JSON_NAMESPACE_END
 

single_include/nlohmann/json_fwd.hpp

@@ -145,26 +145,14 @@
     #define NLOHMANN_JSON_ABI_TAG_NO_SIMD
 #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, i, j, k, l, m) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k ## l ## m
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k, l, m) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k, l, m)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -178,9 +166,7 @@
             NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS,       \
             NLOHMANN_JSON_ABI_TAG_DISABLE_STREAM_BULK_SCAN,          \
             NLOHMANN_JSON_ABI_TAG_DISABLE_UNLOCKED_FILE_IO,          \
-            NLOHMANN_JSON_ABI_TAG_NO_SIMD,                           \
-            NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD,                      \
-            NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3)
+            NLOHMANN_JSON_ABI_TAG_NO_SIMD)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

single_include/nlohmann/json_view.hpp

@@ -239,9 +239,21 @@ struct node_flags
     static constexpr std::uint8_t linked = 32; ///< an entry of a moved sequence links to this value (editable documents): its extent in the parsed layout no longer matters
 };
 
-/// kind of an entry of an edited sequence that stands for a value stored
-/// elsewhere (the address of the value's node is kept in the len/next bytes)
-constexpr std::uint8_t kind_link = 10;
+/// the kind of a node: the value_t of its value, or link
+enum class node_kind : std::uint8_t
+{
+    null = static_cast<std::uint8_t>(value_t::null),
+    object = static_cast<std::uint8_t>(value_t::object),
+    array = static_cast<std::uint8_t>(value_t::array),
+    string = static_cast<std::uint8_t>(value_t::string),
+    boolean = static_cast<std::uint8_t>(value_t::boolean),
+    number_integer = static_cast<std::uint8_t>(value_t::number_integer),
+    number_unsigned = static_cast<std::uint8_t>(value_t::number_unsigned),
+    number_float = static_cast<std::uint8_t>(value_t::number_float),
+    /// an entry of an edited sequence that stands for a value stored elsewhere
+    /// (the address of the value's node is kept in the len/next bytes)
+    link = static_cast<std::uint8_t>(value_t::discarded) + 1,
+};
 
 /// One entry of the flat index, in document order. An object's members are
 /// stored as key node followed by the value's subtree. Integers keep their
@@ -249,7 +261,7 @@ constexpr std::uint8_t kind_link = 10;
 /// always the next one, and the token length follows from `extra`).
 struct node
 {
-    std::uint8_t kind;   ///< value_t, or kind_link
+    node_kind kind;      ///< value_t, or 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 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
@@ -258,8 +270,9 @@ struct node
 };
 static_assert(sizeof(node) == 16, "node must stay 16 bytes");
 
-// the node kinds are value_t values; the test below (object and array are 1
-// and 2) and those of the number kinds depend on this numbering
+// the node kinds are value_t values, and images store them as bytes; the test
+// below (object and array are 1 and 2) and those of the number kinds depend
+// on this numbering
 static_assert(static_cast<std::uint8_t>(value_t::null) == 0 && static_cast<std::uint8_t>(value_t::object) == 1
               && static_cast<std::uint8_t>(value_t::array) == 2 && static_cast<std::uint8_t>(value_t::string) == 3
               && static_cast<std::uint8_t>(value_t::boolean) == 4 && static_cast<std::uint8_t>(value_t::number_integer) == 5
@@ -284,7 +297,7 @@ inline void make_link(node& n, node* target) noexcept
 {
     target->flags = static_cast<std::uint8_t>(target->flags | node_flags::linked);
     n = node{};
-    n.kind = kind_link;
+    n.kind = node_kind::link;
     std::memcpy(reinterpret_cast<unsigned char*>(&n) + 8, static_cast<const void*>(&target), sizeof(const node*)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
@@ -314,8 +327,8 @@ NLOHMANN_VIEW_ALWAYS_INLINE void set_integer_bits(node& n, std::uint64_t v) noex
 /// token length of a number node
 NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t number_length(const node& n) noexcept
 {
-    return n.kind == static_cast<std::uint8_t>(value_t::number_float) ? n.len
-           : (n.extra & 0xFFu) + (n.kind == static_cast<std::uint8_t>(value_t::number_integer) ? 1u : 0u);
+    return n.kind == node_kind::number_float ? n.len
+           : (n.extra & 0xFFu) + (n.kind == node_kind::number_integer ? 1u : 0u);
 }
 
 /// estimated number of nodes for an input of `size` bytes (one node per ~12
@@ -547,7 +560,7 @@ struct document_data
     /// following loads.
     static NLOHMANN_VIEW_ALWAYS_INLINE const node* deref(const node* n) noexcept
     {
-        return NLOHMANN_VIEW_LIKELY(n->kind != kind_link) ? n : follow_link(n);
+        return NLOHMANN_VIEW_LIKELY(n->kind != node_kind::link) ? n : follow_link(n);
     }
 
     static NLOHMANN_VIEW_NOINLINE const node* follow_link(const node* n) noexcept
@@ -665,25 +678,25 @@ NLOHMANN_JSON_NAMESPACE_END
 // with different flags would have different definitions of the same inline
 // functions): the check is compiled for SSSE3 with a function attribute and
 // used where the CPU has SSSE3 (all x86-64 CPUs since about 2011), else the
-// portable check. JSON_VIEW_USE_SSSE3 skips the CPU check (for code compiled
-// for SSSE3 anyway); JSON_VIEW_NO_SIMD selects the portable code.
+// portable check. Code compiled for SSSE3 anyway (-mssse3 or more) skips the
+// CPU check. JSON_NO_SIMD selects the portable code, as in the lexer.
 // NLOHMANN_VIEW_NO_TARGET_ATTRIBUTE (set by the GCC module interface, where GCC
 // ignores the target attribute and then rejects the SSSE3 intrinsics) keeps the
 // check portable without disabling the SSE2 code.
-#if !defined(JSON_VIEW_NO_SIMD) && defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__)) && NLOHMANN_VIEW_LITTLE_ENDIAN
+#if !defined(JSON_NO_SIMD) && defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__)) && NLOHMANN_VIEW_LITTLE_ENDIAN
     #include <arm_neon.h>
     #define NLOHMANN_VIEW_NEON 1
 #else
     #define NLOHMANN_VIEW_NEON 0
 #endif
 // (x86 only: other targets can define __SSE2__ as well, e.g., WebAssembly with -msse2, but have no <cpuid.h>)
-#if !defined(JSON_VIEW_NO_SIMD) && !NLOHMANN_VIEW_NEON && (defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)) && (defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2))
+#if !defined(JSON_NO_SIMD) && !NLOHMANN_VIEW_NEON && (defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)) && (defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2))
     #include <emmintrin.h>
     #define NLOHMANN_VIEW_SSE2 1
 #else
     #define NLOHMANN_VIEW_SSE2 0
 #endif
-#if NLOHMANN_VIEW_SSE2 && defined(JSON_VIEW_USE_SSSE3)
+#if NLOHMANN_VIEW_SSE2 && defined(__SSSE3__)
     #include <tmmintrin.h>
     #define NLOHMANN_VIEW_SSSE3 1 // NOLINT(cppcoreguidelines-macro-to-enum,modernize-macro-to-enum)
 #else
@@ -2169,7 +2182,7 @@ indent_done:
             std::memcpy(reinterpret_cast<unsigned char*>(n), &first, 8);
             std::memcpy(reinterpret_cast<unsigned char*>(n) + 8, &second, 8);
 #else
-            n->kind = static_cast<std::uint8_t>(k);
+            n->kind = static_cast<node_kind>(k);
             n->flags = flags;
             n->extra = extra;
             n->off = static_cast<std::uint32_t>(off);
@@ -2938,21 +2951,11 @@ struct throwing_sax
 
     /// (a template, as in json_sax_dom_parser: the parser passes the concrete
     /// exception type, which is thrown as is)
-    ///
-    /// It is not [[noreturn]]: sax_parse() recovers from an error if
-    /// parse_error() returns true, and MSVC reports that code as unreachable
-    /// (C4702) for a handler that never returns. The flag hides that from it.
     template<class Exception>
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const Exception& ex)
+    [[noreturn]] bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const Exception& ex)
     {
-        if (throwing)
-        {
-            NLOHMANN_VIEW_THROW(ex);
-        }
-        return false; // LCOV_EXCL_LINE
+        NLOHMANN_VIEW_THROW(ex);
     }
-
-    bool throwing = true;
 };
 
 /*!
@@ -3011,7 +3014,7 @@ NLOHMANN_JSON_NAMESPACE_END
 // live in chunks that never move; strings and number tokens written by edits
 // live in the edit arena. An array/object whose elements change gets
 // node_flags::moved: its elements then live in a separate sequence (a header
-// node, then the entries), whose entries link to the values (kind_link).
+// node, then the entries), whose entries link to the values (node_kind::link).
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -3169,7 +3172,7 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
         return nh;
     }
     reserve_moved(d); // (so that set_moved() below cannot throw: the links are marked before)
-    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+    const bool object = n->kind == node_kind::object;
     const std::size_t used = 1 + (static_cast<std::size_t>(n->len) * (object ? 2 : 1));
     const std::size_t cap = used + extra;
     node* const h = alloc_nodes(d, cap);
@@ -3235,7 +3238,7 @@ inline node* find_parent(const document_data& d, const node* target)
         {
             return nullptr; // LCOV_EXCL_LINE (the value is inside c)
         }
-        const bool object = c->kind == static_cast<std::uint8_t>(value_t::object);
+        const bool object = c->kind == node_kind::object;
         const node* down = nullptr;
         for (const node* p = d.first_child_edited(c), *e = d.child_end_edited(c); p != e;)
         {
@@ -3702,7 +3705,7 @@ const node* element_at(const document_data& d, const node* array, std::size_t id
 template<bool Editable>
 const node* last_child(const document_data& d, const node* container) noexcept
 {
-    const std::size_t value_offset = container->kind == static_cast<std::uint8_t>(value_t::object) ? 1 : 0;
+    const std::size_t value_offset = container->kind == node_kind::object ? 1 : 0;
     const node* const end = navigation<Editable>::end(d, container);
     const node* last = navigation<Editable>::first(d, container);
     if (value_offset == 0 && container->next == container->len + 1u && (!navigation<Editable>::editable() || (container->flags & node_flags::moved) == 0))
@@ -3724,12 +3727,38 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/view/node.hpp>
 
+// #include <nlohmann/detail/view/view_mode.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t
+
+// #include <nlohmann/json.hpp>
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 
-template<typename BasicJsonType, bool Editable>
+/// whether a basic_json_document and its views can be edited
+enum class view_mode : std::uint8_t
+{
+    read_only, ///< parsed once, then only read (the default)
+    editable,  ///< also has set(), push_back(), insert(), and erase()
+};
+
+template<typename BasicJsonType, view_mode Mode>
 class basic_json_view;
 
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
 namespace detail
 {
 namespace view
@@ -3818,13 +3847,13 @@ class editor
     View set(const View& object, string_view_t key, V&& value)
     {
         node* const o = own(object);
-        if (o->kind != static_cast<std::uint8_t>(value_t::object) && o->kind != static_cast<std::uint8_t>(value_t::null))
+        if (o->kind != node_kind::object && o->kind != node_kind::null)
         {
             throw_type_error(exception_id::subscript_wrong_type, "cannot use operator[] with a string argument with ", object.type_name());
         }
         check_utf8(key.data(), key.size());
         const encoded e = encode(std::forward<V>(value));
-        if (o->kind == static_cast<std::uint8_t>(value_t::null))
+        if (o->kind == node_kind::null)
         {
             become_empty(o, value_t::object);
         }
@@ -3869,7 +3898,7 @@ class editor
     View set(const View& array, std::size_t idx, V&& value)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array))
+        if (a->kind != node_kind::array)
         {
             throw_type_error(exception_id::subscript_wrong_type, "cannot use operator[] with a numeric argument with ", array.type_name());
         }
@@ -3886,12 +3915,12 @@ class editor
     View push_back(const View& array, V&& value)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array) && a->kind != static_cast<std::uint8_t>(value_t::null))
+        if (a->kind != node_kind::array && a->kind != node_kind::null)
         {
             throw_type_error(exception_id::push_back_wrong_type, "cannot use push_back() with ", array.type_name());
         }
         const encoded e = encode(std::forward<V>(value));
-        if (a->kind == static_cast<std::uint8_t>(value_t::null))
+        if (a->kind == node_kind::null)
         {
             become_empty(a, value_t::array);
         }
@@ -3910,7 +3939,7 @@ class editor
     View insert(const View& array, std::size_t idx, V&& value)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array))
+        if (a->kind != node_kind::array)
         {
             throw_type_error(exception_id::insert_wrong_type, "cannot use insert() with ", array.type_name());
         }
@@ -3930,7 +3959,7 @@ class editor
     std::size_t erase(const View& object, string_view_t key)
     {
         node* const o = own(object);
-        if (o->kind != static_cast<std::uint8_t>(value_t::object))
+        if (o->kind != node_kind::object)
         {
             throw_type_error(exception_id::erase_wrong_type, "cannot use erase() with ", object.type_name());
         }
@@ -3948,7 +3977,7 @@ class editor
     void erase(const View& array, std::size_t idx)
     {
         node* const a = own(array);
-        if (a->kind != static_cast<std::uint8_t>(value_t::array))
+        if (a->kind != node_kind::array)
         {
             throw_type_error(exception_id::erase_wrong_type, "cannot use erase() with ", array.type_name());
         }
@@ -4026,7 +4055,7 @@ class editor
     {
         const std::uint8_t linked = n->flags & node_flags::linked;
         *n = node{};
-        n->kind = static_cast<std::uint8_t>(k);
+        n->kind = static_cast<node_kind>(k);
         n->flags = static_cast<std::uint8_t>(node_flags::is_new | linked);
         n->next = 1;
     }
@@ -4103,8 +4132,8 @@ class editor
     template<typename T>
     struct is_view : std::false_type {};
 
-    template<typename J, bool E>
-    struct is_view<basic_json_view<J, E>> : std::true_type {};
+    template<typename J, view_mode M>
+    struct is_view<basic_json_view<J, M>> : std::true_type {};
 
     template<typename V>
     encoded encode(V&& v)
@@ -4119,8 +4148,8 @@ class editor
     }
 
     /// a view of any document (copied; nothing is shared with it)
-    template<typename J, bool E>
-    encoded encode_impl(const basic_json_view<J, E>& v, encode_tag<0> /*view*/)
+    template<typename J, view_mode M>
+    encoded encode_impl(const basic_json_view<J, M>& v, encode_tag<0> /*view*/)
     {
         if (NLOHMANN_VIEW_UNLIKELY(v.m_node == nullptr))
         {
@@ -4132,8 +4161,8 @@ class editor
             r.scalar = copy_scalar(*v.m_doc, *v.m_node);
             return r;
         }
-        r.region = alloc_nodes(m_doc, count_nodes<E>(*v.m_doc, v.m_node));
-        fill_nodes<E>(*v.m_doc, v.m_node, r.region);
+        r.region = alloc_nodes(m_doc, count_nodes<M == view_mode::editable>(*v.m_doc, v.m_node));
+        fill_nodes<M == view_mode::editable>(*v.m_doc, v.m_node, r.region);
         edit_state_of(m_doc).regions.emplace(r.region, nullptr);
         return r;
     }
@@ -4194,7 +4223,7 @@ class editor
     static node plain_node(value_t k) noexcept
     {
         node n{};
-        n.kind = static_cast<std::uint8_t>(k);
+        n.kind = static_cast<node_kind>(k);
         n.flags = node_flags::is_new;
         return n;
     }
@@ -4379,7 +4408,7 @@ class editor
             ++r;
             if (is_container(*n))
             {
-                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == static_cast<std::uint8_t>(value_t::object)});
+                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == node_kind::object});
             }
             // the next value: close finished containers, then step over the key
             for (;;)
@@ -4428,7 +4457,7 @@ class editor
                 node* const self = out++;
                 *self = plain_node(static_cast<value_t>(n->kind));
                 self->len = n->len;
-                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == static_cast<std::uint8_t>(value_t::object), self});
+                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == node_kind::object, self});
             }
             else
             {
@@ -4913,7 +4942,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
                 r.off = (v->flags & (node_flags::moved | node_flags::is_new)) != 0 ? 0 : v->off;
                 r.len = 0;  // counted below
                 r.next = 0; // set when the container is complete
-                stack.push_back(frame{d.first_child_edited(v), d.child_end_edited(v), out.size(), 0, v->kind == static_cast<std::uint8_t>(value_t::object)});
+                stack.push_back(frame{d.first_child_edited(v), d.child_end_edited(v), out.size(), 0, v->kind == node_kind::object});
                 break;
             case value_t::string:
                 r = string_node(*v);
@@ -4934,7 +4963,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
                     if (t[0] == 'n' || t[0] == 'i' || (v->len > 1 && t[1] == 'i'))
                     {
                         r = node{}; // nan and infinity: null, as dump() writes them
-                        r.kind = static_cast<std::uint8_t>(value_t::null);
+                        r.kind = node_kind::null;
                         break;
                     }
                     r.off = static_cast<std::uint32_t>(d.size + text_tail.size());
@@ -4978,12 +5007,10 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
     }
 }
 
+#if NLOHMANN_VIEW_LITTLE_ENDIAN // (the image format is little-endian: no save() elsewhere)
 /// the document as an image
 inline std::vector<std::uint8_t> save_image(const document_data& d)
 {
-#if !NLOHMANN_VIEW_LITTLE_ENDIAN
-    throw_type_error(exception_id::document_image_unsupported, "json_document images need a little-endian target"); // LCOV_EXCL_LINE
-#endif
     const std::size_t arena_size = d.arena_size;
     std::vector<node> compacted;
     std::string text_tail;
@@ -5017,7 +5044,7 @@ inline std::vector<std::uint8_t> save_image(const document_data& d)
     // extra of an object, and the same document saves to the same bytes
     for (std::size_t i = 0; i < count; ++i)
     {
-        if (nodes[i].kind == static_cast<std::uint8_t>(value_t::object) && nodes[i].extra != 0)
+        if (nodes[i].kind == node_kind::object && nodes[i].extra != 0)
         {
             std::memset(o + (i * sizeof(node)) + offsetof(node, extra), 0, sizeof(nodes[i].extra));
         }
@@ -5039,6 +5066,7 @@ inline std::vector<std::uint8_t> save_image(const document_data& d)
     *o = 0;
     return image;
 }
+#endif
 
 /// the parts of a number token that the checks need
 struct number_token
@@ -5133,7 +5161,7 @@ inline bool float_token_finite(const unsigned char* s, std::size_t len, const nu
     if (static_cast<std::int64_t>(t.int_digits) + t.exponent > 300)
     {
         node n{};
-        n.kind = static_cast<std::uint8_t>(value_t::number_float);
+        n.kind = node_kind::number_float;
         n.len = static_cast<std::uint32_t>(len);
         const auto v = float_value<double>(reinterpret_cast<const char*>(s), n); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
         return v <= (std::numeric_limits<double>::max)() && v >= -(std::numeric_limits<double>::max)();
@@ -5154,7 +5182,7 @@ inline bool check_integer(const node& n, const unsigned char* text)
     }
     // the token's value is the stored one; number_integer nodes of edits can
     // be non-negative (as basic_json keeps the type of a value)
-    const bool integer = n.kind == static_cast<std::uint8_t>(value_t::number_integer);
+    const bool integer = n.kind == node_kind::number_integer;
     if (t.is_float || t.int_digits > 20 || (t.negative && !integer))
     {
         return false;
@@ -5336,7 +5364,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
         {
             return false;
         }
-        if (n.kind != static_cast<std::uint8_t>(value_t::number_float))
+        if (n.kind != node_kind::number_float)
         {
             return (n.extra >> 8u) == 0;
         }
@@ -5377,7 +5405,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
         const node& n = nodes[i];
         if (!stack.empty() && stack.back().object && stack.back().expect_key)
         {
-            if (n.kind != static_cast<std::uint8_t>(value_t::string) || !check_string(n))
+            if (n.kind != node_kind::string || !check_string(n))
             {
                 return false;
             }
@@ -5418,7 +5446,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
                 {
                     // (the contents of float tokens are checked later; the token of an
                     // integer has at most 256 characters)
-                    if (n.kind == static_cast<std::uint8_t>(value_t::number_float))
+                    if (n.kind == node_kind::number_float)
                     {
                         floats.push_back(float_range{n.off, n.len, n.extra});
                     }
@@ -5436,7 +5464,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
                 {
                     return false;
                 }
-                stack.push_back(frame{i + n.next, n.len, 0, n.kind == static_cast<std::uint8_t>(value_t::object), true});
+                stack.push_back(frame{i + n.next, n.len, 0, n.kind == node_kind::object, true});
                 complete = false;
                 break;
             }
@@ -5459,13 +5487,11 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
     throw_parse_error(exception_id::invalid_document_image, concat("invalid json_document image: ", what));
 }
 
+#if NLOHMANN_VIEW_LITTLE_ENDIAN // (the image format is little-endian: no load() elsewhere)
 /// Read an image into d. The text and the decoded strings stay in the image;
 /// the nodes are copied (so that they are aligned, and edits can change them).
 inline void load_image(document_data& d, const std::uint8_t* image, std::size_t size, image_check check)
 {
-#if !NLOHMANN_VIEW_LITTLE_ENDIAN
-    throw_type_error(exception_id::document_image_unsupported, "json_document images need a little-endian target"); // LCOV_EXCL_LINE
-#endif
     if (image == nullptr || size < sizeof(image_header))
     {
         throw_invalid_image("too short");
@@ -5525,7 +5551,7 @@ inline void load_image(document_data& d, const std::uint8_t* image, std::size_t
     for (std::size_t i = 0; i < count; ++i)
     {
         const node& n = d.nodes[i];
-        if (n.kind == static_cast<std::uint8_t>(value_t::object) && n.len >= document_data::index_min_members)
+        if (n.kind == node_kind::object && n.len >= document_data::index_min_members)
         {
             d.large_objects.push_back(static_cast<std::uint32_t>(i));
         }
@@ -5534,6 +5560,7 @@ inline void load_image(document_data& d, const std::uint8_t* image, std::size_t
     std::vector<std::uint32_t>().swap(d.large_objects); // (only needed while building)
     d.discarded = false;
 }
+#endif
 
 }  // namespace view
 }  // namespace detail
@@ -6118,7 +6145,7 @@ BasicJsonType materialize(const document_data& d, const node* n)
             case value_t::object:
             case value_t::array:
             {
-                const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                const bool object = n->kind == node_kind::object;
                 if (object)
                 {
                     sax.start_object(n->len);
@@ -7232,7 +7259,7 @@ class view_serializer
                 case value_t::object:
                 case value_t::array:
                 {
-                    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                    const bool object = n->kind == node_kind::object;
                     room(8);
                     if (n->len == 0)
                     {
@@ -7770,19 +7797,23 @@ struct is_direct_value : std::integral_constant < bool,
 template<typename Traits, typename Alloc, typename BasicJsonType, typename View>
 struct is_direct_value<std::basic_string<char, Traits, Alloc>, BasicJsonType, View> : std::true_type {};
 
+// (vectors of these, which are faster than through from_json(), and containers
+// of views; other containers are read by the library's from_json())
 template<typename U, typename A, typename BasicJsonType, typename View>
-struct is_direct_value<std::vector<U, A>, BasicJsonType, View> : std::true_type {};
+struct is_direct_value<std::vector<U, A>, BasicJsonType, View> : is_direct_value<U, BasicJsonType, View> {};
 
-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 C, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::map<K, View, 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> {};
+template<typename K, typename H, typename E, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::unordered_map<K, View, H, E, A>, BasicJsonType, View> : is_string_key<K> {};
 
 }  // namespace view
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
+// #include <nlohmann/detail/view/view_mode.hpp>
+
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 
@@ -7792,15 +7823,20 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
 Trivially copyable (two pointers). Valid as long as the document is alive and
 has not been re-parsed, and as long as a borrowed source text is alive.
 */
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_view
 {
+    /// whether this is a view of an editable document
+    static constexpr bool is_editable = Mode == view_mode::editable;
+
     using node = detail::view::node;
     using document_data = detail::view::document_data;
     /// how the index is walked (with edits only for editable documents)
-    using navigation = detail::view::navigation<Editable>;
+    using navigation = detail::view::navigation<is_editable>;
 
   public:
+    /// the basic_json type of the document (it also marks views for is_json_view)
+    using basic_json_type = BasicJsonType;
     using value_t = detail::value_t;
     using string_t = typename BasicJsonType::string_t;
     using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -8145,7 +8181,7 @@ class basic_json_view
         if (is_structured() && m_node->len != 0)
         {
             return unedited() ? basic_json_view(m_doc, detail::view::last_child<false>(*m_doc, m_node) + (is_object() ? 1 : 0))
-                   : basic_json_view(m_doc, navigation::value(detail::view::last_child<Editable>(*m_doc, m_node) + (is_object() ? 1 : 0)));
+                   : basic_json_view(m_doc, navigation::value(detail::view::last_child<is_editable>(*m_doc, m_node) + (is_object() ? 1 : 0)));
         }
         return front();
     }
@@ -8203,7 +8239,7 @@ class basic_json_view
     /// more than once); 0 if this is not an object
     size_type count(string_view_t key) const
     {
-        return is_object() ? detail::view::count_members<Editable>(*m_doc, m_node, key.data(), key.size()) : 0;
+        return is_object() ? detail::view::count_members<is_editable>(*m_doc, m_node, key.data(), key.size()) : 0;
     }
 
     size_type count(const char* key) const
@@ -8262,8 +8298,10 @@ class basic_json_view
 
     /// the value converted to T, as BasicJsonType::get<T>(): arithmetic types,
     /// strings (string_view_t without a copy), std::nullptr_t, std::vector,
-    /// maps with string keys, and views are converted directly; other types
-    /// through materialize().get<T>()
+    /// maps with string keys, and views are converted directly; types whose
+    /// from_json() accepts views (those of the NLOHMANN_DEFINE_TYPE_* and
+    /// NLOHMANN_JSON_SERIALIZE_ENUM macros, say) read the view; other types
+    /// go through materialize().get<T>()
     template<typename T>
     NLOHMANN_VIEW_ALWAYS_INLINE T get() const
     {
@@ -8271,11 +8309,12 @@ class basic_json_view
     }
 
     /// as BasicJsonType::get_to(): the types get<T>() converts directly are
-    /// assigned, all others are passed to from_json with v as it is
+    /// assigned, all others are passed to from_json with v as it is (with
+    /// the view if from_json() accepts views, else with materialize())
     template<typename T>
     T& get_to(T& v) const
     {
-        get_to_impl(v, detail::view::is_direct_value<T, BasicJsonType, basic_json_view> {});
+        get_to_impl(v, get_to_kind<T> {});
         return v;
     }
 
@@ -8345,7 +8384,7 @@ class basic_json_view
         }
         else
         {
-            detail::view::view_serializer<BasicJsonType, Editable>(*m_doc, out, estimate, style).dump(m_node);
+            detail::view::view_serializer<BasicJsonType, is_editable>(*m_doc, out, estimate, style).dump(m_node);
         }
         return out;
     }
@@ -8381,14 +8420,14 @@ class basic_json_view
     }
 
     /// a view of an editable document compares with one of a read-only document
-    template < bool E, typename std::enable_if < E != Editable, int >::type = 0 >
-    friend bool operator==(const basic_json_view& a, const basic_json_view<BasicJsonType, E>& b)
+    template < view_mode M, typename std::enable_if < M != Mode, int >::type = 0 >
+    friend bool operator==(const basic_json_view& a, const basic_json_view<BasicJsonType, M>& b)
     {
-        return detail::view::equal<BasicJsonType>(side(a), detail::view::view_side<BasicJsonType, basic_json_view<BasicJsonType, E>>(b));
+        return detail::view::equal<BasicJsonType>(side(a), detail::view::view_side<BasicJsonType, basic_json_view<BasicJsonType, M>>(b));
     }
 
-    template < bool E, typename std::enable_if < E != Editable, int >::type = 0 >
-    friend bool operator!=(const basic_json_view& a, const basic_json_view<BasicJsonType, E>& b)
+    template < view_mode M, typename std::enable_if < M != Mode, int >::type = 0 >
+    friend bool operator!=(const basic_json_view& a, const basic_json_view<BasicJsonType, M>& b)
     {
         return !(a == b);
     }
@@ -8426,7 +8465,7 @@ class basic_json_view
         {
             return BasicJsonType(value_t::discarded);
         }
-        return unedited() ? detail::view::materialize<BasicJsonType, false>(*m_doc, m_node) : detail::view::materialize<BasicJsonType, Editable>(*m_doc, m_node);
+        return unedited() ? detail::view::materialize<BasicJsonType, false>(*m_doc, m_node) : detail::view::materialize<BasicJsonType, is_editable>(*m_doc, m_node);
     }
 
     /// byte offset of this value in the source text (for strings: of the
@@ -8439,8 +8478,8 @@ class basic_json_view
     }
 
   private:
-    template<typename, bool> friend class basic_json_document;
-    template<typename, bool> friend class basic_json_view;
+    template<typename, view_mode> friend class basic_json_document;
+    template<typename, view_mode> friend class basic_json_view;
     template<typename, typename> friend class detail::view::editor;
     friend iterator;
 
@@ -8456,11 +8495,11 @@ class basic_json_view
     }
 
     /// the template argument as a runtime condition: testing it directly in
-    /// `Editable && ...` makes the condition constant, which MSVC reports as
+    /// `is_editable && ...` makes the condition constant, which MSVC reports as
     /// C4127
     static bool editable() noexcept
     {
-        return Editable;
+        return is_editable;
     }
 
     /// the number of source bytes of this value (estimated for values with
@@ -8509,7 +8548,7 @@ class basic_json_view
             const node* const k = detail::view::find_member<false>(*m_doc, m_node, key.data(), key.size());
             return k != nullptr ? basic_json_view(m_doc, k + 1) : basic_json_view();
         }
-        const node* const k = detail::view::find_member<Editable>(*m_doc, m_node, key.data(), key.size());
+        const node* const k = detail::view::find_member<is_editable>(*m_doc, m_node, key.data(), key.size());
         return k != nullptr ? basic_json_view(m_doc, navigation::value(k + 1)) : basic_json_view();
     }
 
@@ -8523,7 +8562,7 @@ class basic_json_view
     /// the member of this object with @a key (the last one if the key occurs more than once), or nullptr
     NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const
     {
-        return find_key(key, std::integral_constant<bool, Editable> {});
+        return find_key(key, std::integral_constant<bool, is_editable> {});
     }
 
     NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key, std::true_type /*editable*/) const
@@ -8545,7 +8584,7 @@ class basic_json_view
         {
             return basic_json_view(m_doc, detail::view::element_at<false>(*m_doc, m_node, idx));
         }
-        return basic_json_view(m_doc, navigation::value(detail::view::element_at<Editable>(*m_doc, m_node, idx)));
+        return basic_json_view(m_doc, navigation::value(detail::view::element_at<is_editable>(*m_doc, m_node, idx)));
     }
 
     // --- get() dispatch ---
@@ -8600,22 +8639,45 @@ class basic_json_view
         return *this;
     }
 
-    template<typename U, typename A>
+    /// vectors of the types converted directly (faster than the library's
+    /// from_json()) and containers of views (no from_json() reads them: a view
+    /// is no value of BasicJsonType); other containers are read by from_json()
+    template < typename U, typename A, typename std::enable_if < detail::view::is_direct_value<U, BasicJsonType, basic_json_view>::value, int >::type = 0 >
     std::vector<U, A> get_impl(detail::view::value_tag<std::vector<U, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
     {
         return detail::view::vector_value<basic_json_view, U, A>(*this);
     }
 
-    template<typename K, typename V, typename C, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
-    std::map<K, V, C, A> get_impl(detail::view::value_tag<std::map<K, V, C, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
+    template<typename K, typename C, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
+    std::map<K, basic_json_view, C, A> get_impl(detail::view::value_tag<std::map<K, basic_json_view, C, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
     {
-        return detail::view::map_value<std::map<K, V, C, A>>(*this);
+        return detail::view::map_value<std::map<K, basic_json_view, C, A>>(*this);
     }
 
-    template<typename K, typename V, typename H, typename E, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
-    std::unordered_map<K, V, H, E, A> get_impl(detail::view::value_tag<std::unordered_map<K, V, H, E, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
+    template<typename K, typename H, typename E, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
+    std::unordered_map<K, basic_json_view, H, E, A> get_impl(detail::view::value_tag<std::unordered_map<K, basic_json_view, H, E, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
     {
-        return detail::view::map_value<std::unordered_map<K, V, H, E, A>>(*this);
+        return detail::view::map_value<std::unordered_map<K, basic_json_view, H, E, A>>(*this);
+    }
+
+    /// whether the from_json() of T's serializer reads views (see
+    /// detail::has_view_from_json)
+    template<typename T>
+    using reads_view = detail::has_view_from_json<typename BasicJsonType::template json_serializer<T, void>, basic_json_view, T>;
+
+    /// how get_to() converts: 2 directly, 1 with a from_json() that reads
+    /// views, 0 through materialize()
+    template<typename T>
+    using get_to_kind = std::integral_constant < int, detail::view::is_direct_value<T, BasicJsonType, basic_json_view>::value
+                        ? 2 : static_cast<int>(reads_view<T>::value) >;
+
+    /// types whose from_json() reads views, without materialize()
+    template < typename T, typename std::enable_if < reads_view<T>::value && std::is_default_constructible<T>::value, int >::type = 0 >
+    T get_impl(detail::view::value_tag<T> /*unused*/, detail::priority_tag<1> /*unused*/) const
+    {
+        auto v = T();
+        BasicJsonType::template json_serializer<T, void>::from_json(*this, v);
+        return v;
     }
 
     /// everything else through the BasicJsonType value (from_json included)
@@ -8628,14 +8690,20 @@ class basic_json_view
     // --- get_to() dispatch ---
 
     template<typename T>
-    void get_to_impl(T& v, std::true_type /*direct*/) const
+    void get_to_impl(T& v, std::integral_constant<int, 2> /*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
+    void get_to_impl(T& v, std::integral_constant<int, 1> /*from_json reads views*/) const
+    {
+        BasicJsonType::template json_serializer<T, void>::from_json(*this, v);
+    }
+
+    template<typename T>
+    void get_to_impl(T& v, std::integral_constant<int, 0> /*through materialize()*/) const
     {
         materialize().get_to(v);
     }
@@ -8651,16 +8719,19 @@ Borrowed parses keep a pointer to the caller's text, which must outlive the
 document. Owned parses (parse_copy, rvalue std::string, streams, and inputs
 that are not contiguous byte ranges) keep their own copy.
 */
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_document
 {
+    /// whether the document can be edited
+    static constexpr bool is_editable = Mode == view_mode::editable;
+
     using document_data = detail::view::document_data;
 
     static_assert(sizeof(typename BasicJsonType::number_integer_t) == 8 && sizeof(typename BasicJsonType::number_unsigned_t) == 8,
                   "json_view supports 64-bit integer types only");
 
   public:
-    using view_type = basic_json_view<BasicJsonType, Editable>;
+    using view_type = basic_json_view<BasicJsonType, Mode>;
     using value_t = detail::value_t;
 
     /// an empty (discarded) document
@@ -8874,6 +8945,10 @@ class basic_json_document
     /// how load() checks an image (full, bounds, or none)
     using image_check = detail::view::image_check;
 
+#if NLOHMANN_VIEW_LITTLE_ENDIAN
+    // (the image format is little-endian: big-endian targets have no save()
+    // and load(), so that a call fails to compile instead of always throwing)
+
     /// The document as an image that load() reads without parsing: the node
     /// index, the text, and the decoded strings. An edited document is
     /// written in its current state (floats that are not finite become null,
@@ -8915,6 +8990,7 @@ class basic_json_document
         detail::view::load_image(*d.m_data, d.m_data->owned_image.data(), d.m_data->owned_image.size(), check);
         return d;
     }
+#endif
 
     ///////////
     // edits //
@@ -9056,7 +9132,7 @@ class basic_json_document
 
     detail::view::editor<BasicJsonType, view_type> editor()
     {
-        static_assert(Editable, "only an editable document can be edited: use basic_json_document<BasicJsonType, true> (json_editable_document)");
+        static_assert(is_editable, "only an editable document can be edited: use basic_json_document<BasicJsonType, view_mode::editable> (json_editable_document)");
         if (NLOHMANN_VIEW_UNLIKELY(!m_data || m_data->discarded))
         {
             detail::view::throw_invalid_iterator(detail::exception_id::iterator_from_other_value, "view does not belong to this document");
@@ -9332,6 +9408,15 @@ class basic_json_document
     std::unique_ptr<document_data, document_data::deleter> m_data{}; // NOLINT(readability-redundant-member-init)
 };
 
+/*!
+@brief whether T is a basic_json_view (of any BasicJsonType and view_mode)
+
+For constraining templates that accept views, e.g. a from_json() written for
+both basic_json values and views.
+*/
+template<typename T>
+struct is_json_view : detail::is_json_view<T> {};
+
 /// a parsed JSON text for json
 using json_document = basic_json_document<json>;
 /// a value of a json_document
@@ -9341,13 +9426,13 @@ using ordered_json_document = basic_json_document<ordered_json>;
 /// a value of an ordered_json_document
 using ordered_json_view = basic_json_view<ordered_json>;
 /// an editable parsed JSON text for json
-using json_editable_document = basic_json_document<json, true>;
+using json_editable_document = basic_json_document<json, view_mode::editable>;
 /// a value of a json_editable_document
-using json_editable_view = basic_json_view<json, true>;
+using json_editable_view = basic_json_view<json, view_mode::editable>;
 /// an editable parsed JSON text for ordered_json
-using ordered_json_editable_document = basic_json_document<ordered_json, true>;
+using ordered_json_editable_document = basic_json_document<ordered_json, view_mode::editable>;
 /// a value of an ordered_json_editable_document
-using ordered_json_editable_view = basic_json_view<ordered_json, true>;
+using ordered_json_editable_view = basic_json_view<ordered_json, view_mode::editable>;
 
 NLOHMANN_JSON_NAMESPACE_END
 

tests/CMakeLists.txt

@@ -420,9 +420,9 @@ json_test_add_test_for(src/unit-file_input.cpp
 )
 
 # the json_view parser again with the portable string scanning instead of
-# NEON/SSE2, and on x86-64 with the SSSE3 UTF-8 check (JSON_VIEW_USE_SSSE3)
+# NEON/SSE2 (JSON_NO_SIMD), and on x86-64 compiled for SSSE3 (no CPU check)
 json_test_set_test_options(test-json_view_builder_portable
-    COMPILE_DEFINITIONS JSON_VIEW_NO_SIMD
+    COMPILE_DEFINITIONS JSON_NO_SIMD
 )
 json_test_add_test_for(src/unit-json_view_builder.cpp
     NAME test-json_view_builder_portable
@@ -430,7 +430,6 @@ json_test_add_test_for(src/unit-json_view_builder.cpp
 )
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64)$" AND NOT MSVC)
     json_test_set_test_options(test-json_view_builder_ssse3
-        COMPILE_DEFINITIONS JSON_VIEW_USE_SSSE3
         COMPILE_OPTIONS -mssse3
     )
     json_test_add_test_for(src/unit-json_view_builder.cpp

tests/abi/config/CMakeLists.txt

@@ -24,9 +24,7 @@ foreach(test default noversion)
         JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1
         JSON_DISABLE_STREAM_BULK_SCAN=1
         JSON_DISABLE_UNLOCKED_FILE_IO=1
-        JSON_NO_SIMD
-        JSON_VIEW_NO_SIMD
-        JSON_VIEW_USE_SSSE3)
+        JSON_NO_SIMD)
     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

@@ -64,14 +64,6 @@ TEST_CASE("default namespace")
         expected += "_ns";
 #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

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

tests/benchmarks/json_view/README.md

@@ -59,6 +59,12 @@ An editable `json_document` edits in place; yyjson copies its immutable document
 (`yyjson_doc_mut_copy`); Boost.JSON and `json::parse` build mutable DOMs; simdjson cannot edit a document. All
 outputs are checked to describe the same value.
 
+`bench_decode.cpp` measures decoding into structs whose `from_json()` comes from the `NLOHMANN_DEFINE_TYPE_*` macros
+(twitter statuses, citm_catalog performances, and 20,000 synthetic records): `get<T>()` on a view, which reads the
+view directly, against `materialize().get<T>()`, `json::parse` plus `get<T>()`, and `get<T>()` on an already parsed
+`json` value. Only nlohmann/json takes part, as the other libraries have no comparable mapping; all engines are
+checked to decode the same values.
+
 Before anything is timed, all engines must accept each document and agree on the traversal: the number of values, the
 bytes of all strings and keys, and the sum of all numbers. All engines run interleaved in every round, and the best
 round is reported, as time and as a factor of the `json_view` time (below 1 means faster than `json_view`). Each timed

tests/benchmarks/json_view/bench_decode.cpp

@@ -0,0 +1,312 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+// Decoding into structs: the same types, with from_json() generated by the
+// NLOHMANN_DEFINE_TYPE_* macros, read three ways. Only nlohmann/json takes
+// part; the other libraries have no comparable mapping.
+//
+//   view           json_document::parse, then get<T>() on the view (from_json reads the view)
+//   materialize    json_document::parse, then materialize().get<T>() (a json value first)
+//   json::parse    json::parse, then get<T>()
+//   json::get      get<T>() on an already parsed json value (the decoding alone)
+//
+// Documents: twitter (the statuses with their users and hashtags), citm_catalog
+// (the performances with their seat categories), and a synthetic document of
+// 20,000 nested records.
+//
+// Build: see README.md (same flags as bench_view.cpp).
+#include <nlohmann/json_view.hpp>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <functional>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+using nlohmann::json;
+using nlohmann::json_document;
+
+static volatile std::size_t g_sink;
+
+namespace twitter
+{
+struct hashtag
+{
+    std::string text;
+    std::vector<int> indices;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(hashtag, text, indices)
+
+struct entities
+{
+    std::vector<hashtag> hashtags;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(entities, hashtags)
+
+struct user
+{
+    std::uint64_t id = 0;
+    std::string screen_name;
+    std::string description;
+    std::int64_t followers_count = 0;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(user, id, screen_name, description, followers_count)
+
+struct status
+{
+    std::uint64_t id = 0;
+    std::string text;
+    user user;
+    entities entities;
+    std::int64_t retweet_count = 0;
+    std::int64_t favorite_count = 0;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(status, id, text, user, entities, retweet_count, favorite_count)
+
+struct document
+{
+    std::vector<status> statuses;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(document, statuses)
+
+std::size_t digest(const document& d)
+{
+    std::size_t n = 0;
+    for (const auto& s : d.statuses)
+    {
+        n += s.text.size() + s.user.screen_name.size() + s.entities.hashtags.size() + static_cast<std::size_t>(s.retweet_count);
+    }
+    return n;
+}
+}  // namespace twitter
+
+namespace citm
+{
+struct area
+{
+    std::int64_t areaId = 0;
+    std::vector<std::int64_t> blockIds;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(area, areaId, blockIds)
+
+struct seat_category
+{
+    std::vector<area> areas;
+    std::int64_t seatCategoryId = 0;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(seat_category, areas, seatCategoryId)
+
+struct performance
+{
+    std::int64_t id = 0;
+    std::int64_t eventId = 0;
+    std::vector<seat_category> seatCategories;
+    std::int64_t start = 0;
+    std::string venueCode;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(performance, id, eventId, seatCategories, start, venueCode)
+
+struct document
+{
+    std::vector<performance> performances;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(document, performances)
+
+std::size_t digest(const document& d)
+{
+    std::size_t n = 0;
+    for (const auto& p : d.performances)
+    {
+        n += p.seatCategories.size() + p.venueCode.size() + static_cast<std::size_t>(p.start % 1000);
+        for (const auto& c : p.seatCategories)
+        {
+            n += c.areas.size();
+        }
+    }
+    return n;
+}
+}  // namespace citm
+
+namespace synthetic
+{
+struct position
+{
+    double x = 0;
+    double y = 0;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(position, x, y)
+
+struct child
+{
+    std::int64_t id = 0;
+    std::string label;
+    bool active = false;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(child, id, label, active)
+
+struct record
+{
+    std::int64_t id = 0;
+    std::string name;
+    std::vector<std::string> tags;
+    position pos;
+    std::vector<child> children;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(record, id, name, tags, pos, children)
+
+struct document
+{
+    std::vector<record> records;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(document, records)
+
+std::string make_text(std::size_t n)
+{
+    std::string s = "{\"records\":[";
+    for (std::size_t i = 0; i < n; ++i)
+    {
+        const std::string id = std::to_string(i);
+        s += (i == 0 ? "" : ",");
+        s += "{\"id\":" + id + ",\"name\":\"record number " + id + "\",\"tags\":[\"alpha\",\"beta\",\"gamma\"],";
+        s += "\"pos\":{\"x\":" + id + ".25,\"y\":-" + id + ".5},\"children\":[";
+        for (std::size_t k = 0; k < 3; ++k)
+        {
+            s += (k == 0 ? "" : ",");
+            s += "{\"id\":" + std::to_string(i * 3 + k) + ",\"label\":\"child " + std::to_string(k) + "\",\"active\":" + (k % 2 == 0 ? "true" : "false") + "}";
+        }
+        s += "]}";
+    }
+    s += "]}";
+    return s;
+}
+
+std::size_t digest(const document& d)
+{
+    std::size_t n = 0;
+    for (const auto& r : d.records)
+    {
+        n += r.name.size() + r.tags.size() + r.children.size() + static_cast<std::size_t>(r.pos.x);
+    }
+    return n;
+}
+}  // namespace synthetic
+
+namespace
+{
+std::string read_file(const std::string& p)
+{
+    std::ifstream f(p, std::ios::binary);
+    if (!f)
+    {
+        std::fprintf(stderr, "cannot open %s\n", p.c_str());
+        std::exit(1);
+    }
+    std::stringstream ss;
+    ss << f.rdbuf();
+    return ss.str();
+}
+
+double time_ns(const std::function<void()>& f)
+{
+    const auto t0 = std::chrono::steady_clock::now();
+    f();
+    const auto t1 = std::chrono::steady_clock::now();
+    return static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
+}
+
+struct engine
+{
+    std::string name;
+    std::function<std::size_t()> run;
+};
+
+template<typename Document>
+std::vector<engine> engines(const std::string& text, const json& parsed)
+{
+    return
+    {
+        {"view", [&text] { const json_document d = json_document::parse(text); return digest(d.root().get<Document>()); }},
+        {"materialize", [&text] { const json_document d = json_document::parse(text); return digest(d.root().materialize().get<Document>()); }},
+        {"json::parse", [&text] { return digest(json::parse(text).get<Document>()); }},
+        {"json::get", [&parsed] { return digest(parsed.get<Document>()); }},
+    };
+}
+}  // namespace
+
+int main(int argc, char** argv)
+{
+    if (argc < 2)
+    {
+        std::fprintf(stderr, "usage: %s <json_test_data directory> [rounds]\n", argv[0]);
+        return 1;
+    }
+    const std::string dir = argv[1];
+    const int rounds = argc > 2 ? std::max(1, std::atoi(argv[2])) : 30;
+
+    struct document_case
+    {
+        std::string name;
+        std::string text;
+        json parsed;
+        std::vector<engine> engines;
+    };
+    std::vector<document_case> cases;
+    cases.push_back({"twitter", read_file(dir + "/nativejson-benchmark/twitter.json"), json(), {}});
+    cases.push_back({"citm_catalog", read_file(dir + "/nativejson-benchmark/citm_catalog.json"), json(), {}});
+    cases.push_back({"synthetic", synthetic::make_text(20000), json(), {}});
+    for (auto& c : cases)
+    {
+        c.parsed = json::parse(c.text);
+    }
+    cases[0].engines = engines<twitter::document>(cases[0].text, cases[0].parsed);
+    cases[1].engines = engines<citm::document>(cases[1].text, cases[1].parsed);
+    cases[2].engines = engines<synthetic::document>(cases[2].text, cases[2].parsed);
+
+    std::FILE* csv = std::fopen("bench_decode.csv", "w");
+    if (csv == nullptr)
+    {
+        std::perror("bench_decode.csv");
+        return 1;
+    }
+    std::fprintf(csv, "doc,bytes,engine,ns\n");
+    for (const auto& c : cases)
+    {
+        // all engines must decode the same values
+        const std::size_t expected = c.engines[0].run();
+        bool ok = true;
+        for (const auto& e : c.engines)
+        {
+            ok = ok && e.run() == expected;
+        }
+        std::vector<double> best(c.engines.size(), 1e300);
+        for (int r = 0; r < rounds; ++r)
+        {
+            for (std::size_t k = 0; k < c.engines.size(); ++k)
+            {
+                g_sink = c.engines[k].run(); // untimed: see bench_view.cpp
+                best[k] = std::min(best[k], time_ns([&] { g_sink = c.engines[k].run(); }));
+            }
+        }
+        std::printf("%-13s %-7s %s", c.name.c_str(), "decode", ok ? "" : "[MISMATCH] ");
+        for (std::size_t k = 0; k < c.engines.size(); ++k)
+        {
+            const double us = best[k] / 1000.0;
+            std::printf("  %s %.*fus (%.2fx)", c.engines[k].name.c_str(), us < 10 ? 3 : (us < 1000 ? 1 : 0), us, best[k] / best[0]);
+            std::fprintf(csv, "%s,%zu,%s,%.1f\n", c.name.c_str(), c.text.size(), c.engines[k].name.c_str(), best[k]);
+        }
+        std::printf("\n");
+    }
+    std::fclose(csv);
+    return 0;
+}

tests/benchmarks/json_view/compare.py

@@ -9,7 +9,7 @@
 
 """Compare json_view with yyjson, simdjson, Boost.JSON, and json::parse.
 
-Builds bench_view.cpp, bench_corpus.cpp, and bench_edit.cpp against the include/ directory of
+Builds bench_view.cpp, bench_corpus.cpp, bench_edit.cpp, and bench_decode.cpp against the include/ directory of
 this checkout, runs them, and writes the results with everything needed to
 reproduce them (date, commit, CPU, OS, compiler, library versions, flags) to
 results/<date>-<host>.md and .csv next to this script.
@@ -283,7 +283,7 @@ def main():
             objects.append(obj)
 
     binaries = {}
-    for bench in ['bench_view', 'bench_corpus', 'bench_edit']:
+    for bench in ['bench_view', 'bench_corpus', 'bench_edit', 'bench_decode']:
         exe = os.path.join(args.build_dir, bench)
         run(cxx + flags + include + [os.path.join(HERE, bench + '.cpp')] + objects + link + ['-o', exe])
         binaries[bench] = exe
@@ -297,6 +297,8 @@ def main():
                                   capture_output=True, text=True).stdout
     outputs['bench_edit'] = run([binaries['bench_edit'], args.data, str(max(1, args.rounds // 2))], cwd=args.build_dir,
                                 capture_output=True, text=True).stdout
+    outputs['bench_decode'] = run([binaries['bench_decode'], args.data, str(max(1, args.rounds // 2))], cwd=args.build_dir,
+                                  capture_output=True, text=True).stdout
     for name, text in outputs.items():
         print(text)
 
@@ -330,7 +332,7 @@ def main():
             f.write(f'\n## {name}\n\n```\n{text.rstrip()}\n```\n')
     with open(stem + '.csv', 'w', encoding='utf-8') as out:
         out.write(''.join(f'# {key}: {value}\n' for key, value in meta))
-        for name in ['bench_view', 'bench_corpus', 'bench_edit']:
+        for name in ['bench_view', 'bench_corpus', 'bench_edit', 'bench_decode']:
             path = os.path.join(args.build_dir, name + '.csv')
             if os.path.isfile(path):
                 with open(path, encoding='utf-8') as f:

tests/src/fuzzer-parse_bjdata.cpp

@@ -47,10 +47,6 @@ dumps is stable under exactly the same values that break operator==.
 The unit tests run the same checks on a fixed corpus (see the "BJData round-trip
 invariants" test case), so keep both in sync.
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bjdata() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -61,7 +57,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -86,9 +81,6 @@ static bool is_value_stable(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bjdata).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -107,9 +99,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2.1: round trip without adding size annotations to container types
@@ -143,7 +132,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -154,7 +142,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_bon8.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_bon8(vec)
 - assert(to_bon8(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bon8() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_bon8
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bon8).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_bson.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_bson(vec)
 - assert(to_bson(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bson() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_bson
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bson).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors can occur during parsing, too
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_cbor.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_cbor(vec)
 - assert(to_cbor(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_cbor() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_cbor
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::cbor).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors can occur during parsing, too
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_json.cpp

@@ -24,16 +24,11 @@ array data, it performs the following steps:
 The pointer range takes the bulk fast paths, the other input adapters read byte
 by byte; see check_input_adapters().
 
-Furthermore, it parses data with a SAX parser that recovers from every error
-and checks that the events are balanced, that parsing ends, and that valid
-input is parsed without errors (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -64,13 +59,6 @@ struct accept_json
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    {
-        const auto checker = check_recovering_parse(data, size, json::input_format_t::json);
-        assert(checker.events <= (4 * size) + 4);
-        assert((checker.errors == 0) == json::accept(data, data + size));
-    }
-
     // step 0: parse input without exceptions
     bool noexcept_threw = false;
     json const j_noexcept = parse_without_exceptions([&] { return json::parse(data, data + size, nullptr, false); }, noexcept_threw);

tests/src/fuzzer-parse_msgpack.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_msgpack(vec)
 - assert(to_msgpack(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_msgpack() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_msgpack
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::msgpack).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_ubjson.cpp

@@ -26,10 +26,6 @@ array data, it performs the following steps:
 The unit tests run the same checks on a fixed corpus (see the "UBJSON round-trip
 invariants" test case), so keep both in sync.
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_ubjson() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -40,7 +36,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -58,9 +53,6 @@ struct read_ubjson
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::ubjson).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -79,9 +71,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2.1: round trip without adding size annotations to container types
@@ -113,7 +102,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -124,7 +112,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-recovering_checker.hpp

@@ -1,154 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-#include <vector>
-#include <nlohmann/json.hpp>
-
-namespace
-{
-// a SAX parser that recovers from every error and checks that the events are
-// balanced and that every key is followed by exactly one value
-class recovering_checker : public nlohmann::json_sax<nlohmann::json>
-{
-  public:
-    bool null() override
-    {
-        return value();
-    }
-
-    bool boolean(bool /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_integer(number_integer_t /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_unsigned(number_unsigned_t /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_float(number_float_t /*val*/, const string_t& /*s*/) override
-    {
-        return value();
-    }
-
-    bool string(string_t& /*val*/) override
-    {
-        return value();
-    }
-
-    bool binary(binary_t& /*val*/) override
-    {
-        return value();
-    }
-
-    bool start_object(std::size_t /*elements*/) override
-    {
-        value();
-        stack.push_back('o');
-        return true;
-    }
-
-    bool key(string_t& /*val*/) override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'o');
-        stack.back() = 'v';
-        return true;
-    }
-
-    bool end_object() override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'o');
-        stack.pop_back();
-        return true;
-    }
-
-    bool start_array(std::size_t /*elements*/) override
-    {
-        value();
-        stack.push_back('a');
-        return true;
-    }
-
-    bool end_array() override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'a');
-        stack.pop_back();
-        return true;
-    }
-
-    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const nlohmann::detail::exception& /*ex*/) override
-    {
-        ++errors;
-        return true;
-    }
-
-    bool complete() const
-    {
-        return stack.empty();
-    }
-
-    std::size_t events = 0;
-    std::size_t errors = 0;
-
-  private:
-    bool value()
-    {
-        ++events;
-        if (!stack.empty())
-        {
-            // an array element, or the value of a key
-            assert(stack.back() != 'o');
-            if (stack.back() == 'v')
-            {
-                stack.back() = 'o';
-            }
-        }
-        return true;
-    }
-
-    // 'a' for an array, 'o' for an object that expects a key, 'v' for an
-    // object that expects the value of a key
-    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
-};
-
-/// parses @a data with a recovering_checker from memory and from a stream,
-/// checks that both see the same, that the events are balanced, and that the
-/// number of errors is bounded, and returns the checker (see #3989)
-inline recovering_checker check_recovering_parse(const std::uint8_t* data, const std::size_t size, const nlohmann::json::input_format_t format)
-{
-    recovering_checker checker;
-    const bool ok = nlohmann::json::sax_parse(data, data + size, &checker, format);
-    assert(checker.complete());
-    assert(checker.errors <= size + 1);
-    assert(ok == (checker.errors == 0));
-
-    std::istringstream stream(std::string(reinterpret_cast<const char*>(data), size));
-    recovering_checker stream_checker;
-    assert(nlohmann::json::sax_parse(stream, &stream_checker, format) == ok);
-    assert(stream_checker.complete());
-    assert(stream_checker.events == checker.events);
-    assert(stream_checker.errors == checker.errors);
-
-    return checker;
-}
-} // namespace

tests/src/sax_event_loggers.hpp

@@ -131,13 +131,11 @@ struct SaxEventLogger : public nlohmann::json_sax<nlohmann::json>
     {
         errored = true;
         events.push_back("parse_error(" + std::to_string(position) + ")");
-        return recover;
+        return false;
     }
 
     std::vector<std::string> events {}; // NOLINT(readability-redundant-member-init)
     bool errored = false;
-    /// whether parse_error() asks the parser to recover from the error (see #3989)
-    bool recover = false;
 };
 
 struct SaxEventLoggerExitAfterStartObject : public SaxEventLogger

tests/src/unit-alt-string.cpp

@@ -415,46 +415,6 @@ TEST_CASE("alternative string type")
         CHECK(j2.dump() == R"({"/foo/0":"bar","/foo/1":"baz"})");
     }
 
-    SECTION("error recovery")
-    {
-        // a SAX parser that recovers from every error (see #3989)
-        struct recovering_parser : nlohmann::detail::json_sax_dom_parser<alt_json>
-        {
-            explicit recovering_parser(alt_json& j)
-                : nlohmann::detail::json_sax_dom_parser<alt_json>(j, false)
-            {}
-
-            // sax_parse() calls the SAX parser's own parse_error(), so hiding
-            // the one of the base class is what recovering takes
-            // NOLINTNEXTLINE(bugprone-derived-method-shadowing-base-method)
-            bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const nlohmann::detail::exception& /*unused*/)
-            {
-                ++errors;
-                return true;
-            }
-
-            std::size_t errors = 0;
-        };
-
-        alt_json j;
-        recovering_parser sax(j);
-        // not inside CHECK(): MSVC reads the escape in a stringized raw string
-        const std::string input = R"([1., "a\qb", tru, {"k" 2}])";
-        CHECK(!alt_json::sax_parse(input, &sax));
-        CHECK(sax.errors == 4);
-        CHECK(j.dump() == R"([1,"aqb",null,{"k":2}])");
-
-        // a UBJSON high-precision number, a CBOR key that is not a string
-        alt_json u;
-        recovering_parser ubjson_sax(u);
-        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {'[', 'H', 'i', 2, '1', '.', ']'}, &ubjson_sax, alt_json::input_format_t::ubjson));
-        CHECK(u.dump() == "[1]");
-        alt_json c;
-        recovering_parser cbor_sax(c);
-        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {0xA2, 0x01, 0x02, 0x61, 'a', 0x03}, &cbor_sax, alt_json::input_format_t::cbor));
-        CHECK(c.dump() == R"({"a":3})");
-    }
-
     SECTION("conversion between basic_json specializations (#2649)")
     {
         // explicit conversions are always possible