Compare commits

..
Author SHA1 Message Date
Niels Lohmann d490ad8541 Fix a scalar set() through a view of a value that an edit dropped
set(target, scalar) on an array/object that spans more than one node first
switches the container that target is in to links, since that container
steps over target's parsed subtree by its node count. The container was
looked up from root(); for a target that is no longer part of the document
(an edit erased or replaced it, or a value that contains it) the lookup
found nothing and the scalar was written anyway. The dropped container then
read past its nodes when walked, and a later edit of it made block_of()
write more links than the block it allocated holds.

When the lookup from root() fails, look for the container whose contiguous
layout still steps over the slot: the nearest container before it in its
allocation whose extent covers it (edits never enlarge an extent, so this
is the original parent). If that container still uses its layout, it
switches to links as a live parent does. Every other edit through a view of
a dropped value already worked and changed only the detached value; the
scalar set now does the same, as documented.

Also stop block_of() when its block is full, so that it never writes past
the capacity it allocated.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-16 07:41:42 +01:00
31 changed files with 311 additions and 110 deletions

No files matched your search

+1 -1
View File
@@ -66,7 +66,7 @@ labels:
- "tests/src/fuzzer-(parse_json_view|json_view_image)\\.cpp" - "tests/src/fuzzer-(parse_json_view|json_view_image)\\.cpp"
- "tests/benchmarks/json_view/.*" - "tests/benchmarks/json_view/.*"
- "tools/amalgamate/config_json_view\\.json" - "tools/amalgamate/config_json_view\\.json"
- "docs/mkdocs/docs/features/json_view/.*" - "docs/mkdocs/docs/features/json_view\\.md"
- "docs/mkdocs/docs/api/basic_json_(document|view)/.*" - "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
- "docs/mkdocs/docs/api/(ordered_)?json_(editable_)?(document|view)\\.md" - "docs/mkdocs/docs/api/(ordered_)?json_(editable_)?(document|view)\\.md"
- "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(editable_)?(document|view)).*" - "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(editable_)?(document|view)).*"
+3 -1
View File
@@ -115,7 +115,9 @@ jobs:
python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s . python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s . python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .
python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_view.json -s . # the configuration of json_view.hpp comes with the pull request until
# it is on develop; the tool itself is still develop's
python3 $TOOL_DIR/amalgamate.py -c $MAIN_DIR/tools/amalgamate/config_json_view.json -s .
# the header list of the Bazel "json" target must match the files in include/ # the header list of the Bazel "json" target must match the files in include/
cmake -P cmake/scripts/gen_bazel_build_file.cmake cmake -P cmake/scripts/gen_bazel_build_file.cmake
+3 -2
View File
@@ -20,7 +20,7 @@
# fuzzers # fuzzers
/tests/corpus_* /tests/corpus_*
/tests/*_fuzzer /tests/parse_*_fuzzer
# documentation # documentation
/docs/docset/JSON_for_Modern_C++.docset/ /docs/docset/JSON_for_Modern_C++.docset/
@@ -47,10 +47,11 @@ nlohmann_json.spdx
# Bazel-related # Bazel-related
MODULE.bazel.lock MODULE.bazel.lock
# backups left by `make check-amalgamation` if it is interrupted # backups left by `make check-amalgamation` or the ci_test_amalgamation target if they are interrupted
/BUILD.bazel~ /BUILD.bazel~
/nlohmann_json.natvis~ /nlohmann_json.natvis~
/single_include/nlohmann/*.hpp~ /single_include/nlohmann/*.hpp~
/venv_astyle/
# release outputs of `make release` # release outputs of `make release`
/include.zip /include.zip
-1
View File
@@ -28,7 +28,6 @@ The [GitHub Actions](https://docs.github.com/en/actions) workflows that build, t
- `publish_documentation.yml` — build and publish the documentation on pushes to the `develop` branch that touch the documentation sources (or the files it embeds). - `publish_documentation.yml` — build and publish the documentation on pushes to the `develop` branch that touch the documentation sources (or the files it embeds).
- `check_docs_links.yml` — check the links of the documentation weekly, as external links can break without any change in this repository. - `check_docs_links.yml` — check the links of the documentation weekly, as external links can break without any change in this repository.
- `cancel_closed_pr_runs.yml` — cancel unfinished workflow runs of a pull request once it is closed or merged. - `cancel_closed_pr_runs.yml` — cancel unfinished workflow runs of a pull request once it is closed or merged.
- `json_view_benchmarks.yml` — compare the performance of `json_view` with other JSON libraries on GitHub-hosted x86-64 and AArch64 Linux runners, on demand or when a pull request gets the label "benchmark".
Further documentation: Further documentation:
+1 -1
View File
@@ -215,7 +215,7 @@ release: include.zip json.tar.xz
# clean up # clean up
clean: clean:
rm -fr *.dSYM tests/*.dSYM tests/*_fuzzer rm -fr *.dSYM tests/*.dSYM tests/parse_*_fuzzer
rm -fr cmake-build-benchmarks cmake-build-pvs-studio release_files rm -fr cmake-build-benchmarks cmake-build-pvs-studio release_files
$(MAKE) clean -Cdocs $(MAKE) clean -Cdocs
+77
View File
@@ -406,6 +406,61 @@ add_custom_target(ci_test_clang_sanitizer
COMMENT "Compile and test with sanitizers" COMMENT "Compile and test with sanitizers"
) )
###############################################################################
# Check if header is amalgamated and sources are properly indented.
###############################################################################
# Same file set as .github/workflows/check_amalgamation.yml, so this CMake target (which can be run locally) is held
# to the same standard as the workflow (which runs for pull requests and for pushes to develop/master/release/*).
file(GLOB_RECURSE INDENT_FILES
${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.hpp
${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.cpp
${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.cu
${PROJECT_SOURCE_DIR}/include/*.hpp
${PROJECT_SOURCE_DIR}/include/*.cpp
${PROJECT_SOURCE_DIR}/include/*.cu
${PROJECT_SOURCE_DIR}/tests/*.hpp
${PROJECT_SOURCE_DIR}/tests/*.cpp
${PROJECT_SOURCE_DIR}/tests/*.cu
)
list(FILTER INDENT_FILES EXCLUDE REGEX "/tests/thirdparty/|/tests/abi/include/nlohmann/")
set(include_dir ${PROJECT_SOURCE_DIR}/single_include/nlohmann)
set(tool_dir ${PROJECT_SOURCE_DIR}/tools/amalgamate)
add_custom_target(ci_test_amalgamation
COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~
COMMAND cp ${include_dir}/json.hpp ${include_dir}/json.hpp~
COMMAND cp ${include_dir}/json_fwd.hpp ${include_dir}/json_fwd.hpp~
COMMAND cp ${include_dir}/json_literals.hpp ${include_dir}/json_literals.hpp~
COMMAND cp ${include_dir}/json_view.hpp ${include_dir}/json_view.hpp~
COMMAND cp ${PROJECT_SOURCE_DIR}/BUILD.bazel ${PROJECT_SOURCE_DIR}/BUILD.bazel~
COMMAND ${Python3_EXECUTABLE} -mvenv venv_astyle
COMMAND venv_astyle/bin/pip3 --quiet install -r ${CMAKE_SOURCE_DIR}/tools/astyle/requirements.txt
COMMAND venv_astyle/bin/astyle --version
COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json.json -s .
COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_fwd.json -s .
COMMAND cp ${PROJECT_SOURCE_DIR}/include/nlohmann/json_literals.hpp ${include_dir}/json_literals.hpp
COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_view.json -s .
COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp ${include_dir}/json_literals.hpp ${include_dir}/json_view.hpp
COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/scripts/gen_bazel_build_file.cmake
COMMAND diff ${include_dir}/json.hpp~ ${include_dir}/json.hpp
COMMAND diff ${include_dir}/json_fwd.hpp~ ${include_dir}/json_fwd.hpp
COMMAND diff ${include_dir}/json_literals.hpp~ ${include_dir}/json_literals.hpp
COMMAND diff ${include_dir}/json_view.hpp~ ${include_dir}/json_view.hpp
COMMAND diff ${PROJECT_SOURCE_DIR}/BUILD.bazel~ ${PROJECT_SOURCE_DIR}/BUILD.bazel
COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
COMMAND for FILE in `find . -name '*.orig'`\; do false \; done
COMMAND rm -f ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~ ${PROJECT_SOURCE_DIR}/BUILD.bazel~
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT "Check amalgamation, formatting, and BUILD.bazel"
)
############################################################################### ###############################################################################
# Build and test using the amalgamated header # Build and test using the amalgamated header
############################################################################### ###############################################################################
@@ -637,6 +692,19 @@ else()
) )
endif() endif()
###############################################################################
# Benchmarks
###############################################################################
add_custom_target(ci_benchmarks
COMMAND ${CMAKE_COMMAND}
-DCMAKE_BUILD_TYPE=Release -GNinja
-S${PROJECT_SOURCE_DIR}/tests/benchmarks -B${PROJECT_BINARY_DIR}/build_benchmarks
COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_benchmarks --target json_benchmarks
COMMAND cd ${PROJECT_BINARY_DIR}/build_benchmarks && ./json_benchmarks
COMMENT "Run benchmarks"
)
############################################################################### ###############################################################################
# CMake flags # CMake flags
############################################################################### ###############################################################################
@@ -897,3 +965,12 @@ add_custom_target(ci_test_documentation_mermaid
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs/mkdocs WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs/mkdocs
COMMENT "Check the Mermaid diagrams of the documentation" COMMENT "Check the Mermaid diagrams of the documentation"
) )
###############################################################################
# Clean up all generated files.
###############################################################################
add_custom_target(ci_clean
COMMAND rm -fr ${PROJECT_BINARY_DIR}/build_* ${PROJECT_BINARY_DIR}/cmake-3.5.0 ${PROJECT_BINARY_DIR}/cmake-3.31.6 ${PROJECT_BINARY_DIR}/cmake-4.0.0 ${JSON_CMAKE_FLAG_BUILD_DIRS} ${single_binaries}
COMMENT "Clean generated directories"
)
+2 -14
View File
@@ -2,21 +2,12 @@
```cpp ```cpp
namespace std { namespace std {
void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2) noexcept( void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2);
is_nothrow_move_constructible<nlohmann::basic_json>::value &&
is_nothrow_move_assignable<nlohmann::basic_json>::value
);
} }
``` ```
Exchanges the values of two JSON objects. Exchanges the values of two JSON objects.
This specialization is only provided before C++20, which no longer allows specializing function templates in
namespace `std`. With C++20 (and in generic code with any standard), use the idiom `#!cpp using std::swap; swap(j1, j2);`: it finds
the [`swap`](swap.md) friend function (overload 2) by argument-dependent lookup. A qualified `#!cpp std::swap(j1, j2)`
still compiles with C++20, but uses the generic `std::swap`, which swaps by three moves instead of exchanging the
contents.
## Parameters ## Parameters
`j1` (in, out) `j1` (in, out)
@@ -27,9 +18,7 @@ contents.
## Exception safety ## Exception safety
No-throw guarantee if the `noexcept` condition above holds: it holds unless moving the No-throw guarantee: this function never throws exceptions.
[`json_base_class_t`](json_base_class_t.md) can throw. With the default base class, this function never throws
exceptions.
## Complexity ## Complexity
@@ -68,4 +57,3 @@ void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2)
- Added in version 1.0.0. - Added in version 1.0.0.
- Extended for arbitrary basic_json types in version 3.10.5. - Extended for arbitrary basic_json types in version 3.10.5.
- Not provided with C++20 since version 3.9.0.
+4 -8
View File
@@ -75,12 +75,8 @@ void swap(typename binary_t::container_type& other);
## Exception safety ## Exception safety
1. No-throw guarantee if the `noexcept` condition above holds: it holds unless moving the 1. No-throw guarantee: this function never throws exceptions.
[`json_base_class_t`](json_base_class_t.md) can throw (moving the type tag and the stored value never throws). 2. No-throw guarantee: this function never throws exceptions.
With the default base class, this function never throws exceptions.
2. No-throw guarantee if the `noexcept` condition above holds: it holds unless moving the
[`json_base_class_t`](json_base_class_t.md) can throw (moving the type tag and the stored value never throws).
With the default base class, this function never throws exceptions.
3. Strong guarantee: if an exception is thrown, there are no changes to any JSON value. 3. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
4. Strong guarantee: if an exception is thrown, there are no changes to any JSON value. 4. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
5. Strong guarantee: if an exception is thrown, there are no changes to any JSON value. 5. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
@@ -89,8 +85,8 @@ void swap(typename binary_t::container_type& other);
## Exceptions ## Exceptions
1. Throws only what moving the [`json_base_class_t`](json_base_class_t.md) throws; nothing with the default base class. 1. No-throw guarantee: this function never throws exceptions.
2. Throws only what moving the [`json_base_class_t`](json_base_class_t.md) throws; nothing with the default base class. 2. No-throw guarantee: this function never throws exceptions.
3. Throws [`type_error.310`](../../home/exceptions.md#jsonexceptiontype_error310) if called on JSON values other than 3. Throws [`type_error.310`](../../home/exceptions.md#jsonexceptiontype_error310) if called on JSON values other than
arrays; example: `"cannot use swap(array_t&) with boolean"` arrays; example: `"cannot use swap(array_t&) with boolean"`
4. Throws [`type_error.310`](../../home/exceptions.md#jsonexceptiontype_error310) if called on JSON values other than 4. Throws [`type_error.310`](../../home/exceptions.md#jsonexceptiontype_error310) if called on JSON values other than
+1 -2
View File
@@ -57,8 +57,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
## Exceptions ## Exceptions
- Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size` - Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
is false, and `j` contains a non-empty array, object, or binary value. Scalars and empty arrays, objects, or binary is false, and `j` contains a non-empty array, object, or binary value.
values do not throw.
- Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
not valid UTF-8 and `error_handler` is `strict` (the default only if not valid UTF-8 and `error_handler` is `strict` (the default only if
[`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
@@ -66,8 +66,7 @@ has `erase`; calling it on a read-only `basic_json_document` fails to compile (`
[`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) (a leading `#!cpp '0'`), [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) (a leading `#!cpp '0'`),
[`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) (not a number), [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) (not a number),
[`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) (too large for `size_type`), or [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) (too large for `size_type`), or
[`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token, or the token [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token); otherwise (an
`#!cpp "-"`, which never names an existing element); otherwise (an
object, or a primitive value the pointer's parent resolves to) throws what 1. throws. object, or a primitive value the pointer's parent resolves to) throws what 1. throws.
Overloads 1. and 2. also throw [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) Overloads 1. and 2. also throw [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202)
@@ -100,7 +100,8 @@ points apply to every edit:
[`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the [`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the
document, allocated on demand. document, allocated on demand.
- **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view - **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view
sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. An edit sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. Such a
view can still be edited: the edit changes only that detached value, never anything reachable from `root()`. An edit
of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a
different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even
as further edits happen (earlier buffers of edited text are kept alive, not overwritten). as further edits happen (earlier buffers of edited text are kept alive, not overwritten).
@@ -164,7 +164,9 @@ general.
The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a
scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent
originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a
one-node scalar. one-node scalar. This also holds when `target` is no longer part of the document (an edit erased or replaced it, or
a value that contains it): if the container that `target` was in still uses its parsed layout, it switches to links
(otherwise nothing steps over `target` any more), and only the dropped values change.
## Examples ## Examples
@@ -62,9 +62,10 @@ view.
!!! info "Overload 2 never throws" !!! info "Overload 2 never throws"
Like [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), overload 2 never throws: a Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
missing key, an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
primitive all simply make it return `#!cpp false`. an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a primitive all
simply make it return `#!cpp false`.
## Examples ## Examples
@@ -27,10 +27,9 @@ for (const auto [key, value] : v.items())
} }
``` ```
Taking `item` by value (`#!cpp const auto`) is recommended: unlike `BasicJsonType::items()`, whose elements are Note the `#!cpp const auto` (by value), not `#!cpp const auto&`: unlike `BasicJsonType::items()`, whose elements are
references into an existing object, a view's `item` is produced on the fly for each step of the iteration and is references into an existing object, a view's `item` is produced on the fly for each step of the iteration, so there
cheap to copy. A `#!cpp const auto&` (as in the first snippet) also works, as it binds to that temporary, but a is nothing for a reference to bind to.
non-const `#!cpp auto&` does not compile.
## Return value ## Return value
@@ -7,10 +7,6 @@ bool operator==(const basic_json_view& lhs, const basic_json_view& rhs);
// (2) // (2)
bool operator==(const basic_json_view& lhs, const BasicJsonType& rhs); bool operator==(const basic_json_view& lhs, const BasicJsonType& rhs);
bool operator==(const BasicJsonType& lhs, const basic_json_view& rhs); bool operator==(const BasicJsonType& lhs, const basic_json_view& rhs);
// (3)
template<view_mode M>
bool operator==(const basic_json_view& lhs, const basic_json_view<BasicJsonType, M>& rhs);
``` ```
1. Compares two views for equality: whether the values [`BasicJsonType::parse()`](../basic_json/parse.md) would 1. Compares two views for equality: whether the values [`BasicJsonType::parse()`](../basic_json/parse.md) would
@@ -18,12 +14,8 @@ bool operator==(const basic_json_view& lhs, const basic_json_view<BasicJsonType,
2. Compares a view and a `BasicJsonType` value for equality, in either order: whether the value `parse()` would 2. Compares a view and a `BasicJsonType` value for equality, in either order: whether the value `parse()` would
produce for the view and the other operand are equal, according to `BasicJsonType`'s produce for the view and the other operand are equal, according to `BasicJsonType`'s
[`operator==`](../basic_json/operator_eq.md). [`operator==`](../basic_json/operator_eq.md).
3. Like overload 1, for two views of the same `BasicJsonType` but of different [view modes](../view_mode.md), in
either order: a view of a read-only document (such as a [`json_view`](../json_view.md)) and a view of an editable
document (such as a [`json_editable_view`](../json_editable_view.md)). This overload only takes part in overload
resolution if `M` is not the mode of `lhs`.
No overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers Neither overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers
compare by value across their types (`#!cpp 1 == 1.0`), and an object compares by its members, with duplicate keys compare by value across their types (`#!cpp 1 == 1.0`), and an object compares by its members, with duplicate keys
resolved exactly as `parse()` resolves them — the last value, at the position of the first occurrence of the key. resolved exactly as `parse()` resolves them — the last value, at the position of the first occurrence of the key.
This is not what [`operator[]`](operator[].md) and the other lookups return for a duplicate key: they find the *first* This is not what [`operator[]`](operator[].md) and the other lookups return for a duplicate key: they find the *first*
@@ -7,17 +7,11 @@ bool operator!=(const basic_json_view& lhs, const basic_json_view& rhs);
// (2) // (2)
bool operator!=(const basic_json_view& lhs, const BasicJsonType& rhs); bool operator!=(const basic_json_view& lhs, const BasicJsonType& rhs);
bool operator!=(const BasicJsonType& lhs, const basic_json_view& rhs); bool operator!=(const BasicJsonType& lhs, const basic_json_view& rhs);
// (3)
template<view_mode M>
bool operator!=(const basic_json_view& lhs, const basic_json_view<BasicJsonType, M>& rhs);
``` ```
1. Compares two views for inequality. Returns `#!cpp !(lhs == rhs)`, see [operator==](operator_eq.md). 1. Compares two views for inequality. Returns `#!cpp !(lhs == rhs)`, see [operator==](operator_eq.md).
2. Compares a view and a `BasicJsonType` value for inequality, in either order. Returns `#!cpp !(lhs == rhs)` (or, 2. Compares a view and a `BasicJsonType` value for inequality, in either order. Returns `#!cpp !(lhs == rhs)` (or,
for the reversed order, `#!cpp !(rhs == lhs)`), see [operator==](operator_eq.md). for the reversed order, `#!cpp !(rhs == lhs)`), see [operator==](operator_eq.md).
3. Compares a read-only and an editable view of the same `BasicJsonType` for inequality, in either order. Returns
`#!cpp !(lhs == rhs)`, see [operator==](operator_eq.md).
Since `operator!=` is defined as the negation of [`operator==`](operator_eq.md), it follows the same rules for Since `operator!=` is defined as the negation of [`operator==`](operator_eq.md), it follows the same rules for
special cases: for instance, since a [discarded](is_discarded.md) view is never equal to anything by default (see special cases: for instance, since a [discarded](is_discarded.md) view is never equal to anything by default (see
@@ -15,10 +15,6 @@ materializing anything.
- `#!cpp static_cast<std::size_t>(-1)` for a [discarded](is_discarded.md) view, and for a string that contains - `#!cpp static_cast<std::size_t>(-1)` for a [discarded](is_discarded.md) view, and for a string that contains
escapes — such a string was decoded once into the document's own buffer, so there is no single byte range in escapes — such a string was decoded once into the document's own buffer, so there is no single byte range in
`source()` left to point at. `source()` left to point at.
- `#!cpp static_cast<std::size_t>(-1)` in an [editable document](../json_editable_document.md) for a value written
by an edit ([`set`](../basic_json_document/set.md), [`push_back`](../basic_json_document/push_back.md),
[`insert`](../basic_json_document/insert.md)), and for an array or object whose elements an edit added or removed.
The values an edit did not touch keep their offsets.
## Exception safety ## Exception safety
@@ -8,9 +8,8 @@ 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 This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the default
[`json`](json.md) specialization: in addition to everything [`json_document`](json_document.md) offers, [`json`](json.md) specialization: in addition to everything [`json_document`](json_document.md) offers,
[`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md), [`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) change values after
[`insert`](basic_json_document/insert.md), and [`erase`](basic_json_document/erase.md) change values after parsing, parsing, without ever rewriting the source text — see [Edits](basic_json_document/index.md#edits) and
without ever rewriting the source text — see [Edits](basic_json_document/index.md#edits) and
[Editing a document](../features/json_view/editing.md). [Editing a document](../features/json_view/editing.md).
## Examples ## Examples
+1 -2
View File
@@ -9,8 +9,7 @@ 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 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a
[`json_editable_document`](json_editable_document.md). It offers the same read-only interface as [`json_editable_document`](json_editable_document.md). It offers the same read-only interface as
[`json_view`](json_view.md); what is different is what it can be a view *of* — a value that [`json_view`](json_view.md); what is different is what it can be a view *of* — a value that
[`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md), [`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) can change, with every view
[`insert`](basic_json_document/insert.md), and [`erase`](basic_json_document/erase.md) can change, with every view
still referring to it seeing the change, see [Edits](basic_json_document/index.md#edits). still referring to it seeing the change, see [Edits](basic_json_document/index.md#edits).
## Examples ## Examples
@@ -171,7 +171,7 @@ See the examples below for the concrete generated code.
The macro is equivalent to: The macro is equivalent to:
```cpp hl_lines="22 23 24 25 26 27 28" ```cpp hl_lines="22 22 23 24 25 26 27 28"
--8<-- "examples/nlohmann_define_type_intrusive_only_serialize_explicit.cpp" --8<-- "examples/nlohmann_define_type_intrusive_only_serialize_explicit.cpp"
``` ```
@@ -69,7 +69,7 @@ For further information please refer to the corresponding macros without `WITH_N
The macro is equivalent to: The macro is equivalent to:
```cpp hl_lines="16 17 18 19 20 21 22 23 24 25 26 27 28 29 30" ```cpp hl_lines="16 17 18 19 20 21 22 23 24 25 26 27 28"
--8<-- "examples/nlohmann_define_type_non_intrusive_with_names_explicit.cpp" --8<-- "examples/nlohmann_define_type_non_intrusive_with_names_explicit.cpp"
``` ```
+1 -1
View File
@@ -98,7 +98,7 @@ serialization fails by default. The fourth argument of `dump` selects an
## Using `std::format`, `std::print`, and `fmt` ## Using `std::format`, `std::print`, and `fmt`
Since version 3.13.0, JSON values can be formatted directly with C++20's Since version 3.12.0, JSON values can be formatted directly with C++20's
[`std::format`](https://en.cppreference.com/w/cpp/utility/format/format) whenever the standard library provides the [`std::format`](https://en.cppreference.com/w/cpp/utility/format/format) whenever the standard library provides the
`<format>` header (controlled by [`JSON_HAS_STD_FORMAT`](../api/macros/json_has_std_format.md)). This is enabled by the `<format>` header (controlled by [`JSON_HAS_STD_FORMAT`](../api/macros/json_has_std_format.md)). This is enabled by the
[`std::formatter<basic_json>`](../api/basic_json/std_formatter.md) specialization, which also makes JSON values work with [`std::formatter<basic_json>`](../api/basic_json/std_formatter.md) specialization, which also makes JSON values work with
+2 -2
View File
@@ -1,7 +1,7 @@
# Recipes for Common Types # Recipes for Common Types
The library converts the standard containers, strings, numbers, tuples, `std::optional` (since version 3.12.0), and The library converts the standard containers, strings, numbers, tuples, `std::optional`, and `std::filesystem::path`
`std::filesystem::path` (since version 3.10.5), the last two with C++17, out of the box, and your own types once you write conversion functions or use (the last two since version 3.12.0, C++17) out of the box, and your own types once you write conversion functions or use
the macros (see [Arbitrary type conversions](arbitrary_types.md)). It deliberately does **not** convert smart pointers, the macros (see [Arbitrary type conversions](arbitrary_types.md)). It deliberately does **not** convert smart pointers,
`std::variant`, `std::chrono` types, or class hierarchies, because there is more than one reasonable JSON `std::variant`, `std::chrono` types, or class hierarchies, because there is more than one reasonable JSON
representation for each of them. This page shows a representation for each that you can copy and adapt. representation for each of them. This page shows a representation for each that you can copy and adapt.
+4 -6
View File
@@ -987,9 +987,7 @@ contains other characters (e.g., `1a`), or `-` where it cannot be used.
The JSON Patch operations 'remove' and 'move' cannot be applied to the root element of the JSON value. The exception is The JSON Patch operations 'remove' and 'move' cannot be applied to the root element of the JSON value. The exception is
also thrown when the parent or a reference token of an empty JSON Pointer is requested, for instance by also thrown when the parent or a reference token of an empty JSON Pointer is requested, for instance by
[`front`](../api/json_pointer/front.md), [`back`](../api/json_pointer/back.md), [`back`](../api/json_pointer/back.md) or [`pop_back`](../api/json_pointer/pop_back.md).
[`pop_front`](../api/json_pointer/pop_front.md), or [`pop_back`](../api/json_pointer/pop_back.md), and when
[`basic_json_document::erase`](../api/basic_json_document/erase.md) is called with an empty JSON Pointer.
!!! failure "Example message" !!! failure "Example message"
@@ -1265,9 +1263,9 @@ A JSON Patch operation 'test' failed. The unsuccessful operation is also printed
### json.exception.other_error.502 ### json.exception.other_error.502
[`to_ubjson`](../api/basic_json/to_ubjson.md) and [`to_bjdata`](../api/basic_json/to_bjdata.md) were called with [`to_ubjson`](../api/basic_json/to_ubjson.md) and [`to_bjdata`](../api/basic_json/to_bjdata.md) were called with
`use_type = true` but `use_size = false`, and the value contains a non-empty array, object, or binary value (with `use_type = true` but `use_size = false`, and the value contains a non-empty array or object (or, with BJData Draft 3,
BJData Draft 3, any binary value, including an empty one). UBJSON requires a size marker (`#`) after a type marker any binary value). UBJSON requires a size marker (`#`) after a type marker (`$`); scalars and empty arrays or objects
(`$`); scalars and empty arrays or objects do not throw. do not throw.
!!! failure "Example message" !!! failure "Example message"
+14 -1
View File
@@ -384,11 +384,24 @@ class editor
// for the container is linear in the size of the document, so // for the container is linear in the size of the document, so
// links (which are marked in the slot) avoid it. // links (which are marked in the slot) avoid it.
node* const p = parent_known ? parent : find_parent(m_doc, slot); node* const p = parent_known ? parent : find_parent(m_doc, slot);
if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)) if (p != nullptr)
{
if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)
{ {
block_of(m_doc, p, 0); block_of(m_doc, p, 0);
} }
} }
else
{
// the slot is no longer part of the document, but the
// (dropped) container it is in may still step over it
node* const q = find_layout_parent(m_doc, slot);
if (q != nullptr)
{
block_of(m_doc, q, 0);
}
}
}
*slot = e.scalar; *slot = e.scalar;
slot->flags = static_cast<std::uint8_t>(slot->flags | linked); slot->flags = static_cast<std::uint8_t>(slot->flags | linked);
return; return;
+38 -1
View File
@@ -194,7 +194,9 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
h->len = n->len; h->len = n->len;
h->next = static_cast<std::uint32_t>(used); h->next = static_cast<std::uint32_t>(used);
node* o = h + 1; node* o = h + 1;
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;) // (the bound on o keeps the copy inside the block even if the elements
// disagreed with the element count)
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;)
{ {
if (object) if (object)
{ {
@@ -276,6 +278,41 @@ inline node* find_parent(const document_data& d, const node* target)
} }
} }
/// The container whose contiguous layout (in the parsed index, or in a new
/// value) steps over `target`, also when an edit dropped the container or a
/// value that encloses it; nullptr if there is none, or if the container no
/// longer walks that layout (its elements moved). An edit never gives a node a
/// larger extent than it was parsed or encoded with (a scalar is one node, an
/// assigned array/object keeps the extent of the slot), so the containers whose
/// extent covers `target` are its original ancestors: the nearest one before it
/// is its original parent. The root of a new value that is the element sequence
/// of another container is walked by that container (which find_parent() finds
/// while it still uses the sequence), not by itself.
inline node* find_layout_parent(const document_data& d, const node* target)
{
const std::less<const node*> lt{};
const node* lo = d.nodes;
if (lt(target, lo) || !lt(target, d.nodes + d.node_count))
{
auto it = d.edits->regions.upper_bound(target);
if (it == d.edits->regions.begin())
{
return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value)
}
--it;
lo = it->second != nullptr ? it->first + 1 : it->first;
}
for (const node* c = target; c != lo;)
{
--c;
if (is_container(*c) && lt(target, c + c->next))
{
return (c->flags & node_flags::moved) == 0 ? const_cast<node*>(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document
}
}
return nullptr;
}
} // namespace view } // namespace view
} // namespace detail } // namespace detail
NLOHMANN_JSON_NAMESPACE_END NLOHMANN_JSON_NAMESPACE_END
+1 -1
View File
@@ -50,7 +50,6 @@
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#undef JSON_HEDLEY_END_C_DECLS #undef JSON_HEDLEY_END_C_DECLS
#undef JSON_HEDLEY_FALL_THROUGH
#undef JSON_HEDLEY_FLAGS #undef JSON_HEDLEY_FLAGS
#undef JSON_HEDLEY_FLAGS_CAST #undef JSON_HEDLEY_FLAGS_CAST
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
@@ -159,3 +158,4 @@
#undef JSON_HEDLEY_WARNING #undef JSON_HEDLEY_WARNING
#undef JSON_HEDLEY_WARN_UNUSED_RESULT #undef JSON_HEDLEY_WARN_UNUSED_RESULT
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
#undef JSON_HEDLEY_FALL_THROUGH
+1 -1
View File
@@ -48757,7 +48757,6 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#undef JSON_HEDLEY_END_C_DECLS #undef JSON_HEDLEY_END_C_DECLS
#undef JSON_HEDLEY_FALL_THROUGH
#undef JSON_HEDLEY_FLAGS #undef JSON_HEDLEY_FLAGS
#undef JSON_HEDLEY_FLAGS_CAST #undef JSON_HEDLEY_FLAGS_CAST
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
@@ -48866,6 +48865,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
#undef JSON_HEDLEY_WARNING #undef JSON_HEDLEY_WARNING
#undef JSON_HEDLEY_WARN_UNUSED_RESULT #undef JSON_HEDLEY_WARN_UNUSED_RESULT
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
#undef JSON_HEDLEY_FALL_THROUGH
// IWYU pragma: keep // IWYU pragma: keep
+52 -2
View File
@@ -5564,7 +5564,9 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
h->len = n->len; h->len = n->len;
h->next = static_cast<std::uint32_t>(used); h->next = static_cast<std::uint32_t>(used);
node* o = h + 1; node* o = h + 1;
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;) // (the bound on o keeps the copy inside the block even if the elements
// disagreed with the element count)
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;)
{ {
if (object) if (object)
{ {
@@ -5646,6 +5648,41 @@ inline node* find_parent(const document_data& d, const node* target)
} }
} }
/// The container whose contiguous layout (in the parsed index, or in a new
/// value) steps over `target`, also when an edit dropped the container or a
/// value that encloses it; nullptr if there is none, or if the container no
/// longer walks that layout (its elements moved). An edit never gives a node a
/// larger extent than it was parsed or encoded with (a scalar is one node, an
/// assigned array/object keeps the extent of the slot), so the containers whose
/// extent covers `target` are its original ancestors: the nearest one before it
/// is its original parent. The root of a new value that is the element sequence
/// of another container is walked by that container (which find_parent() finds
/// while it still uses the sequence), not by itself.
inline node* find_layout_parent(const document_data& d, const node* target)
{
const std::less<const node*> lt{};
const node* lo = d.nodes;
if (lt(target, lo) || !lt(target, d.nodes + d.node_count))
{
auto it = d.edits->regions.upper_bound(target);
if (it == d.edits->regions.begin())
{
return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value)
}
--it;
lo = it->second != nullptr ? it->first + 1 : it->first;
}
for (const node* c = target; c != lo;)
{
--c;
if (is_container(*c) && lt(target, c + c->next))
{
return (c->flags & node_flags::moved) == 0 ? const_cast<node*>(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document
}
}
return nullptr;
}
} // namespace view } // namespace view
} // namespace detail } // namespace detail
NLOHMANN_JSON_NAMESPACE_END NLOHMANN_JSON_NAMESPACE_END
@@ -6522,11 +6559,24 @@ class editor
// for the container is linear in the size of the document, so // for the container is linear in the size of the document, so
// links (which are marked in the slot) avoid it. // links (which are marked in the slot) avoid it.
node* const p = parent_known ? parent : find_parent(m_doc, slot); node* const p = parent_known ? parent : find_parent(m_doc, slot);
if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)) if (p != nullptr)
{
if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)
{ {
block_of(m_doc, p, 0); block_of(m_doc, p, 0);
} }
} }
else
{
// the slot is no longer part of the document, but the
// (dropped) container it is in may still step over it
node* const q = find_layout_parent(m_doc, slot);
if (q != nullptr)
{
block_of(m_doc, q, 0);
}
}
}
*slot = e.scalar; *slot = e.scalar;
slot->flags = static_cast<std::uint8_t>(slot->flags | linked); slot->flags = static_cast<std::uint8_t>(slot->flags | linked);
return; return;
+70
View File
@@ -589,6 +589,76 @@ TEST_CASE("json_view edits: a container that was added is replaced by a scalar")
CHECK(d.root().materialize() == json::parse(R"({"a":[1,6,{"k":"s"}]})")); CHECK(d.root().materialize() == json::parse(R"({"a":[1,6,{"k":"s"}]})"));
} }
TEST_CASE("json_view edits: a scalar replaces an array or object that is no longer part of the document")
{
// the dropped container that the array/object is in still steps over its
// parsed extent: that container switches to links first, as a live one does
SECTION("members of an erased object")
{
json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, [2]], "b": 3, "e": []}, "q": 0})");
const json_editable_view p = d.root()["p"];
const json_editable_view a = p["a"];
d.erase(d.root(), "p");
d.set(a[1], 5);
CHECK(p.dump() == R"({"a":[1,5],"b":3,"e":[]})");
d.set(a, 5);
CHECK(p.size() == 3);
CHECK(p.dump() == R"({"a":5,"b":3,"e":[]})");
d.push_back(p["e"], 6);
CHECK(p.dump() == R"({"a":5,"b":3,"e":[6]})");
CHECK(d.root().dump() == R"({"q":0})");
}
SECTION("an array whose elements moved")
{
json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, 2], "b": 3}, "q": 0})");
const json_editable_view p = d.root()["p"];
const json_editable_view a = p["a"];
d.erase(d.root(), "p");
d.push_back(a, 4); // (the extent of a stays)
d.set(a, 5);
CHECK(p.dump() == R"({"a":5,"b":3})");
CHECK(d.root().dump() == R"({"q":0})");
}
SECTION("an element of an erased array, which grows afterwards")
{
json_editable_document d = json_editable_document::parse(R"({"p": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "q": 0})");
const json_editable_view p = d.root()["p"];
d.erase(d.root(), "p");
d.set(p[0], 5);
d.push_back(p, 1);
CHECK(p.dump() == "[5,1]");
CHECK(d.root().dump() == R"({"q":0})");
}
SECTION("values in an erased new value")
{
json_editable_document d = json_editable_document::parse("[0]");
const json_editable_view x = d.push_back(d.root(), json::parse("[[[1, 2]], 3]"));
const json_editable_view y = x[0];
d.erase(d.root(), 1);
d.set(y[0], 5);
CHECK(x.dump() == "[[5],3]");
d.set(y, 5);
CHECK(x.dump() == "[5,3]");
CHECK(d.root().dump() == "[0]");
}
SECTION("values in the elements that an array had before it was replaced")
{
json_editable_document d = json_editable_document::parse("[0]");
d.set(d.root()[0], json::parse("[[[1, 2]]]"));
const json_editable_view y = d.root()[0][0];
d.set(d.root()[0], json::array({3}));
d.set(y[0], 5);
CHECK(y.dump() == "[5]");
d.set(y, 5);
CHECK(y.dump() == "5");
CHECK(d.root().dump() == "[[3]]");
}
}
#if !defined(JSON_NOEXCEPTION) #if !defined(JSON_NOEXCEPTION)
TEST_CASE("json_view edits: the size of a text arena") TEST_CASE("json_view edits: the size of a text arena")
{ {
+17 -28
View File
@@ -15,7 +15,6 @@ using nlohmann::json;
#include <fstream> #include <fstream>
#include <random> #include <random>
#include <string> #include <string>
#include <vector>
#include "make_test_data_available.hpp" #include "make_test_data_available.hpp"
#include "test_utils.hpp" #include "test_utils.hpp"
@@ -266,50 +265,39 @@ TEST_CASE("Unicode")
CHECK_THROWS_WITH_AS(_ = json::parse("\"\\uD800\\uE000\""), "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\uE000'", json::parse_error&); CHECK_THROWS_WITH_AS(_ = json::parse("\"\\uD800\\uE000\""), "[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\uE000'", json::parse_error&);
} }
}
#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
SECTION("incorrect sequences")
{
SECTION("high surrogate without low surrogate") SECTION("high surrogate without low surrogate")
{ {
// D800..DBFF are high surrogates and must be followed by low // D800..DBFF are high surrogates and must be followed by low
// surrogates DC00..DFFF; here, nothing follows // surrogates DC00..DFFF; here, nothing follows
json _;
for (std::size_t cp = 0xD800u; cp <= 0xDBFFu; ++cp) for (std::size_t cp = 0xD800u; cp <= 0xDBFFu; ++cp)
{ {
const std::string json_text = "\"" + codepoint_to_unicode(cp) + "\""; std::string json_text = "\"" + codepoint_to_unicode(cp) + "\"";
CAPTURE(json_text) CAPTURE(json_text)
CHECK_THROWS_AS(_ = json::parse(json_text), json::parse_error&); CHECK_THROWS_AS(json::parse(json_text), json::parse_error&);
} }
} }
SECTION("high surrogate with wrong low surrogate") SECTION("high surrogate with wrong low surrogate")
{ {
// D800..DBFF are high surrogates and must be followed by low // D800..DBFF are high surrogates and must be followed by low
// surrogates DC00..DFFF; here a different code unit follows. // surrogates DC00..DFFF; here a different sequence follows
// All pairs would be 1024 * 64512 parses, so every high
// surrogate is paired with the boundaries of the ranges around
// DC00..DFFF, and one high surrogate with every code unit
// (with accept(), which does not throw and is much faster)
const auto escaped_pair = [&](std::size_t cp1, std::size_t cp2)
{
return "\"" + codepoint_to_unicode(cp1) + codepoint_to_unicode(cp2) + "\"";
};
const std::vector<std::size_t> boundaries = {0x0000u, 0x0041u, 0xD7FFu, 0xD800u, 0xDBFFu, 0xE000u, 0xFFFFu};
json _;
for (std::size_t cp1 = 0xD800u; cp1 <= 0xDBFFu; ++cp1) for (std::size_t cp1 = 0xD800u; cp1 <= 0xDBFFu; ++cp1)
{ {
for (const std::size_t cp2 : boundaries)
{
const std::string json_text = escaped_pair(cp1, cp2);
CAPTURE(json_text)
CHECK_THROWS_AS(_ = json::parse(json_text), json::parse_error&);
}
}
for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2) for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2)
{ {
if (cp2 < 0xDC00u || cp2 > 0xDFFFu) if (0xDC00u <= cp2 && cp2 <= 0xDFFFu)
{ {
const std::string json_text = escaped_pair(0xDA00u, cp2); continue;
}
std::string json_text = "\"" + codepoint_to_unicode(cp1) + codepoint_to_unicode(cp2) + "\"";
CAPTURE(json_text) CAPTURE(json_text)
CHECK_FALSE(json::accept(json_text)); CHECK_THROWS_AS(json::parse(json_text), json::parse_error&);
} }
} }
} }
@@ -318,15 +306,16 @@ TEST_CASE("Unicode")
{ {
// low surrogates DC00..DFFF must follow high surrogates; here, // low surrogates DC00..DFFF must follow high surrogates; here,
// they occur alone // they occur alone
json _;
for (std::size_t cp = 0xDC00u; cp <= 0xDFFFu; ++cp) for (std::size_t cp = 0xDC00u; cp <= 0xDFFFu; ++cp)
{ {
const std::string json_text = "\"" + codepoint_to_unicode(cp) + "\""; std::string json_text = "\"" + codepoint_to_unicode(cp) + "\"";
CAPTURE(json_text) CAPTURE(json_text)
CHECK_THROWS_AS(_ = json::parse(json_text), json::parse_error&); CHECK_THROWS_AS(json::parse(json_text), json::parse_error&);
} }
} }
} }
#endif
} }
SECTION("read all unicode characters") SECTION("read all unicode characters")