From 99ae1d0d033a2de0473077016119163e36851eb9 Mon Sep 17 00:00:00 2001 From: Niels Lohmann Date: Sun, 4 Oct 2026 12:44:49 +0200 Subject: [PATCH] Add JSON_DELETE_DEPRECATED_FUNCTIONS to delete the deprecated functions Defining JSON_DELETE_DEPRECATED_FUNCTIONS to 1 (or the CMake option JSON_DeleteDeprecatedFunctions) declares every deprecated function as deleted instead of deprecated, so that code that is not ready for 4.0.0 no longer compiles. A deleted function still takes part in overload resolution, so from_*(ptr, len) cannot silently bind len to the strict parameter of from_*(InputType&&, bool); the roadmap now plans to keep these overloads deleted in 4.0.0 instead of removing them. The legacy discarded-value comparison is left to its own macro. Also update the 4.0 roadmap: add JSON_DISABLE_TUPLE_REFERENCE_CONVERSION and JSON_DELETE_DEPRECATED_FUNCTIONS to the macro table, add the from_bjdata/from_bon8 (ptr, len) overloads to the deprecated functions, document the macro in the migration guide, and fix the docs style check findings (example titles, missing docset entry for JSON_STRICT_BINARY_UTF8). Signed-off-by: Niels Lohmann --- .github/workflows/ubuntu.yml | 2 +- CMakeLists.txt | 6 + cmake/ci.cmake | 16 +- docs/docset/docSet.sql | 2 + docs/mkdocs/docs/api/macros/index.md | 5 + .../json_delete_deprecated_functions.md | 96 ++++++++ ...json_disable_tuple_reference_conversion.md | 1 + .../api/macros/json_strict_binary_utf8.md | 4 +- .../macros/json_use_implicit_conversions.md | 4 +- docs/mkdocs/docs/community/roadmap.md | 14 +- docs/mkdocs/docs/features/macros.md | 14 +- docs/mkdocs/docs/integration/cmake.md | 6 + .../docs/integration/migration_guide.md | 13 +- docs/mkdocs/mkdocs.yml | 1 + include/nlohmann/detail/json_pointer.hpp | 28 +++ include/nlohmann/detail/macro_scope.hpp | 4 + include/nlohmann/detail/macro_unscope.hpp | 1 + include/nlohmann/json.hpp | 129 +++++++++++ single_include/nlohmann/json.hpp | 162 +++++++++++++ tests/src/unit-bjdata.cpp | 10 + tests/src/unit-bon8.cpp | 10 + tests/src/unit-bson.cpp | 12 + tests/src/unit-cbor.cpp | 12 + .../src/unit-delete_deprecated_functions.cpp | 214 ++++++++++++++++++ tests/src/unit-deserialization.cpp | 16 +- tests/src/unit-items.cpp | 10 + tests/src/unit-json_pointer.cpp | 23 +- tests/src/unit-msgpack.cpp | 12 + tests/src/unit-regression2.cpp | 2 +- tests/src/unit-serialization.cpp | 10 + tests/src/unit-ubjson.cpp | 12 + 31 files changed, 833 insertions(+), 18 deletions(-) create mode 100644 docs/mkdocs/docs/api/macros/json_delete_deprecated_functions.md create mode 100644 tests/src/unit-delete_deprecated_functions.cpp diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml index f5addb92e..8093face2 100644 --- a/.github/workflows/ubuntu.yml +++ b/.github/workflows/ubuntu.yml @@ -107,7 +107,7 @@ jobs: container: ubuntu:24.04 strategy: matrix: - target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local] + target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_delete_deprecated_functions, ci_test_no_thread_local] steps: - name: Install build-essential run: apt-get update ; apt-get install -y build-essential unzip wget git diff --git a/CMakeLists.txt b/CMakeLists.txt index b5092ae49..a2501a92d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,6 +62,7 @@ option(JSON_MultipleHeaders "Use non-amalgamated version of the l option(JSON_SystemInclude "Include as system headers (skip for clang-tidy)." OFF) option(JSON_StrictNulHandling "Build with strict NUL-byte handling enabled." OFF) option(JSON_StrictBinaryUTF8 "Build with UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers enabled." OFF) +option(JSON_DeleteDeprecatedFunctions "Delete the deprecated functions instead of only deprecating them." OFF) if (JSON_CI) include(ci) @@ -123,6 +124,10 @@ if (JSON_StrictBinaryUTF8) message(STATUS "Strict UTF-8 checks in binary writers enabled (JSON_STRICT_BINARY_UTF8=1)") endif() +if (JSON_DeleteDeprecatedFunctions) + message(STATUS "Deprecated functions are deleted (JSON_DELETE_DEPRECATED_FUNCTIONS=1)") +endif() + if (JSON_Diagnostic_Positions) message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)") endif() @@ -159,6 +164,7 @@ target_compile_definitions( $<$:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1> $<$:JSON_STRICT_NUL_HANDLING=1> $<$:JSON_STRICT_BINARY_UTF8=1> + $<$:JSON_DELETE_DEPRECATED_FUNCTIONS=1> ) target_include_directories( diff --git a/cmake/ci.cmake b/cmake/ci.cmake index 2aceb5afd..8e11bcb3c 100644 --- a/cmake/ci.cmake +++ b/cmake/ci.cmake @@ -249,6 +249,20 @@ add_custom_target(ci_test_strict_nul_handling COMMENT "Compile and test with strict NUL-byte handling enabled" ) +############################################################################### +# Delete the deprecated functions. +############################################################################### + +add_custom_target(ci_test_delete_deprecated_functions + COMMAND ${CMAKE_COMMAND} + -DCMAKE_BUILD_TYPE=Debug -GNinja + -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DeleteDeprecatedFunctions=ON + -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_delete_deprecated_functions + COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions + COMMAND cd ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure + COMMENT "Compile and test with the deprecated functions deleted" +) + ############################################################################### # Disable global UDLs. ############################################################################### @@ -701,7 +715,7 @@ ci_get_cmake(4.0.0 CMAKE_4_0_0_BINARY) # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind - JSON_StrictNulHandling JSON_StrictBinaryUTF8) + JSON_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions) set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0}) set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0}) diff --git a/docs/docset/docSet.sql b/docs/docset/docSet.sql index 09802e43e..9fc5f7e3d 100644 --- a/docs/docset/docSet.sql +++ b/docs/docset/docSet.sql @@ -219,6 +219,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', ' INSERT INTO searchIndex(name, type, path) VALUES ('JSON_ASSERT', 'Macro', 'api/macros/json_assert/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_BRACE_INIT_COPY_SEMANTICS', 'Macro', 'api/macros/json_brace_init_copy_semantics/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_CATCH_USER', 'Macro', 'api/macros/json_throw_user/index.html'); +INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DELETE_DEPRECATED_FUNCTIONS', 'Macro', 'api/macros/json_delete_deprecated_functions/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTICS', 'Macro', 'api/macros/json_diagnostics/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTIC_POSITIONS', 'Macro', 'api/macros/json_diagnostic_positions/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DISABLE_ENUM_SERIALIZATION', 'Macro', 'api/macros/json_disable_enum_serialization/index.html'); @@ -242,6 +243,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_NO_THREAD_LOCAL', 'Macro INSERT INTO searchIndex(name, type, path) VALUES ('JSON_PRECISE_STREAM_POSITION', 'Macro', 'api/macros/json_precise_stream_position/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_SKIP_LIBRARY_VERSION_CHECK', 'Macro', 'api/macros/json_skip_library_version_check/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_SKIP_UNSUPPORTED_COMPILER_CHECK', 'Macro', 'api/macros/json_skip_unsupported_compiler_check/index.html'); +INSERT INTO searchIndex(name, type, path) VALUES ('JSON_STRICT_BINARY_UTF8', 'Macro', 'api/macros/json_strict_binary_utf8/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_STRICT_NUL_HANDLING', 'Macro', 'api/macros/json_strict_nul_handling/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_THROW_USER', 'Macro', 'api/macros/json_throw_user/index.html'); INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api/macros/json_throw_user/index.html'); diff --git a/docs/mkdocs/docs/api/macros/index.md b/docs/mkdocs/docs/api/macros/index.md index 872d6cb8c..406aa255b 100644 --- a/docs/mkdocs/docs/api/macros/index.md +++ b/docs/mkdocs/docs/api/macros/index.md @@ -59,6 +59,11 @@ header. See also the [macro overview page](../../features/macros.md). - [**JSON_DISABLE_TUPLE_REFERENCE_CONVERSION**](json_disable_tuple_reference_conversion.md) - switch off conversion from a one-element tuple of a JSON reference - [**JSON_USE_IMPLICIT_CONVERSIONS**](json_use_implicit_conversions.md) - control implicit conversions +## Deprecated functions + +- [**JSON_DELETE_DEPRECATED_FUNCTIONS**](json_delete_deprecated_functions.md) - opt in to deleting the deprecated + functions ahead of their removal in version 4.0.0 + ## Comparison behavior - [**JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON**](json_use_legacy_discarded_value_comparison.md) - diff --git a/docs/mkdocs/docs/api/macros/json_delete_deprecated_functions.md b/docs/mkdocs/docs/api/macros/json_delete_deprecated_functions.md new file mode 100644 index 000000000..20f0ead0c --- /dev/null +++ b/docs/mkdocs/docs/api/macros/json_delete_deprecated_functions.md @@ -0,0 +1,96 @@ +# JSON_DELETE_DEPRECATED_FUNCTIONS + +```cpp +#define JSON_DELETE_DEPRECATED_FUNCTIONS /* value */ +``` + +When defined to `1`, all [deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) of the +library are declared as deleted (`= delete`) instead of only being marked as deprecated. Code that still calls one of +them no longer compiles. This way, you can find all calls that need to be replaced before version 4.0.0 removes these +functions; the [migration guide](../../integration/migration_guide.md#replace-deprecated-functions) describes how. + +A deleted function, unlike a removed one, still takes part in overload resolution. A call that would select it +therefore fails to compile instead of silently selecting another overload. This matters for the deprecated +`from_*(ptr, len)` overloads of [`from_cbor`](../basic_json/from_cbor.md), [`from_msgpack`](../basic_json/from_msgpack.md), +[`from_ubjson`](../basic_json/from_ubjson.md), [`from_bjdata`](../basic_json/from_bjdata.md), +[`from_bon8`](../basic_json/from_bon8.md), and [`from_bson`](../basic_json/from_bson.md): without them, a call like +`from_cbor(ptr, len)` would compile, read `ptr` as a NUL-terminated string, and convert `len` to the `strict` parameter. + +The macro does not affect the deprecated legacy comparison of discarded values, which is controlled by +[`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](json_use_legacy_discarded_value_comparison.md). + +## Default definition + +The default value is `0` (disabled, the deprecated functions can still be called, and the compiler warns about it). + +```cpp +#define JSON_DELETE_DEPRECATED_FUNCTIONS 0 +``` + +## Notes + +!!! info "CMake option" + + The macro can also be set with the CMake option + [`JSON_DeleteDeprecatedFunctions`](../../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default). + +!!! warning "Opt-in only" + + This macro must be defined **before** including ``. Defining it after the include has no + effect. Define it for the whole project to avoid different declarations of the same class in different + translation units. + +!!! note "ABI compatibility" + + The macro only turns calls that compile into calls that do not; it does not change the layout or the behavior of + any type. Its value is therefore not encoded in the [namespace](../../features/namespace.md). + +## Examples + +??? example "Example: default behavior (macro not defined)" + + Without the macro, the deprecated overload is called, and the compiler warns about it: + + ```cpp + #include + + using json = nlohmann::json; + + int main() + { + const std::vector v = {0x82, 0x01, 0x02}; + auto j = json::from_cbor(v.data(), v.size()); + // warning: 'from_cbor' is deprecated: Since 3.8.0; use from_cbor(ptr, ptr + len) + } + ``` + +??? example "Example: deleted deprecated functions (macro defined to 1)" + + With the macro, the call does not compile: + + ```cpp + #define JSON_DELETE_DEPRECATED_FUNCTIONS 1 + #include + + using json = nlohmann::json; + + int main() + { + const std::vector v = {0x82, 0x01, 0x02}; + auto j = json::from_cbor(v.data(), v.size()); + // error: call to deleted function 'from_cbor' + } + ``` + +## See also + +- [Roadmap: removal of deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) - the + deprecated functions and the version they were deprecated in +- [Migration guide: replace deprecated functions](../../integration/migration_guide.md#replace-deprecated-functions) - + how to replace each deprecated function + +## Version history + +- Added in version 3.13.0. +- Planned to be removed in version 4.0.0, which removes the deprecated functions. The deprecated `from_*(ptr, len)` + overloads stay deleted in version 4.0.0. diff --git a/docs/mkdocs/docs/api/macros/json_disable_tuple_reference_conversion.md b/docs/mkdocs/docs/api/macros/json_disable_tuple_reference_conversion.md index c69240726..0a2216b57 100644 --- a/docs/mkdocs/docs/api/macros/json_disable_tuple_reference_conversion.md +++ b/docs/mkdocs/docs/api/macros/json_disable_tuple_reference_conversion.md @@ -112,3 +112,4 @@ The default value is `0` (disabled — existing behavior is preserved). ## Version history - Added in version 3.13.0. +- Planned to become the default (with the macro removed) in version 4.0.0. diff --git a/docs/mkdocs/docs/api/macros/json_strict_binary_utf8.md b/docs/mkdocs/docs/api/macros/json_strict_binary_utf8.md index ed7bbe6b3..4c573d56e 100644 --- a/docs/mkdocs/docs/api/macros/json_strict_binary_utf8.md +++ b/docs/mkdocs/docs/api/macros/json_strict_binary_utf8.md @@ -54,7 +54,7 @@ The default value is `0` (disabled, the behavior of version 3.12.0 and earlier i ## Examples -??? example "Default behavior (macro not defined)" +??? example "Example: default behavior (macro not defined)" Without the macro, the bytes are written unchanged: @@ -70,7 +70,7 @@ The default value is `0` (disabled, the behavior of version 3.12.0 and earlier i } ``` -??? example "Opt-in check (macro defined to 1)" +??? example "Example: opt-in check (macro defined to 1)" With the macro, ill-formed UTF-8 is rejected: diff --git a/docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md b/docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md index 11bf74b22..675a8acee 100644 --- a/docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md +++ b/docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md @@ -44,7 +44,7 @@ By default, implicit conversions are enabled. ## Examples -??? example +??? example "Example: implicit and explicit conversions" This is an example for an implicit conversion: @@ -61,7 +61,7 @@ By default, implicit conversions are enabled. auto s = j.get(); ``` -??? example "Conversion between `basic_json` specializations" +??? example "Example: conversion between `basic_json` specializations" A `basic_json` specialization with a different string type is also no longer converted implicitly when `JSON_USE_IMPLICIT_CONVERSIONS` is defined to `0`: diff --git a/docs/mkdocs/docs/community/roadmap.md b/docs/mkdocs/docs/community/roadmap.md index 48977b295..36d5d7e7f 100644 --- a/docs/mkdocs/docs/community/roadmap.md +++ b/docs/mkdocs/docs/community/roadmap.md @@ -64,6 +64,8 @@ The following macros guard changes that are planned to become the default in ver | [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md) | `0` | `1`: reading from a stream does not consume the character after a number | – | 3.13.0 | | [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md) | `0` | `1`: a NUL byte in the input is a parse error instead of the end of input | [`JSON_StrictNulHandling`](../integration/cmake.md#json_strictnulhandling) | 3.13.0 | | [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md) | `0` | `1`: `to_cbor`, `to_ubjson`, `to_bjdata`, and `to_bson` throw for strings that are not valid UTF-8 by default | [`JSON_StrictBinaryUTF8`](../integration/cmake.md#json_strictbinaryutf8) | 3.13.0 | +| [`JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md) | `0` | `1`: a `basic_json` value can no longer be created from a one-element tuple of a reference to it, such as `std::forward_as_tuple(j)`| [`JSON_DisableTupleReferenceConversion`](../integration/cmake.md#json_disabletuplereferenceconversion) | 3.13.0 | +| [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) | `0` | removed: the deprecated functions are removed (see below); the `from_*(ptr, len)` overloads stay deleted | [`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions) | 3.13.0 | For example, the following makes a 3.x release behave like version 4.0 with respect to these changes: @@ -75,6 +77,8 @@ For example, the following makes a 3.x release behave like version 4.0 with resp #define JSON_PRECISE_STREAM_POSITION 1 #define JSON_STRICT_NUL_HANDLING 1 #define JSON_STRICT_BINARY_UTF8 1 +#define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 1 +#define JSON_DELETE_DEPRECATED_FUNCTIONS 1 #include ``` @@ -84,8 +88,13 @@ way to achieve this. ### Removal of deprecated functions Version 4.0 will remove all deprecated functions. Compiling with deprecation warnings enabled shows which of them your -code still uses. The [migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to -replace each of them. +code still uses. Defining [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to +`1` turns these warnings into errors, as the deprecated functions are then deleted. The +[migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to replace each of them. + +The `from_*` overloads taking a pointer and a length are not removed in version 4.0, but stay deleted. Without them, a +call like `from_cbor(ptr, len)` would still compile: it would read `ptr` as a NUL-terminated string and convert `len` +to the `strict` parameter. | Deprecated | Since | Migration | |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------| @@ -97,6 +106,7 @@ replace each of them. | [`json_pointer::operator string_t`](../api/json_pointer/operator_string_t.md) | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers) | | [`json_pointer`](../api/json_pointer/index.md) with a `basic_json` type as template argument, and the overloads of `value`, `contains`, `operator[]`, and `at` accepting such a pointer | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers) | | Comparing a [`json_pointer`](../api/json_pointer/index.md) with a string via [`operator==`](../api/json_pointer/operator_eq.md) or [`operator!=`](../api/json_pointer/operator_ne.md) | 3.11.2 | [JSON Pointers](../integration/migration_guide.md#json-pointers) | +| [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) with `(ptr, len)` | 3.13.0 | [Parsing](../integration/migration_guide.md#parsing) | The deprecated legacy comparison of discarded values is controlled by a macro and therefore listed in the table above. diff --git a/docs/mkdocs/docs/features/macros.md b/docs/mkdocs/docs/features/macros.md index 681980315..440fcdbdf 100644 --- a/docs/mkdocs/docs/features/macros.md +++ b/docs/mkdocs/docs/features/macros.md @@ -23,6 +23,17 @@ This macro overrides [`#!cpp catch`](https://en.cppreference.com/w/cpp/language/ See [full documentation of `JSON_CATCH_USER(exception)`](../api/macros/json_throw_user.md). +## `JSON_DELETE_DEPRECATED_FUNCTIONS` + +When defined to `1`, all deprecated functions are declared as deleted instead of only being marked as deprecated, so +code that still calls them no longer compiles. This way, you can find all calls that need to be replaced before version +4.0.0 removes these functions. + +The macro can also be set with the CMake option +[`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default). + +See [full documentation of `JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md). + ## `JSON_DIAGNOSTICS` This macro enables extended diagnostics for exception messages. Possible values are `1` to enable or `0` to disable @@ -86,7 +97,8 @@ See [full documentation of `JSON_DISABLE_ENUM_SERIALIZATION`](../api/macros/json ## `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION` When defined to `1`, a JSON value can no longer be created from a one-element `std::tuple` holding a reference to a JSON -value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise. +value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise. This +is planned to become the default in version 4.0.0. See [full documentation of `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md). diff --git a/docs/mkdocs/docs/integration/cmake.md b/docs/mkdocs/docs/integration/cmake.md index 9151d12be..d75aef47b 100644 --- a/docs/mkdocs/docs/integration/cmake.md +++ b/docs/mkdocs/docs/integration/cmake.md @@ -132,6 +132,12 @@ Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/ Enable CI build targets. The exact targets are used during the several CI steps and are subject to change without notice. This option is `OFF` by default. +### `JSON_DeleteDeprecatedFunctions` + +Delete the deprecated functions instead of only deprecating them by defining the macro +[`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md). This option is `OFF` by +default. + ### `JSON_Diagnostics` Enable [extended diagnostic messages](../home/exceptions.md#extended-diagnostic-messages) by defining macro [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md). This option is `OFF` by default. diff --git a/docs/mkdocs/docs/integration/migration_guide.md b/docs/mkdocs/docs/integration/migration_guide.md index 8a07d48a3..17b2eb360 100644 --- a/docs/mkdocs/docs/integration/migration_guide.md +++ b/docs/mkdocs/docs/integration/migration_guide.md @@ -14,6 +14,13 @@ deprecations are annotated with [`HEDLEY_DEPRECATED_FOR`](https://nemequ.github.io/hedley/api-reference.html#HEDLEY_DEPRECATED_FOR) to report which function to use instead. +!!! tip "Find all calls of deprecated functions" + + Define [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to `1` (or set the + CMake option [`JSON_DeleteDeprecatedFunctions`](cmake.md#json_deletedeprecatedfunctions)) to delete all deprecated + functions. Every remaining call then fails to compile, even if deprecation warnings are disabled, so your code is + ready for version 4.0.0 once it compiles with the macro. + ### Parsing - Function `friend std::istream& operator<<(basic_json&, std::istream&)` is deprecated since 3.0.0. Please use @@ -41,8 +48,10 @@ function to use instead. [`from_ubjson`](../api/basic_json/from_ubjson.md), and [`from_bson`](../api/basic_json/from_bson.md)) via initializer lists is deprecated since 3.8.0. Instead, pass two iterators; for instance, call `from_cbor(ptr, ptr+len)` instead of `from_cbor({ptr, len})`. Likewise, passing a pointer and a length as two separate arguments to `from_cbor`, - `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0; call `from_cbor(ptr, ptr+len)` instead of - `from_cbor(ptr, len)`. + `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0, and to + [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) since 3.13.0; call + `from_cbor(ptr, ptr+len)` instead of `from_cbor(ptr, len)`. These overloads will not be removed in version 4.0.0, but + deleted, so a call like `from_cbor(ptr, len)` cannot compile and convert `len` to the `strict` parameter. === "Deprecated" diff --git a/docs/mkdocs/mkdocs.yml b/docs/mkdocs/mkdocs.yml index dcb94864d..1ff780e25 100644 --- a/docs/mkdocs/mkdocs.yml +++ b/docs/mkdocs/mkdocs.yml @@ -292,6 +292,7 @@ nav: - 'JSON_BRACE_INIT_COPY_SEMANTICS': api/macros/json_brace_init_copy_semantics.md - 'JSON_CATCH_USER, JSON_THROW_USER, JSON_TRY_USER': api/macros/json_throw_user.md - 'JSON_DIAGNOSTICS': api/macros/json_diagnostics.md + - 'JSON_DELETE_DEPRECATED_FUNCTIONS': api/macros/json_delete_deprecated_functions.md - 'JSON_DIAGNOSTIC_POSITIONS': api/macros/json_diagnostic_positions.md - 'JSON_DISABLE_ENUM_SERIALIZATION': api/macros/json_disable_enum_serialization.md - 'JSON_DISABLE_TUPLE_REFERENCE_CONVERSION': api/macros/json_disable_tuple_reference_conversion.md diff --git a/include/nlohmann/detail/json_pointer.hpp b/include/nlohmann/detail/json_pointer.hpp index 788af1047..596766de6 100644 --- a/include/nlohmann/detail/json_pointer.hpp +++ b/include/nlohmann/detail/json_pointer.hpp @@ -79,11 +79,15 @@ class json_pointer /// @brief return a string representation of the JSON pointer /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/ +#if JSON_DELETE_DEPRECATED_FUNCTIONS + operator string_t() const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string()) operator string_t() const { return to_string(); } +#endif #ifndef JSON_NO_IO /// @brief write string representation of the JSON pointer to stream @@ -1016,11 +1020,15 @@ class json_pointer /// @brief compares JSON pointer and string for equality /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ +#if JSON_DELETE_DEPRECATED_FUNCTIONS + bool operator==(const string_t& rhs) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer)) bool operator==(const string_t& rhs) const { return *this == json_pointer(rhs); } +#endif /// @brief 3-way compares two JSON pointers template @@ -1095,21 +1103,31 @@ inline bool operator==(const json_pointer& lhs, template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator==(const json_pointer& lhs, + const StringType& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) inline bool operator==(const json_pointer& lhs, const StringType& rhs) { return lhs == json_pointer(rhs); } +#endif template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator==(const StringType& lhs, + const json_pointer& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) inline bool operator==(const StringType& lhs, const json_pointer& rhs) { return json_pointer(lhs) == rhs; } +#endif template inline bool operator!=(const json_pointer& lhs, @@ -1120,21 +1138,31 @@ inline bool operator!=(const json_pointer& lhs, template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator!=(const json_pointer& lhs, + const StringType& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) inline bool operator!=(const json_pointer& lhs, const StringType& rhs) { return !(lhs == rhs); } +#endif template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator!=(const StringType& lhs, + const json_pointer& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) inline bool operator!=(const StringType& lhs, const json_pointer& rhs) { return !(lhs == rhs); } +#endif template inline bool operator<(const json_pointer& lhs, diff --git a/include/nlohmann/detail/macro_scope.hpp b/include/nlohmann/detail/macro_scope.hpp index 17118927c..1a847e1a9 100644 --- a/include/nlohmann/detail/macro_scope.hpp +++ b/include/nlohmann/detail/macro_scope.hpp @@ -888,6 +888,10 @@ #define JSON_DISABLE_ENUM_SERIALIZATION 0 #endif +#ifndef JSON_DELETE_DEPRECATED_FUNCTIONS + #define JSON_DELETE_DEPRECATED_FUNCTIONS 0 +#endif + #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0 #endif diff --git a/include/nlohmann/detail/macro_unscope.hpp b/include/nlohmann/detail/macro_unscope.hpp index 55b2ac99e..f8befb2f6 100644 --- a/include/nlohmann/detail/macro_unscope.hpp +++ b/include/nlohmann/detail/macro_unscope.hpp @@ -43,6 +43,7 @@ #undef JSON_PRECISE_STREAM_POSITION #undef JSON_STRICT_NUL_HANDLING #undef JSON_STRICT_BINARY_UTF8 + #undef JSON_DELETE_DEPRECATED_FUNCTIONS #endif #include diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp index 3c49002f7..fc137d506 100644 --- a/include/nlohmann/json.hpp +++ b/include/nlohmann/json.hpp @@ -3470,22 +3470,30 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec detail::is_basic_json::value && detail::is_getable::value && !std::is_same>::value, int > = 0 > +#if JSON_DELETE_DEPRECATED_FUNCTIONS + ValueType value(const ::nlohmann::json_pointer& ptr, const ValueType& default_value) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) ValueType value(const ::nlohmann::json_pointer& ptr, const ValueType& default_value) const { return value(ptr.convert(), default_value); } +#endif template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type::type, detail::enable_if_t < detail::is_basic_json::value && detail::is_getable::value && !std::is_same>::value, int > = 0 > +#if JSON_DELETE_DEPRECATED_FUNCTIONS + ReturnType value(const ::nlohmann::json_pointer& ptr, ValueType && default_value) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) ReturnType value(const ::nlohmann::json_pointer& ptr, ValueType && default_value) const { return value(ptr.convert(), std::forward(default_value)); } +#endif /// @brief access the first element /// @sa https://json.nlohmann.me/api/basic_json/front/ @@ -3841,11 +3849,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + bool contains(const typename ::nlohmann::json_pointer& ptr) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) bool contains(const typename ::nlohmann::json_pointer& ptr) const { return ptr.contains(this); } +#endif /// @} @@ -3954,22 +3966,30 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// @deprecated This function is deprecated since 3.1.0 and will be removed in /// version 4.0.0 of the library. Please use @ref items() instead; /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static iteration_proxy iterator_wrapper(reference ref) noexcept = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(reference ref) noexcept { return ref.items(); } +#endif /// @brief wrapper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ /// @deprecated This function is deprecated since 3.1.0 and will be removed in /// version 4.0.0 of the library. Please use @ref items() instead; /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static iteration_proxy iterator_wrapper(const_reference ref) noexcept = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(const_reference ref) noexcept { return ref.items(); } +#endif /// @brief helper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ @@ -5285,11 +5305,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// version 4.0.0 of the library. Please use /// operator<<(std::ostream&, const basic_json&) instead; that is, /// replace calls like `j >> o;` with `o << j;`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + friend std::ostream& operator>>(const basic_json& j, std::ostream& o) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&)) friend std::ostream& operator>>(const basic_json& j, std::ostream& o) { return o << j; } +#endif #endif // JSON_NO_IO /// @} @@ -5335,6 +5359,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json parse(detail::span_input_adapter&& i, + parser_callback_t cb = nullptr, + const bool allow_exceptions = true, + const bool ignore_comments = false, + const bool ignore_trailing_commas = false) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len)) static basic_json parse(detail::span_input_adapter&& i, parser_callback_t cb = nullptr, @@ -5347,6 +5378,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec p.parse(true, result); return result; } +#endif /// @brief check if the input is valid JSON /// @sa https://json.nlohmann.me/api/basic_json/accept/ @@ -5372,6 +5404,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static bool accept(detail::span_input_adapter&& i, + const bool ignore_comments = false, + const bool ignore_trailing_commas = false) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len)) static bool accept(detail::span_input_adapter&& i, const bool ignore_comments = false, @@ -5379,6 +5416,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true); } +#endif /// @brief generate SAX events /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/ @@ -5432,6 +5470,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec #pragma clang diagnostic ignored "-Wdocumentation-deprecated-sync" #endif template +#if JSON_DELETE_DEPRECATED_FUNCTIONS + JSON_HEDLEY_NON_NULL(2) + static bool sax_parse(detail::span_input_adapter&& i, SAX* sax, + input_format_t format = input_format_t::json, + const bool strict = true, + const bool ignore_comments = false, + const bool ignore_trailing_commas = false) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...)) JSON_HEDLEY_NON_NULL(2) static bool sax_parse(detail::span_input_adapter&& i, SAX* sax, @@ -5447,6 +5493,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) : detail::binary_reader(std::move(ia), format).sax_parse(sax, strict); } +#endif #if defined(__clang__) #pragma clang diagnostic pop #endif @@ -5457,11 +5504,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// version 4.0.0 of the library. Please use /// operator>>(std::istream&, basic_json&) instead; that is, /// replace calls like `j << i;` with `i >> j;`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + friend std::istream& operator<<(basic_json& j, std::istream& i) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&)) friend std::istream& operator<<(basic_json& j, std::istream& i) { return operator>>(i, j); } +#endif /// @brief deserialize from stream /// @sa https://json.nlohmann.me/api/operator_gtgt/ @@ -5804,6 +5855,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_cbor(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true, + const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) static basic_json from_cbor(const T* ptr, std::size_t len, const bool strict = true, @@ -5812,8 +5869,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_cbor(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true, + const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) static basic_json from_cbor(detail::span_input_adapter&& i, const bool strict = true, @@ -5822,6 +5886,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::cbor, strict, allow_exceptions, error_handler_t::keep, tag_handler); } +#endif /// @brief create a JSON value from an input in MessagePack format /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/ @@ -5850,6 +5915,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_msgpack(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len)) static basic_json from_msgpack(const T* ptr, std::size_t len, const bool strict = true, @@ -5857,8 +5927,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_msgpack(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_msgpack(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len)) static basic_json from_msgpack(detail::span_input_adapter&& i, const bool strict = true, @@ -5866,6 +5942,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::msgpack, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in UBJSON format /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/ @@ -5894,6 +5971,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_ubjson(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len)) static basic_json from_ubjson(const T* ptr, std::size_t len, const bool strict = true, @@ -5901,8 +5983,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_ubjson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_ubjson(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len)) static basic_json from_ubjson(detail::span_input_adapter&& i, const bool strict = true, @@ -5910,6 +5998,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::ubjson, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in BJData format /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/ @@ -5938,6 +6027,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bjdata(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bjdata(ptr, ptr + len)) static basic_json from_bjdata(const T* ptr, std::size_t len, const bool strict = true, @@ -5945,6 +6039,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_bjdata(ptr, ptr + len, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in BON8 format /// @sa https://json.nlohmann.me/api/basic_json/from_bon8/ @@ -5971,6 +6066,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bon8(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bon8(ptr, ptr + len)) static basic_json from_bon8(const T* ptr, std::size_t len, const bool strict = true, @@ -5978,6 +6078,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_bon8(ptr, ptr + len, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in BSON format /// @sa https://json.nlohmann.me/api/basic_json/from_bson/ @@ -6006,6 +6107,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bson(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len)) static basic_json from_bson(const T* ptr, std::size_t len, const bool strict = true, @@ -6013,8 +6119,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_bson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bson(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len)) static basic_json from_bson(detail::span_input_adapter&& i, const bool strict = true, @@ -6022,6 +6134,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions); } +#endif /// @} ////////////////////////// @@ -6039,11 +6152,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + reference operator[](const ::nlohmann::json_pointer& ptr) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) reference operator[](const ::nlohmann::json_pointer& ptr) { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ @@ -6053,11 +6170,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + const_reference operator[](const ::nlohmann::json_pointer& ptr) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) const_reference operator[](const ::nlohmann::json_pointer& ptr) const { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -6067,11 +6188,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + reference at(const ::nlohmann::json_pointer& ptr) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) reference at(const ::nlohmann::json_pointer& ptr) { return ptr.get_checked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -6081,11 +6206,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + const_reference at(const ::nlohmann::json_pointer& ptr) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) const_reference at(const ::nlohmann::json_pointer& ptr) const { return ptr.get_checked(this); } +#endif /// @brief return flattened JSON value /// @sa https://json.nlohmann.me/api/basic_json/flatten/ diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp index 2ba16000d..a16d884d1 100644 --- a/single_include/nlohmann/json.hpp +++ b/single_include/nlohmann/json.hpp @@ -3214,6 +3214,10 @@ JSON_HEDLEY_DIAGNOSTIC_POP #define JSON_DISABLE_ENUM_SERIALIZATION 0 #endif +#ifndef JSON_DELETE_DEPRECATED_FUNCTIONS + #define JSON_DELETE_DEPRECATED_FUNCTIONS 0 +#endif + #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0 #endif @@ -19755,11 +19759,15 @@ class json_pointer /// @brief return a string representation of the JSON pointer /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/ +#if JSON_DELETE_DEPRECATED_FUNCTIONS + operator string_t() const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string()) operator string_t() const { return to_string(); } +#endif #ifndef JSON_NO_IO /// @brief write string representation of the JSON pointer to stream @@ -20692,11 +20700,15 @@ class json_pointer /// @brief compares JSON pointer and string for equality /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ +#if JSON_DELETE_DEPRECATED_FUNCTIONS + bool operator==(const string_t& rhs) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer)) bool operator==(const string_t& rhs) const { return *this == json_pointer(rhs); } +#endif /// @brief 3-way compares two JSON pointers template @@ -20771,21 +20783,31 @@ inline bool operator==(const json_pointer& lhs, template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator==(const json_pointer& lhs, + const StringType& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) inline bool operator==(const json_pointer& lhs, const StringType& rhs) { return lhs == json_pointer(rhs); } +#endif template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator==(const StringType& lhs, + const json_pointer& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) inline bool operator==(const StringType& lhs, const json_pointer& rhs) { return json_pointer(lhs) == rhs; } +#endif template inline bool operator!=(const json_pointer& lhs, @@ -20796,21 +20818,31 @@ inline bool operator!=(const json_pointer& lhs, template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator!=(const json_pointer& lhs, + const StringType& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) inline bool operator!=(const json_pointer& lhs, const StringType& rhs) { return !(lhs == rhs); } +#endif template::string_t> +#if JSON_DELETE_DEPRECATED_FUNCTIONS +inline bool operator!=(const StringType& lhs, + const json_pointer& rhs) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) inline bool operator!=(const StringType& lhs, const json_pointer& rhs) { return !(lhs == rhs); } +#endif template inline bool operator<(const json_pointer& lhs, @@ -30407,22 +30439,30 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec detail::is_basic_json::value && detail::is_getable::value && !std::is_same>::value, int > = 0 > +#if JSON_DELETE_DEPRECATED_FUNCTIONS + ValueType value(const ::nlohmann::json_pointer& ptr, const ValueType& default_value) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) ValueType value(const ::nlohmann::json_pointer& ptr, const ValueType& default_value) const { return value(ptr.convert(), default_value); } +#endif template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type::type, detail::enable_if_t < detail::is_basic_json::value && detail::is_getable::value && !std::is_same>::value, int > = 0 > +#if JSON_DELETE_DEPRECATED_FUNCTIONS + ReturnType value(const ::nlohmann::json_pointer& ptr, ValueType && default_value) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) ReturnType value(const ::nlohmann::json_pointer& ptr, ValueType && default_value) const { return value(ptr.convert(), std::forward(default_value)); } +#endif /// @brief access the first element /// @sa https://json.nlohmann.me/api/basic_json/front/ @@ -30778,11 +30818,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + bool contains(const typename ::nlohmann::json_pointer& ptr) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) bool contains(const typename ::nlohmann::json_pointer& ptr) const { return ptr.contains(this); } +#endif /// @} @@ -30891,22 +30935,30 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// @deprecated This function is deprecated since 3.1.0 and will be removed in /// version 4.0.0 of the library. Please use @ref items() instead; /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static iteration_proxy iterator_wrapper(reference ref) noexcept = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(reference ref) noexcept { return ref.items(); } +#endif /// @brief wrapper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ /// @deprecated This function is deprecated since 3.1.0 and will be removed in /// version 4.0.0 of the library. Please use @ref items() instead; /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static iteration_proxy iterator_wrapper(const_reference ref) noexcept = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(const_reference ref) noexcept { return ref.items(); } +#endif /// @brief helper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ @@ -32222,11 +32274,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// version 4.0.0 of the library. Please use /// operator<<(std::ostream&, const basic_json&) instead; that is, /// replace calls like `j >> o;` with `o << j;`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + friend std::ostream& operator>>(const basic_json& j, std::ostream& o) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&)) friend std::ostream& operator>>(const basic_json& j, std::ostream& o) { return o << j; } +#endif #endif // JSON_NO_IO /// @} @@ -32272,6 +32328,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json parse(detail::span_input_adapter&& i, + parser_callback_t cb = nullptr, + const bool allow_exceptions = true, + const bool ignore_comments = false, + const bool ignore_trailing_commas = false) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len)) static basic_json parse(detail::span_input_adapter&& i, parser_callback_t cb = nullptr, @@ -32284,6 +32347,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec p.parse(true, result); return result; } +#endif /// @brief check if the input is valid JSON /// @sa https://json.nlohmann.me/api/basic_json/accept/ @@ -32309,6 +32373,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static bool accept(detail::span_input_adapter&& i, + const bool ignore_comments = false, + const bool ignore_trailing_commas = false) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len)) static bool accept(detail::span_input_adapter&& i, const bool ignore_comments = false, @@ -32316,6 +32385,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true); } +#endif /// @brief generate SAX events /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/ @@ -32369,6 +32439,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec #pragma clang diagnostic ignored "-Wdocumentation-deprecated-sync" #endif template +#if JSON_DELETE_DEPRECATED_FUNCTIONS + JSON_HEDLEY_NON_NULL(2) + static bool sax_parse(detail::span_input_adapter&& i, SAX* sax, + input_format_t format = input_format_t::json, + const bool strict = true, + const bool ignore_comments = false, + const bool ignore_trailing_commas = false) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...)) JSON_HEDLEY_NON_NULL(2) static bool sax_parse(detail::span_input_adapter&& i, SAX* sax, @@ -32384,6 +32462,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) : detail::binary_reader(std::move(ia), format).sax_parse(sax, strict); } +#endif #if defined(__clang__) #pragma clang diagnostic pop #endif @@ -32394,11 +32473,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// version 4.0.0 of the library. Please use /// operator>>(std::istream&, basic_json&) instead; that is, /// replace calls like `j << i;` with `i >> j;`. +#if JSON_DELETE_DEPRECATED_FUNCTIONS + friend std::istream& operator<<(basic_json& j, std::istream& i) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&)) friend std::istream& operator<<(basic_json& j, std::istream& i) { return operator>>(i, j); } +#endif /// @brief deserialize from stream /// @sa https://json.nlohmann.me/api/operator_gtgt/ @@ -32741,6 +32824,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_cbor(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true, + const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) static basic_json from_cbor(const T* ptr, std::size_t len, const bool strict = true, @@ -32749,8 +32838,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_cbor(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true, + const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) static basic_json from_cbor(detail::span_input_adapter&& i, const bool strict = true, @@ -32759,6 +32855,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::cbor, strict, allow_exceptions, error_handler_t::keep, tag_handler); } +#endif /// @brief create a JSON value from an input in MessagePack format /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/ @@ -32787,6 +32884,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_msgpack(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len)) static basic_json from_msgpack(const T* ptr, std::size_t len, const bool strict = true, @@ -32794,8 +32896,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_msgpack(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_msgpack(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len)) static basic_json from_msgpack(detail::span_input_adapter&& i, const bool strict = true, @@ -32803,6 +32911,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::msgpack, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in UBJSON format /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/ @@ -32831,6 +32940,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_ubjson(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len)) static basic_json from_ubjson(const T* ptr, std::size_t len, const bool strict = true, @@ -32838,8 +32952,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_ubjson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_ubjson(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len)) static basic_json from_ubjson(detail::span_input_adapter&& i, const bool strict = true, @@ -32847,6 +32967,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::ubjson, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in BJData format /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/ @@ -32875,6 +32996,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bjdata(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bjdata(ptr, ptr + len)) static basic_json from_bjdata(const T* ptr, std::size_t len, const bool strict = true, @@ -32882,6 +33008,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_bjdata(ptr, ptr + len, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in BON8 format /// @sa https://json.nlohmann.me/api/basic_json/from_bon8/ @@ -32908,6 +33035,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bon8(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bon8(ptr, ptr + len)) static basic_json from_bon8(const T* ptr, std::size_t len, const bool strict = true, @@ -32915,6 +33047,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_bon8(ptr, ptr + len, strict, allow_exceptions); } +#endif /// @brief create a JSON value from an input in BSON format /// @sa https://json.nlohmann.me/api/basic_json/from_bson/ @@ -32943,6 +33076,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bson(const T* ptr, std::size_t len, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len)) static basic_json from_bson(const T* ptr, std::size_t len, const bool strict = true, @@ -32950,8 +33088,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_bson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT +#if JSON_DELETE_DEPRECATED_FUNCTIONS + static basic_json from_bson(detail::span_input_adapter&& i, + const bool strict = true, + const bool allow_exceptions = true) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len)) static basic_json from_bson(detail::span_input_adapter&& i, const bool strict = true, @@ -32959,6 +33103,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec { return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions); } +#endif /// @} ////////////////////////// @@ -32976,11 +33121,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + reference operator[](const ::nlohmann::json_pointer& ptr) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) reference operator[](const ::nlohmann::json_pointer& ptr) { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ @@ -32990,11 +33139,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + const_reference operator[](const ::nlohmann::json_pointer& ptr) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) const_reference operator[](const ::nlohmann::json_pointer& ptr) const { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -33004,11 +33157,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + reference at(const ::nlohmann::json_pointer& ptr) = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) reference at(const ::nlohmann::json_pointer& ptr) { return ptr.get_checked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -33018,11 +33175,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec } template::value, int> = 0> +#if JSON_DELETE_DEPRECATED_FUNCTIONS + const_reference at(const ::nlohmann::json_pointer& ptr) const = delete; +#else JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer) // NOLINT(readability/alt_tokens) const_reference at(const ::nlohmann::json_pointer& ptr) const { return ptr.get_checked(this); } +#endif /// @brief return flattened JSON value /// @sa https://json.nlohmann.me/api/basic_json/flatten/ @@ -34182,6 +34343,7 @@ struct formatter // NOLINT(cert-dcl58-c #undef JSON_PRECISE_STREAM_POSITION #undef JSON_STRICT_NUL_HANDLING #undef JSON_STRICT_BINARY_UTF8 + #undef JSON_DELETE_DEPRECATED_FUNCTIONS #endif // #include diff --git a/tests/src/unit-bjdata.cpp b/tests/src/unit-bjdata.cpp index 0f2ebc97d..0ca58577c 100644 --- a/tests/src/unit-bjdata.cpp +++ b/tests/src/unit-bjdata.cpp @@ -9,6 +9,14 @@ #include "doctest_compatibility.h" #define JSON_TESTS_PRIVATE +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; @@ -4505,6 +4513,7 @@ TEST_CASE("issue #5648 - from_bjdata(ptr, len) must read len bytes, not treat pt } REQUIRE(contains_nul); +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED // before the fix, from_bjdata had no (ptr, len) overload, so this call // bound to from_bjdata(InputType&&, bool strict) instead: ptr was read // as a NUL-terminated C string (stopping at the embedded 0x00 byte), and @@ -4517,4 +4526,5 @@ TEST_CASE("issue #5648 - from_bjdata(ptr, len) must read len bytes, not treat pt // len must not collapse into the strict flag either CHECK(json::from_bjdata(packed.data(), packed.size(), false) == j); +#endif } diff --git a/tests/src/unit-bon8.cpp b/tests/src/unit-bon8.cpp index ac85d2de5..925d05689 100644 --- a/tests/src/unit-bon8.cpp +++ b/tests/src/unit-bon8.cpp @@ -8,6 +8,14 @@ #include "doctest_compatibility.h" +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; #ifdef JSON_TEST_NO_GLOBAL_UDLS @@ -1026,6 +1034,7 @@ TEST_CASE("issue #5648 - from_bon8(ptr, len) must read len bytes, not treat ptr } REQUIRE(contains_nul); +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED // before the fix, from_bon8 had no (ptr, len) overload, so this call // bound to from_bon8(InputType&&, bool strict) instead: ptr was read as // a NUL-terminated C string (stopping at the embedded 0x00 byte), and @@ -1038,6 +1047,7 @@ TEST_CASE("issue #5648 - from_bon8(ptr, len) must read len bytes, not treat ptr // len must not collapse into the strict flag either CHECK(json::from_bon8(packed.data(), packed.size(), false) == j); +#endif } #ifdef JSON_HAS_CPP_17 diff --git a/tests/src/unit-bson.cpp b/tests/src/unit-bson.cpp index 92a14e6fe..0d8a4b506 100644 --- a/tests/src/unit-bson.cpp +++ b/tests/src/unit-bson.cpp @@ -8,6 +8,14 @@ #include "doctest_compatibility.h" +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; @@ -1259,8 +1267,10 @@ TEST_CASE("BSON input that cannot be read is discarded by every overload") CHECK_THROWS_AS(_ = json::from_bson(input.begin(), input.end()), json::parse_error&); CHECK(json::from_bson(input, true, false).is_discarded()); CHECK(json::from_bson(input.begin(), input.end(), true, false).is_discarded()); +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED CHECK(json::from_bson(input.data(), input.size(), true, false).is_discarded()); CHECK(json::from_bson({input.data(), input.size()}, true, false).is_discarded()); +#endif } TEST_CASE("BSON SAX parsing stops at every event") @@ -1738,6 +1748,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip()) CHECK(j1 == j2); } +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED { INFO_WITH_TEMP(filename + ": uint8_t* and size"); // parse JSON file @@ -1752,6 +1763,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip()) // compare parsed JSON values CHECK(j1 == j2); } +#endif { INFO_WITH_TEMP(filename + ": output to output adapters"); diff --git a/tests/src/unit-cbor.cpp b/tests/src/unit-cbor.cpp index 633f50fea..8d501cc31 100644 --- a/tests/src/unit-cbor.cpp +++ b/tests/src/unit-cbor.cpp @@ -8,6 +8,14 @@ #include "doctest_compatibility.h" +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; @@ -2215,8 +2223,10 @@ TEST_CASE("CBOR input that cannot be read is discarded by every overload") CHECK_THROWS_AS(_ = json::from_cbor(input.begin(), input.end()), json::parse_error&); CHECK(json::from_cbor(input, true, false).is_discarded()); CHECK(json::from_cbor(input.begin(), input.end(), true, false).is_discarded()); +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED CHECK(json::from_cbor(input.data(), input.size(), true, false).is_discarded()); CHECK(json::from_cbor({input.data(), input.size()}, true, false).is_discarded()); +#endif // a string that ends early, read through iterators that are not // contiguous and have to be copied from one element at a time @@ -2611,12 +2621,14 @@ TEST_CASE("CBOR roundtrips" * doctest::skip()) CHECK(j1 == j2); } +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED { INFO_WITH_TEMP(filename + ": uint8_t* and size"); json j2; CHECK_NOTHROW(j2 = json::from_cbor({packed.data(), packed.size()})); CHECK(j1 == j2); } +#endif { INFO_WITH_TEMP(filename + ": output to output adapters"); diff --git a/tests/src/unit-delete_deprecated_functions.cpp b/tests/src/unit-delete_deprecated_functions.cpp new file mode 100644 index 000000000..f54e9966a --- /dev/null +++ b/tests/src/unit-delete_deprecated_functions.cpp @@ -0,0 +1,214 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ (supporting code) +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann +// SPDX-License-Identifier: MIT + +#include "doctest_compatibility.h" + +// This file tests the opt-in JSON_DELETE_DEPRECATED_FUNCTIONS, so it defines the +// macro itself instead of relying on the build configuration. +#ifdef JSON_DELETE_DEPRECATED_FUNCTIONS + #undef JSON_DELETE_DEPRECATED_FUNCTIONS +#endif +#define JSON_DELETE_DEPRECATED_FUNCTIONS 1 + +#include +using nlohmann::json; + +#include +#include +#include +#include +#include +#include +#include + +namespace +{ +template +struct make_void +{ + using type = void; +}; + +template +using void_t = typename make_void::type; + +// A deleted function is still found by overload resolution, but naming it in an +// unevaluated operand is ill-formed, so each of the following traits is false +// exactly if the expression selects a deleted (or no) function. +#define JSON_TEST_DETECT(name, expr) \ + template \ + struct name : std::false_type {}; \ + template \ + struct name> : std::true_type {} + +using ptr_t = const std::uint8_t*; + +JSON_TEST_DETECT(from_cbor_ptr_len, J::from_cbor(std::declval(), std::declval())); +JSON_TEST_DETECT(from_msgpack_ptr_len, J::from_msgpack(std::declval(), std::declval())); +JSON_TEST_DETECT(from_ubjson_ptr_len, J::from_ubjson(std::declval(), std::declval())); +JSON_TEST_DETECT(from_bjdata_ptr_len, J::from_bjdata(std::declval(), std::declval())); +JSON_TEST_DETECT(from_bon8_ptr_len, J::from_bon8(std::declval(), std::declval())); +JSON_TEST_DETECT(from_bson_ptr_len, J::from_bson(std::declval(), std::declval())); + +JSON_TEST_DETECT(from_cbor_ptr_ptr, J::from_cbor(std::declval(), std::declval())); +JSON_TEST_DETECT(from_msgpack_ptr_ptr, J::from_msgpack(std::declval(), std::declval())); +JSON_TEST_DETECT(from_ubjson_ptr_ptr, J::from_ubjson(std::declval(), std::declval())); +JSON_TEST_DETECT(from_bjdata_ptr_ptr, J::from_bjdata(std::declval(), std::declval())); +JSON_TEST_DETECT(from_bon8_ptr_ptr, J::from_bon8(std::declval(), std::declval())); +JSON_TEST_DETECT(from_bson_ptr_ptr, J::from_bson(std::declval(), std::declval())); + +JSON_TEST_DETECT(from_cbor_init_list, J::from_cbor({std::declval(), std::declval()})); +JSON_TEST_DETECT(from_msgpack_init_list, J::from_msgpack({std::declval(), std::declval()})); +JSON_TEST_DETECT(from_ubjson_init_list, J::from_ubjson({std::declval(), std::declval()})); +JSON_TEST_DETECT(from_bson_init_list, J::from_bson({std::declval(), std::declval()})); + +JSON_TEST_DETECT(parse_init_list, J::parse({std::declval(), std::declval()})); +JSON_TEST_DETECT(accept_init_list, J::accept({std::declval(), std::declval()})); +JSON_TEST_DETECT(sax_parse_init_list, J::sax_parse({std::declval(), std::declval()}, std::declval*>())); +JSON_TEST_DETECT(parse_ptr_ptr, J::parse(std::declval(), std::declval())); + +JSON_TEST_DETECT(iterator_wrapper, J::iterator_wrapper(std::declval())); +JSON_TEST_DETECT(iterator_wrapper_const, J::iterator_wrapper(std::declval())); +JSON_TEST_DETECT(items, std::declval().items()); + +JSON_TEST_DETECT(json_ltlt_istream, std::declval() << std::declval()); +JSON_TEST_DETECT(istream_gtgt_json, std::declval() >> std::declval()); +JSON_TEST_DETECT(json_gtgt_ostream, std::declval() >> std::declval()); +JSON_TEST_DETECT(ostream_ltlt_json, std::declval() << std::declval()); + +JSON_TEST_DETECT(ptr_eq_ptr, std::declval() == std::declval()); +JSON_TEST_DETECT(ptr_ne_ptr, std::declval() != std::declval()); +JSON_TEST_DETECT(ptr_eq_string, std::declval() == std::declval()); +JSON_TEST_DETECT(string_eq_ptr, std::declval() == std::declval()); +JSON_TEST_DETECT(ptr_eq_c_string, std::declval() == std::declval()); +JSON_TEST_DETECT(c_string_eq_ptr, std::declval() == std::declval()); +JSON_TEST_DETECT(ptr_ne_string, std::declval() != std::declval()); +JSON_TEST_DETECT(string_ne_ptr, std::declval() != std::declval()); +JSON_TEST_DETECT(ptr_to_string, std::declval().to_string()); + +// json_pointer with a basic_json type as template argument +template +using legacy_ptr_t = const nlohmann::json_pointer& ; +JSON_TEST_DETECT(legacy_ptr_value, std::declval().value(std::declval>(), 0)); +JSON_TEST_DETECT(legacy_ptr_value_rvalue, std::declval().value(std::declval>(), std::string())); +JSON_TEST_DETECT(legacy_ptr_contains, std::declval().contains(std::declval>())); +JSON_TEST_DETECT(legacy_ptr_subscript, std::declval()[std::declval>()]); +JSON_TEST_DETECT(legacy_ptr_subscript_const, std::declval()[std::declval>()]); +JSON_TEST_DETECT(legacy_ptr_at, std::declval().at(std::declval>())); +JSON_TEST_DETECT(legacy_ptr_at_const, std::declval().at(std::declval>())); +JSON_TEST_DETECT(ptr_value, std::declval().value(std::declval(), 0)); +JSON_TEST_DETECT(ptr_at, std::declval().at(std::declval())); + +#undef JSON_TEST_DETECT +} // namespace + +TEST_CASE("JSON_DELETE_DEPRECATED_FUNCTIONS") +{ + SECTION("from_* with a pointer and a length") + { + // the overloads are deleted rather than removed, so the length cannot + // silently bind to the strict parameter of from_*(InputType&&, bool) + CHECK_FALSE(from_cbor_ptr_len::value); + CHECK_FALSE(from_msgpack_ptr_len::value); + CHECK_FALSE(from_ubjson_ptr_len::value); + CHECK_FALSE(from_bjdata_ptr_len::value); + CHECK_FALSE(from_bon8_ptr_len::value); + CHECK_FALSE(from_bson_ptr_len::value); + + // the replacement + CHECK(from_cbor_ptr_ptr::value); + CHECK(from_msgpack_ptr_ptr::value); + CHECK(from_ubjson_ptr_ptr::value); + CHECK(from_bjdata_ptr_ptr::value); + CHECK(from_bon8_ptr_ptr::value); + CHECK(from_bson_ptr_ptr::value); + } + + SECTION("initializer lists of a pointer and a length") + { + CHECK_FALSE(from_cbor_init_list::value); + CHECK_FALSE(from_msgpack_init_list::value); + CHECK_FALSE(from_ubjson_init_list::value); + CHECK_FALSE(from_bson_init_list::value); + CHECK_FALSE(parse_init_list::value); + CHECK_FALSE(accept_init_list::value); + CHECK_FALSE(sax_parse_init_list::value); + + // the replacement + CHECK(parse_ptr_ptr::value); + } + + SECTION("iterator_wrapper") + { + CHECK_FALSE(iterator_wrapper::value); + CHECK_FALSE(iterator_wrapper_const::value); + + // the replacement + CHECK(items::value); + } + + SECTION("stream operators with reversed operands") + { + CHECK_FALSE(json_ltlt_istream::value); + CHECK_FALSE(json_gtgt_ostream::value); + + // the replacement + CHECK(istream_gtgt_json::value); + CHECK(ostream_ltlt_json::value); + } + + SECTION("json_pointer") + { + // conversion to a string + CHECK_FALSE(std::is_constructible::value); + CHECK_FALSE(std::is_convertible::value); + + // comparison with a string + CHECK_FALSE(ptr_eq_string::value); + CHECK_FALSE(string_eq_ptr::value); + CHECK_FALSE(ptr_eq_c_string::value); + CHECK_FALSE(c_string_eq_ptr::value); + CHECK_FALSE(ptr_ne_string::value); + CHECK_FALSE(string_ne_ptr::value); + + // the replacement + CHECK(ptr_to_string::value); + CHECK(ptr_eq_ptr::value); + CHECK(ptr_ne_ptr::value); + } + + SECTION("json_pointer with a basic_json type as template argument") + { + CHECK_FALSE(legacy_ptr_value::value); + CHECK_FALSE(legacy_ptr_value_rvalue::value); + CHECK_FALSE(legacy_ptr_contains::value); + CHECK_FALSE(legacy_ptr_subscript::value); + CHECK_FALSE(legacy_ptr_subscript_const::value); + CHECK_FALSE(legacy_ptr_at::value); + CHECK_FALSE(legacy_ptr_at_const::value); + + // the replacement + CHECK(ptr_value::value); + CHECK(ptr_at::value); + } + + SECTION("the non-deprecated functions still work") + { + const json j = {{"a", {1, 2}}}; + const auto cbor = json::to_cbor(j); + CHECK(json::from_cbor(cbor.data(), cbor.data() + cbor.size()) == j); + + const json::json_pointer ptr("/a/1"); + CHECK(ptr == json::json_pointer("/a/1")); + CHECK(ptr.to_string() == "/a/1"); + CHECK(j[ptr] == 2); + CHECK(j.at(ptr) == 2); + CHECK(j.value(ptr, 0) == 2); + CHECK(j.contains(ptr)); + } +} diff --git a/tests/src/unit-deserialization.cpp b/tests/src/unit-deserialization.cpp index 2f9ff63fa..ca9b63112 100644 --- a/tests/src/unit-deserialization.cpp +++ b/tests/src/unit-deserialization.cpp @@ -16,6 +16,14 @@ #define JSON_TEST_STRICT_NUL_HANDLING_ENABLED 1 #endif +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; #ifdef JSON_TEST_NO_GLOBAL_UDLS @@ -291,6 +299,7 @@ TEST_CASE("deserialization") })); } +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED SECTION("operator<<") { std::stringstream ss; @@ -299,6 +308,7 @@ TEST_CASE("deserialization") j << ss; CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}})); } +#endif SECTION("operator>>") { @@ -423,6 +433,7 @@ TEST_CASE("deserialization") CHECK_THROWS_WITH_AS(_ = json::parse(nullptr), "[json.exception.parse_error.101] parse error: attempting to parse an empty input; check that your input string or stream contains the expected JSON", json::parse_error&); } +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED SECTION("operator<<") { std::stringstream ss; @@ -430,6 +441,7 @@ TEST_CASE("deserialization") json j; CHECK_THROWS_WITH_AS(j << ss, "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'", json::parse_error&); } +#endif SECTION("operator>>") { @@ -1148,9 +1160,9 @@ TEST_CASE("deserialization") { std::istringstream s(bom + "123 456"); json j; - j << s; + s >> j; CHECK(j == 123); - j << s; + s >> j; CHECK(j == 456); } } diff --git a/tests/src/unit-items.cpp b/tests/src/unit-items.cpp index 81959db8d..71b0522a8 100644 --- a/tests/src/unit-items.cpp +++ b/tests/src/unit-items.cpp @@ -8,6 +8,14 @@ #include "doctest_compatibility.h" +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; @@ -19,6 +27,7 @@ DOCTEST_GCC_SUPPRESS_WARNING_PUSH DOCTEST_CLANG_SUPPRESS_WARNING_PUSH DOCTEST_CLANG_SUPPRESS_WARNING("-Wrange-loop-construct") +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED TEST_CASE("iterator_wrapper") { SECTION("object") @@ -715,6 +724,7 @@ TEST_CASE("iterator_wrapper") } } } +#endif TEST_CASE("items()") { diff --git a/tests/src/unit-json_pointer.cpp b/tests/src/unit-json_pointer.cpp index 86c636c2a..b4ed2c9cc 100644 --- a/tests/src/unit-json_pointer.cpp +++ b/tests/src/unit-json_pointer.cpp @@ -9,6 +9,14 @@ #include "doctest_compatibility.h" #define JSON_TESTS_PRIVATE +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; #ifdef JSON_TEST_NO_GLOBAL_UDLS @@ -564,7 +572,9 @@ TEST_CASE("JSON pointers") std::stringstream ss; ss << ptr; CHECK(ptr.to_string() == ptr_str); +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED CHECK(std::string(ptr) == ptr_str); +#endif CHECK(ss.str() == ptr_str); } } @@ -744,8 +754,6 @@ TEST_CASE("JSON pointers") SECTION("equality comparison") { - const char* ptr_cpstring = "/foo/bar"; - const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays) std::string ptr_string{"/foo/bar"}; auto ptr1 = json::json_pointer(ptr_string); auto ptr2 = json::json_pointer(ptr_string); @@ -755,6 +763,12 @@ TEST_CASE("JSON pointers") CHECK(ptr1 == ptr2); + CHECK_FALSE(ptr1 != ptr2); + +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED + const char* ptr_cpstring = "/foo/bar"; + const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays) + CHECK(ptr1 == "/foo/bar"); CHECK(ptr1 == ptr_cpstring); CHECK(ptr1 == ptr_castring); @@ -765,8 +779,6 @@ TEST_CASE("JSON pointers") CHECK(ptr_castring == ptr1); CHECK(ptr_string == ptr1); - CHECK_FALSE(ptr1 != ptr2); - CHECK_FALSE(ptr1 != "/foo/bar"); CHECK_FALSE(ptr1 != ptr_cpstring); CHECK_FALSE(ptr1 != ptr_castring); @@ -788,6 +800,7 @@ TEST_CASE("JSON pointers") CHECK_THROWS_WITH_AS("/~~" == ptr1, "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&); } +#endif } SECTION("less-than comparison") @@ -839,6 +852,7 @@ TEST_CASE("JSON pointers") json_ptr_j ptr_j{ptr_string}; json_ptr_oj ptr_oj{ptr_string}; +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED CHECK(j.contains(ptr)); CHECK(j.contains(ptr_j)); CHECK(j.contains(ptr_oj)); @@ -851,6 +865,7 @@ TEST_CASE("JSON pointers") CHECK(j.value(ptr, "x") == j.value(ptr_j, "x")); CHECK(j.value(ptr, "x") == j.value(ptr_oj, "x")); +#endif CHECK(ptr == ptr_j); CHECK(ptr == ptr_oj); diff --git a/tests/src/unit-msgpack.cpp b/tests/src/unit-msgpack.cpp index a92496144..aa52a5c4d 100644 --- a/tests/src/unit-msgpack.cpp +++ b/tests/src/unit-msgpack.cpp @@ -8,6 +8,14 @@ #include "doctest_compatibility.h" +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; #ifdef JSON_TEST_NO_GLOBAL_UDLS @@ -1795,8 +1803,10 @@ TEST_CASE("MessagePack input that cannot be read is discarded by every overload" CHECK_THROWS_AS(_ = json::from_msgpack(input.begin(), input.end()), json::parse_error&); CHECK(json::from_msgpack(input, true, false).is_discarded()); CHECK(json::from_msgpack(input.begin(), input.end(), true, false).is_discarded()); +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED CHECK(json::from_msgpack(input.data(), input.size(), true, false).is_discarded()); CHECK(json::from_msgpack({input.data(), input.size()}, true, false).is_discarded()); +#endif } TEST_CASE("MessagePack SAX parsing stops at every event") @@ -2099,12 +2109,14 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip()) CHECK(j1 == j2); } +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED { INFO_WITH_TEMP(filename + ": uint8_t* and size"); json j2; CHECK_NOTHROW(j2 = json::from_msgpack({packed.data(), packed.size()})); CHECK(j1 == j2); } +#endif { INFO_WITH_TEMP(filename + ": output to output adapters"); diff --git a/tests/src/unit-regression2.cpp b/tests/src/unit-regression2.cpp index 79ca5a770..1a8c73d4e 100644 --- a/tests/src/unit-regression2.cpp +++ b/tests/src/unit-regression2.cpp @@ -569,7 +569,7 @@ TEST_CASE("regression tests 2") SECTION("issue #2067 - cannot serialize binary data to text JSON") { const std::array data = {{0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30}}; - const json j = json::from_msgpack(data.data(), data.size()); + const json j = json::from_msgpack(data.begin(), data.end()); // dump() is nodiscard; this only checks that dumping does not throw CHECK_NOTHROW( utils::ignore_return_value( diff --git a/tests/src/unit-serialization.cpp b/tests/src/unit-serialization.cpp index 4b959021e..4b7a53b10 100644 --- a/tests/src/unit-serialization.cpp +++ b/tests/src/unit-serialization.cpp @@ -8,6 +8,14 @@ #include "doctest_compatibility.h" +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; @@ -48,6 +56,7 @@ TEST_CASE("serialization") } } +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED SECTION("operator>>") { SECTION("no given width") @@ -79,6 +88,7 @@ TEST_CASE("serialization") "[\n\t\"foo\",\n\t1,\n\t2,\n\t3,\n\tfalse,\n\t{\n\t\t\"one\": 1\n\t}\n]"); } } +#endif SECTION("dump") { diff --git a/tests/src/unit-ubjson.cpp b/tests/src/unit-ubjson.cpp index 450882a12..45e1ee604 100644 --- a/tests/src/unit-ubjson.cpp +++ b/tests/src/unit-ubjson.cpp @@ -8,6 +8,14 @@ #include "doctest_compatibility.h" +// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command +// line *before* including json.hpp, since the library #undefs it once the header +// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the +// tests of deprecated functions are skipped if these functions are deleted +#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1) + #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED +#endif + #include using nlohmann::json; @@ -2212,8 +2220,10 @@ TEST_CASE("UBJSON input that cannot be read is discarded by every overload") CHECK_THROWS_AS(_ = json::from_ubjson(input.begin(), input.end()), json::parse_error&); CHECK(json::from_ubjson(input, true, false).is_discarded()); CHECK(json::from_ubjson(input.begin(), input.end(), true, false).is_discarded()); +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED CHECK(json::from_ubjson(input.data(), input.size(), true, false).is_discarded()); CHECK(json::from_ubjson({input.data(), input.size()}, true, false).is_discarded()); +#endif } TEST_CASE("UBJSON SAX parsing stops at every event") @@ -2961,12 +2971,14 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip()) CHECK(j1 == j2); } +#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED { INFO_WITH_TEMP(filename + ": uint8_t* and size"); json j2; CHECK_NOTHROW(j2 = json::from_ubjson({packed.data(), packed.size()})); CHECK(j1 == j2); } +#endif { INFO_WITH_TEMP(filename + ": output to output adapters");