mirror of
https://github.com/nlohmann/json.git
synced 2026-11-17 09:01:28 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
29f1df793f |
No files matched your search
+1
-1
@@ -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\\.md"
|
||||
- "docs/mkdocs/docs/features/json_view/.*"
|
||||
- "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)).*"
|
||||
|
||||
@@ -115,9 +115,7 @@ 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 .
|
||||
# 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 .
|
||||
python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/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
|
||||
|
||||
+2
-3
@@ -20,7 +20,7 @@
|
||||
|
||||
# fuzzers
|
||||
/tests/corpus_*
|
||||
/tests/parse_*_fuzzer
|
||||
/tests/*_fuzzer
|
||||
|
||||
# documentation
|
||||
/docs/docset/JSON_for_Modern_C++.docset/
|
||||
@@ -47,11 +47,10 @@ nlohmann_json.spdx
|
||||
# Bazel-related
|
||||
MODULE.bazel.lock
|
||||
|
||||
# backups left by `make check-amalgamation` or the ci_test_amalgamation target if they are interrupted
|
||||
# backups left by `make check-amalgamation` if it is interrupted
|
||||
/BUILD.bazel~
|
||||
/nlohmann_json.natvis~
|
||||
/single_include/nlohmann/*.hpp~
|
||||
/venv_astyle/
|
||||
|
||||
# release outputs of `make release`
|
||||
/include.zip
|
||||
|
||||
@@ -28,6 +28,7 @@ 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:
|
||||
|
||||
|
||||
@@ -215,7 +215,7 @@ release: include.zip json.tar.xz
|
||||
|
||||
# clean up
|
||||
clean:
|
||||
rm -fr *.dSYM tests/*.dSYM tests/parse_*_fuzzer
|
||||
rm -fr *.dSYM tests/*.dSYM tests/*_fuzzer
|
||||
rm -fr cmake-build-benchmarks cmake-build-pvs-studio release_files
|
||||
$(MAKE) clean -Cdocs
|
||||
|
||||
|
||||
@@ -406,61 +406,6 @@ 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
|
||||
###############################################################################
|
||||
@@ -692,19 +637,6 @@ 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
|
||||
###############################################################################
|
||||
@@ -965,12 +897,3 @@ 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,10 +79,7 @@ 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. 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.
|
||||
Lvalues and `const` rvalues are copied, and the source is left 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,12 +2,21 @@
|
||||
|
||||
```cpp
|
||||
namespace std {
|
||||
void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2);
|
||||
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
|
||||
);
|
||||
}
|
||||
```
|
||||
|
||||
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)
|
||||
@@ -18,7 +27,9 @@ Exchanges the values of two JSON objects.
|
||||
|
||||
## Exception safety
|
||||
|
||||
No-throw guarantee: this function never throws exceptions.
|
||||
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.
|
||||
|
||||
## Complexity
|
||||
|
||||
@@ -57,3 +68,4 @@ 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.
|
||||
@@ -75,8 +75,12 @@ void swap(typename binary_t::container_type& other);
|
||||
|
||||
## Exception safety
|
||||
|
||||
1. No-throw guarantee: this function never throws exceptions.
|
||||
2. No-throw guarantee: this function never throws exceptions.
|
||||
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.
|
||||
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.
|
||||
@@ -85,8 +89,8 @@ void swap(typename binary_t::container_type& other);
|
||||
|
||||
## Exceptions
|
||||
|
||||
1. No-throw guarantee: this function never throws exceptions.
|
||||
2. No-throw guarantee: this function never throws 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.
|
||||
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
|
||||
|
||||
@@ -57,7 +57,8 @@ 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.
|
||||
is false, and `j` contains a non-empty array, object, or binary value. Scalars and empty arrays, objects, or binary
|
||||
values do not throw.
|
||||
- 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,7 +66,8 @@ 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); otherwise (an
|
||||
[`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
|
||||
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,10 +62,9 @@ view.
|
||||
|
||||
!!! info "Overload 2 never throws"
|
||||
|
||||
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`.
|
||||
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`.
|
||||
|
||||
## Examples
|
||||
|
||||
|
||||
@@ -27,9 +27,10 @@ for (const auto [key, value] : v.items())
|
||||
}
|
||||
```
|
||||
|
||||
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.
|
||||
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.
|
||||
|
||||
## Return value
|
||||
|
||||
|
||||
@@ -7,6 +7,10 @@ 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
|
||||
@@ -14,8 +18,12 @@ bool operator==(const BasicJsonType& lhs, const basic_json_view& rhs);
|
||||
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`.
|
||||
|
||||
Neither overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers
|
||||
No 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,11 +7,17 @@ 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,6 +15,10 @@ 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,8 +8,9 @@ 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) 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
|
||||
[`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
|
||||
[Editing a document](../features/json_view/editing.md).
|
||||
|
||||
## Examples
|
||||
|
||||
@@ -9,7 +9,8 @@ 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) and [`push_back`](basic_json_document/push_back.md) can change, with every view
|
||||
[`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
|
||||
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 22 23 24 25 26 27 28"
|
||||
```cpp hl_lines="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"
|
||||
```cpp hl_lines="16 17 18 19 20 21 22 23 24 25 26 27 28 29 30"
|
||||
--8<-- "examples/nlohmann_define_type_non_intrusive_with_names_explicit.cpp"
|
||||
```
|
||||
|
||||
|
||||
@@ -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.12.0, JSON values can be formatted directly with C++20's
|
||||
Since version 3.13.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
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# Recipes for Common Types
|
||||
|
||||
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 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 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.
|
||||
|
||||
@@ -987,7 +987,9 @@ 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
|
||||
[`back`](../api/json_pointer/back.md) or [`pop_back`](../api/json_pointer/pop_back.md).
|
||||
[`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.
|
||||
|
||||
!!! failure "Example message"
|
||||
|
||||
@@ -1263,9 +1265,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 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.
|
||||
`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.
|
||||
|
||||
!!! failure "Example message"
|
||||
|
||||
|
||||
@@ -7,9 +7,7 @@ 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, 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).
|
||||
objects are still copied. 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
|
||||
|
||||
@@ -48,47 +48,30 @@ namespace detail
|
||||
* leave j with the type of the new value, but the pointer to the destroyed old one.
|
||||
*/
|
||||
|
||||
// reference type of the elements of a const T
|
||||
template<typename T>
|
||||
using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
|
||||
|
||||
// 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>;
|
||||
|
||||
// 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>
|
||||
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>
|
||||
std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
|
||||
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
|
||||
{
|
||||
return std::make_move_iterator(it);
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
|
||||
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/)
|
||||
{
|
||||
return it;
|
||||
}
|
||||
|
||||
template<typename Container, typename Iterator>
|
||||
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
|
||||
template<typename Iterator>
|
||||
using is_mutable_iterator = std::integral_constant < bool,
|
||||
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
|
||||
|
||||
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> {}))
|
||||
template<typename Iterator>
|
||||
auto make_move_iterator_if_mutable(const Iterator& it)
|
||||
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
|
||||
{
|
||||
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
|
||||
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {});
|
||||
}
|
||||
|
||||
template<value_t> struct external_constructor;
|
||||
@@ -210,14 +193,14 @@ struct external_constructor<value_t::array>
|
||||
j.replace_value(value_t::array, value);
|
||||
}
|
||||
|
||||
/// an rvalue container: move its elements if it owns them
|
||||
/// an rvalue container: move its elements
|
||||
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_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
|
||||
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))));
|
||||
j.replace_value(value_t::array, value);
|
||||
}
|
||||
|
||||
@@ -271,14 +254,14 @@ struct external_constructor<value_t::object>
|
||||
j.replace_value(value_t::object, value);
|
||||
}
|
||||
|
||||
/// an rvalue container: move its values if it owns them
|
||||
/// an rvalue container: move its values
|
||||
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_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
|
||||
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))));
|
||||
j.replace_value(value_t::object, value);
|
||||
}
|
||||
|
||||
@@ -473,8 +456,7 @@ 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 if the
|
||||
// container owns them (see owns_its_elements)
|
||||
// rvalue containers: their elements are moved instead of copied
|
||||
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
@@ -50,6 +50,7 @@
|
||||
#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
|
||||
@@ -158,4 +159,3 @@
|
||||
#undef JSON_HEDLEY_WARNING
|
||||
#undef JSON_HEDLEY_WARN_UNUSED_RESULT
|
||||
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
|
||||
#undef JSON_HEDLEY_FALL_THROUGH
|
||||
Generated
+18
-36
@@ -7810,47 +7810,30 @@ namespace detail
|
||||
* leave j with the type of the new value, but the pointer to the destroyed old one.
|
||||
*/
|
||||
|
||||
// reference type of the elements of a const T
|
||||
template<typename T>
|
||||
using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
|
||||
|
||||
// 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>;
|
||||
|
||||
// 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>
|
||||
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>
|
||||
std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
|
||||
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
|
||||
{
|
||||
return std::make_move_iterator(it);
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
|
||||
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/)
|
||||
{
|
||||
return it;
|
||||
}
|
||||
|
||||
template<typename Container, typename Iterator>
|
||||
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
|
||||
template<typename Iterator>
|
||||
using is_mutable_iterator = std::integral_constant < bool,
|
||||
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
|
||||
|
||||
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> {}))
|
||||
template<typename Iterator>
|
||||
auto make_move_iterator_if_mutable(const Iterator& it)
|
||||
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
|
||||
{
|
||||
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
|
||||
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {});
|
||||
}
|
||||
|
||||
template<value_t> struct external_constructor;
|
||||
@@ -7972,14 +7955,14 @@ struct external_constructor<value_t::array>
|
||||
j.replace_value(value_t::array, value);
|
||||
}
|
||||
|
||||
/// an rvalue container: move its elements if it owns them
|
||||
/// an rvalue container: move its elements
|
||||
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_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
|
||||
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))));
|
||||
j.replace_value(value_t::array, value);
|
||||
}
|
||||
|
||||
@@ -8033,14 +8016,14 @@ struct external_constructor<value_t::object>
|
||||
j.replace_value(value_t::object, value);
|
||||
}
|
||||
|
||||
/// an rvalue container: move its values if it owns them
|
||||
/// an rvalue container: move its values
|
||||
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_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
|
||||
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))));
|
||||
j.replace_value(value_t::object, value);
|
||||
}
|
||||
|
||||
@@ -8235,8 +8218,7 @@ 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 if the
|
||||
// container owns them (see owns_its_elements)
|
||||
// rvalue containers: their elements are moved instead of copied
|
||||
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)
|
||||
@@ -48775,6 +48757,7 @@ 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
|
||||
@@ -48883,7 +48866,6 @@ 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
|
||||
|
||||
|
||||
@@ -67,67 +67,6 @@ 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
|
||||
{
|
||||
@@ -205,34 +144,6 @@ 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;
|
||||
@@ -310,26 +221,6 @@ 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}};
|
||||
|
||||
+30
-19
@@ -15,6 +15,7 @@ using nlohmann::json;
|
||||
#include <fstream>
|
||||
#include <random>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "make_test_data_available.hpp"
|
||||
#include "test_utils.hpp"
|
||||
|
||||
@@ -265,39 +266,50 @@ 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)
|
||||
{
|
||||
std::string json_text = "\"" + codepoint_to_unicode(cp) + "\"";
|
||||
const 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 sequence follows
|
||||
// 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 _;
|
||||
for (std::size_t cp1 = 0xD800u; cp1 <= 0xDBFFu; ++cp1)
|
||||
{
|
||||
for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2)
|
||||
for (const std::size_t cp2 : boundaries)
|
||||
{
|
||||
if (0xDC00u <= cp2 && cp2 <= 0xDFFFu)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string json_text = "\"" + codepoint_to_unicode(cp1) + codepoint_to_unicode(cp2) + "\"";
|
||||
const std::string json_text = escaped_pair(cp1, cp2);
|
||||
CAPTURE(json_text)
|
||||
CHECK_THROWS_AS(json::parse(json_text), json::parse_error&);
|
||||
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));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -306,16 +318,15 @@ 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)
|
||||
{
|
||||
std::string json_text = "\"" + codepoint_to_unicode(cp) + "\"";
|
||||
const 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")
|
||||
|
||||
Reference in new issue
Block a user