Compare commits

..
Author SHA1 Message Date
Niels Lohmann 4503e5d9bc Copy instead of move when converting an rvalue non-owning range
Converting an rvalue array-like or object-like container to JSON moves its
elements since the rvalue to_json overloads were added. The check only looked
at the value category, so non-owning ranges (gsl::span, absl::Span, span
backports, iterator ranges), which are usually passed by value, had the
elements of the storage they refer to moved out:

    std::vector<std::string> v = {...};
    json j = make_span(v); // v's strings were left empty

Move only from containers that own their elements, detected by deep
constness: the elements of a const std::vector or std::map are const, while a
const span still gives mutable elements. The rvalue overloads still take
every rvalue container and copy the elements of the others, as in 3.12.0;
this also keeps ranges that can only be iterated when not const working.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-16 07:16:10 +01:00
29 changed files with 328 additions and 150 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/benchmarks/json_view/.*"
- "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/(ordered_)?json_(editable_)?(document|view)\\.md"
- "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_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/
cmake -P cmake/scripts/gen_bazel_build_file.cmake
+3 -2
View File
@@ -20,7 +20,7 @@
# fuzzers
/tests/corpus_*
/tests/*_fuzzer
/tests/parse_*_fuzzer
# documentation
/docs/docset/JSON_for_Modern_C++.docset/
@@ -47,10 +47,11 @@ nlohmann_json.spdx
# Bazel-related
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~
/nlohmann_json.natvis~
/single_include/nlohmann/*.hpp~
/venv_astyle/
# release outputs of `make release`
/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).
- `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.
- `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:
+1 -1
View File
@@ -215,7 +215,7 @@ release: include.zip json.tar.xz
# clean up
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
$(MAKE) clean -Cdocs
+77
View File
@@ -406,6 +406,61 @@ add_custom_target(ci_test_clang_sanitizer
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
###############################################################################
@@ -637,6 +692,19 @@ else()
)
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
###############################################################################
@@ -897,3 +965,12 @@ add_custom_target(ci_test_documentation_mermaid
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs/mkdocs
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"
)
@@ -79,7 +79,10 @@ basic_json(basic_json&& other) noexcept;
(e.g., `json j = std::move(vec);` or `json j(std::vector<std::string>{...});`), the elements are moved into
the JSON value instead of copied. Afterwards, the elements of the source container are in a valid but
unspecified state (**moved-from**). Keys of associative containers are `const` and therefore still copied.
Lvalues and `const` rvalues are copied, and the source is left unchanged.
Lvalues and `const` rvalues are copied, and the source is left unchanged. Only containers that own their
elements are moved from, that is, containers whose elements are `const` when accessed through a `const`
container. Non-owning ranges such as spans or iterator ranges (e.g., `gsl::span`, `std::span`) are copied, so
converting an rvalue span leaves the referenced elements unchanged.
- **numbers**: [`number_integer_t`](number_integer_t.md), [`number_unsigned_t`](number_unsigned_t.md),
[`number_float_t`](number_float_t.md), and all convertible number types such as `int`, `size_t`, `int64_t`, `float`
or `double` can be used.
+2 -14
View File
@@ -2,21 +2,12 @@
```cpp
namespace std {
void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2) noexcept(
is_nothrow_move_constructible<nlohmann::basic_json>::value &&
is_nothrow_move_assignable<nlohmann::basic_json>::value
);
void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2);
}
```
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
`j1` (in, out)
@@ -27,9 +18,7 @@ contents.
## Exception safety
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. With the default base class, this function never throws
exceptions.
No-throw guarantee: this function never throws exceptions.
## Complexity
@@ -68,4 +57,3 @@ void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2)
- Added in version 1.0.0.
- 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
1. 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.
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.
1. No-throw guarantee: this function never throws exceptions.
2. No-throw guarantee: this function never throws exceptions.
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.
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
1. Throws only what moving the [`json_base_class_t`](json_base_class_t.md) throws; nothing with the default base class.
2. 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. 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
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
+1 -2
View File
@@ -57,8 +57,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
## Exceptions
- 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
values do not throw.
is false, and `j` contains a non-empty array, object, or binary value.
- 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
[`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.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.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token, or the token
`#!cpp "-"`, which never names an existing element); otherwise (an
[`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token); otherwise (an
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)
@@ -62,9 +62,10 @@ view.
!!! info "Overload 2 never throws"
Like [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), overload 2 never throws: a
missing key, 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`.
Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
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
@@ -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
references into an existing object, a view's `item` is produced on the fly for each step of the iteration and is
cheap to copy. A `#!cpp const auto&` (as in the first snippet) also works, as it binds to that temporary, but a
non-const `#!cpp auto&` does not compile.
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, so there
is nothing for a reference to bind to.
## Return value
@@ -7,10 +7,6 @@ bool operator==(const basic_json_view& lhs, const basic_json_view& rhs);
// (2)
bool operator==(const basic_json_view& lhs, const BasicJsonType& 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
@@ -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
produce for the view and the other operand are equal, according to `BasicJsonType`'s
[`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
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*
@@ -7,17 +7,11 @@ bool operator!=(const basic_json_view& lhs, const basic_json_view& rhs);
// (2)
bool operator!=(const basic_json_view& lhs, const BasicJsonType& 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).
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).
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
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
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.
- `#!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
@@ -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
[`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),
[`insert`](basic_json_document/insert.md), and [`erase`](basic_json_document/erase.md) change values after parsing,
without ever rewriting the source text — see [Edits](basic_json_document/index.md#edits) and
[`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) change values after
parsing, without ever rewriting the source text — see [Edits](basic_json_document/index.md#edits) and
[Editing a document](../features/json_view/editing.md).
## 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
[`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
[`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) can change, with every view
[`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) can change, with every view
still referring to it seeing the change, see [Edits](basic_json_document/index.md#edits).
## Examples
@@ -171,7 +171,7 @@ See the examples below for the concrete generated code.
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"
```
@@ -69,7 +69,7 @@ For further information please refer to the corresponding macros without `WITH_N
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"
```
+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`
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
`<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
+2 -2
View File
@@ -1,7 +1,7 @@
# Recipes for Common Types
The library converts the standard containers, strings, numbers, tuples, `std::optional` (since version 3.12.0), and
`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 library converts the standard containers, strings, numbers, tuples, `std::optional`, and `std::filesystem::path`
(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,
`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.
+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
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),
[`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.
[`back`](../api/json_pointer/back.md) or [`pop_back`](../api/json_pointer/pop_back.md).
!!! failure "Example message"
@@ -1265,9 +1263,9 @@ A JSON Patch operation 'test' failed. The unsuccessful operation is also printed
### 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
`use_type = true` but `use_size = false`, and the value contains a non-empty array, object, or binary value (with
BJData Draft 3, any binary value, including an empty one). UBJSON requires a size marker (`#`) after a type marker
(`$`); scalars and empty arrays or objects do not throw.
`use_type = true` but `use_size = false`, and the value contains a non-empty array or object (or, with BJData Draft 3,
any binary value). UBJSON requires a size marker (`#`) after a type marker (`$`); scalars and empty arrays or objects
do not throw.
!!! failure "Example message"
+3 -1
View File
@@ -7,7 +7,9 @@ These changes are part of the `develop` branch, but not of a release yet.
2.3 ms). Two consequences: the source container is left in a valid but unspecified (moved-from) state, and if an
exception is thrown during the conversion, the source may be partially moved-from, so the strong exception guarantee
no longer holds for the source of an rvalue conversion (the JSON value itself is unaffected). Lvalues and `const`
objects are still copied. See [`basic_json`](../../api/basic_json/basic_json.md).
objects are still copied, and so are non-owning ranges such as spans (a range whose elements stay mutable through a
`const` range): converting an rvalue span leaves the referenced elements unchanged.
See [`basic_json`](../../api/basic_json/basic_json.md).
- In C++20 (library support for `char8_t`, `__cpp_lib_char8_t`), a `#!cpp std::u8string` is a JSON **string**:
`json j = std::u8string(u8"abc");` stores `"abc"`, and `#!cpp j.get<std::u8string>()` reads it back. Version 3.12.0
stored a `#!cpp std::u8string` as an array of code units (`[97,98,99]`); on the 3.13.0 development branch it was
+39 -21
View File
@@ -48,30 +48,47 @@ namespace detail
* leave j with the type of the new value, but the pointer to the destroyed old one.
*/
// a move iterator over the elements of an rvalue container, unless they are
// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a
// std::move_iterator as value_type&&, which cannot bind to a const element
template<typename Iterator>
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
{
return std::make_move_iterator(it);
}
// reference type of the elements of a const T
template<typename T>
using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
template<typename Iterator>
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/)
{
return it;
}
// a container that owns its elements propagates constness to them (deep
// constness): the elements of a const std::vector<std::string> are const. A
// non-owning range (a span, an iterator range) has shallow constness: a const
// span still gives mutable access to the elements it refers to. Moving from an
// rvalue of such a range would empty the storage it refers to, so the elements
// of an rvalue range are only moved if it has deep constness.
template<typename T>
using owns_its_elements = std::is_const<typename std::remove_reference<detected_t<const_range_reference_t, T>>::type>;
template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
// a move iterator over the elements of an rvalue container that owns them,
// unless they are const (e.g., std::set): libstdc++ before GCC 5 defines the
// reference of a std::move_iterator as value_type&&, which cannot bind to a
// const element
template<typename Iterator>
auto make_move_iterator_if_mutable(const Iterator& it)
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
{
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {});
return std::make_move_iterator(it);
}
template<typename Iterator>
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
{
return it;
}
template<typename Container, typename Iterator>
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
template<typename Container, typename Iterator>
auto make_move_iterator_if_owned(const Iterator& it)
-> decltype(make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {}))
{
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
}
template<value_t> struct external_constructor;
@@ -193,14 +210,14 @@ struct external_constructor<value_t::array>
j.replace_value(value_t::array, value);
}
/// an rvalue container: move its elements
/// an rvalue container: move its elements if it owns them
template<typename BasicJsonType, typename CompatibleArrayType>
static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
j.replace_value(value_t::array, value);
}
@@ -254,14 +271,14 @@ struct external_constructor<value_t::object>
j.replace_value(value_t::object, value);
}
/// an rvalue container: move its values
/// an rvalue container: move its values if it owns them
template<typename BasicJsonType, typename CompatibleObjectType>
static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
j.replace_value(value_t::object, value);
}
@@ -456,7 +473,8 @@ using is_rvalue_array_to_json = conjunction<is_movable_container_rvalue<T>,
is_compatible_string_type<BasicJsonType, T>,
is_compatible_binary_type<BasicJsonType, T>>>>;
// rvalue containers: their elements are moved instead of copied
// rvalue containers: their elements are moved instead of copied if the
// container owns them (see owns_its_elements)
template<typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward)
+1 -1
View File
@@ -50,7 +50,6 @@
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#undef JSON_HEDLEY_END_C_DECLS
#undef JSON_HEDLEY_FALL_THROUGH
#undef JSON_HEDLEY_FLAGS
#undef JSON_HEDLEY_FLAGS_CAST
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
@@ -159,3 +158,4 @@
#undef JSON_HEDLEY_WARNING
#undef JSON_HEDLEY_WARN_UNUSED_RESULT
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
#undef JSON_HEDLEY_FALL_THROUGH
+40 -22
View File
@@ -7810,30 +7810,47 @@ namespace detail
* leave j with the type of the new value, but the pointer to the destroyed old one.
*/
// a move iterator over the elements of an rvalue container, unless they are
// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a
// std::move_iterator as value_type&&, which cannot bind to a const element
template<typename Iterator>
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
{
return std::make_move_iterator(it);
}
// reference type of the elements of a const T
template<typename T>
using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
template<typename Iterator>
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/)
{
return it;
}
// a container that owns its elements propagates constness to them (deep
// constness): the elements of a const std::vector<std::string> are const. A
// non-owning range (a span, an iterator range) has shallow constness: a const
// span still gives mutable access to the elements it refers to. Moving from an
// rvalue of such a range would empty the storage it refers to, so the elements
// of an rvalue range are only moved if it has deep constness.
template<typename T>
using owns_its_elements = std::is_const<typename std::remove_reference<detected_t<const_range_reference_t, T>>::type>;
template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
// a move iterator over the elements of an rvalue container that owns them,
// unless they are const (e.g., std::set): libstdc++ before GCC 5 defines the
// reference of a std::move_iterator as value_type&&, which cannot bind to a
// const element
template<typename Iterator>
auto make_move_iterator_if_mutable(const Iterator& it)
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
{
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {});
return std::make_move_iterator(it);
}
template<typename Iterator>
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
{
return it;
}
template<typename Container, typename Iterator>
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
template<typename Container, typename Iterator>
auto make_move_iterator_if_owned(const Iterator& it)
-> decltype(make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {}))
{
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
}
template<value_t> struct external_constructor;
@@ -7955,14 +7972,14 @@ struct external_constructor<value_t::array>
j.replace_value(value_t::array, value);
}
/// an rvalue container: move its elements
/// an rvalue container: move its elements if it owns them
template<typename BasicJsonType, typename CompatibleArrayType>
static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
j.replace_value(value_t::array, value);
}
@@ -8016,14 +8033,14 @@ struct external_constructor<value_t::object>
j.replace_value(value_t::object, value);
}
/// an rvalue container: move its values
/// an rvalue container: move its values if it owns them
template<typename BasicJsonType, typename CompatibleObjectType>
static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
j.replace_value(value_t::object, value);
}
@@ -8218,7 +8235,8 @@ using is_rvalue_array_to_json = conjunction<is_movable_container_rvalue<T>,
is_compatible_string_type<BasicJsonType, T>,
is_compatible_binary_type<BasicJsonType, T>>>>;
// rvalue containers: their elements are moved instead of copied
// rvalue containers: their elements are moved instead of copied if the
// container owns them (see owns_its_elements)
template<typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward)
@@ -48757,7 +48775,6 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#undef JSON_HEDLEY_END_C_DECLS
#undef JSON_HEDLEY_FALL_THROUGH
#undef JSON_HEDLEY_FLAGS
#undef JSON_HEDLEY_FLAGS_CAST
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
@@ -48866,6 +48883,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
#undef JSON_HEDLEY_WARNING
#undef JSON_HEDLEY_WARN_UNUSED_RESULT
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
#undef JSON_HEDLEY_FALL_THROUGH
// IWYU pragma: keep
+109
View File
@@ -67,6 +67,67 @@ void to_json(json& j, tracked&& t)
t.moved_from = true;
}
// non-owning range over contiguous storage (like gsl::span or a pre-C++20 span
// backport): its constness is shallow, so a const span gives mutable elements
template<typename T>
struct span_like
{
using value_type = T;
using iterator = T*;
using const_iterator = T*;
T* first;
T* last;
T* begin() const
{
return first;
}
T* end() const
{
return last;
}
};
// non-owning view of key/value pairs with key_type and mapped_type, so it is
// converted like an object
template<typename K, typename V>
struct map_span_like
{
using key_type = K;
using mapped_type = V;
using value_type = std::pair<const K, V>;
using iterator = value_type*;
using const_iterator = value_type*;
value_type* first;
value_type* last;
value_type* begin() const
{
return first;
}
value_type* end() const
{
return last;
}
};
// owning container that can only be iterated when it is not const
struct mutable_only_range
{
std::vector<std::string> values;
std::vector<std::string>::iterator begin()
{
return values.begin();
}
std::vector<std::string>::iterator end()
{
return values.end();
}
};
// user type with its own rvalue-aware serializer
struct udt_container
{
@@ -144,6 +205,34 @@ TEST_CASE("to_json from rvalue containers")
CHECK(tracked_moves == 2);
}
SECTION("tracked elements: standard containers move")
{
tracked_copies = 0;
tracked_moves = 0;
std::list<tracked> l;
l.emplace_back("l");
CHECK(json(std::move(l)) == json::array({"l"}));
std::deque<tracked> d;
d.emplace_back("d");
CHECK(json(std::move(d)) == json::array({"d"}));
std::forward_list<tracked> fl;
fl.emplace_front("f");
CHECK(json(std::move(fl)) == json::array({"f"}));
std::array<tracked, 1> a{{tracked("a")}};
CHECK(json(std::move(a)) == json::array({"a"}));
std::unordered_map<std::string, tracked> um;
um.emplace("k", tracked("u"));
CHECK(json(std::move(um)) == json({{"k", "u"}}));
CHECK(tracked_moves == 5);
CHECK(tracked_copies == 0);
}
SECTION("const rvalue is copied")
{
tracked_copies = 0;
@@ -221,6 +310,26 @@ TEST_CASE("to_json from rvalue containers")
CHECK(json(std::move(obj)) == json({{"a", 1}}));
}
SECTION("non-owning ranges are copied")
{
std::vector<std::string> v{long_a, long_b};
const json j = span_like<std::string> {v.data(), v.data() + v.size()};
CHECK(j == json::array({long_a, long_b}));
CHECK(v[0] == long_a);
CHECK(v[1] == long_b);
std::vector<std::pair<const std::string, std::string>> m{{"a", long_a}};
const json jm = map_span_like<std::string, std::string> {m.data(), m.data() + m.size()};
CHECK(jm == json({{"a", long_a}}));
CHECK(m[0].second == long_a);
// without a const begin(), it cannot be told whether the range owns
// its elements, so they are copied
mutable_only_range r{{long_a}};
CHECK(json(std::move(r)) == json::array({long_a}));
CHECK(r.values[0] == long_a); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
}
SECTION("user type with its own to_json overloads")
{
udt_container c{{1, 2}};
+19 -30
View File
@@ -15,7 +15,6 @@ using nlohmann::json;
#include <fstream>
#include <random>
#include <string>
#include <vector>
#include "make_test_data_available.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&);
}
}
#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
SECTION("incorrect sequences")
{
SECTION("high surrogate without low surrogate")
{
// D800..DBFF are high surrogates and must be followed by low
// surrogates DC00..DFFF; here, nothing follows
json _;
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)
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")
{
// D800..DBFF are high surrogates and must be followed by low
// surrogates DC00..DFFF; here a different code unit 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 _;
// surrogates DC00..DFFF; here a different sequence follows
for (std::size_t cp1 = 0xD800u; cp1 <= 0xDBFFu; ++cp1)
{
for (const std::size_t cp2 : boundaries)
for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2)
{
const std::string json_text = escaped_pair(cp1, cp2);
if (0xDC00u <= cp2 && cp2 <= 0xDFFFu)
{
continue;
}
std::string json_text = "\"" + codepoint_to_unicode(cp1) + codepoint_to_unicode(cp2) + "\"";
CAPTURE(json_text)
CHECK_THROWS_AS(_ = json::parse(json_text), json::parse_error&);
}
}
for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2)
{
if (cp2 < 0xDC00u || cp2 > 0xDFFFu)
{
const std::string json_text = escaped_pair(0xDA00u, cp2);
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,
// they occur alone
json _;
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)
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")