diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml index 1e4a72870..354cf2391 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 d0af68786..b9d246bbf 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. ############################################################################### @@ -705,7 +719,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 801ade93a..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'); diff --git a/docs/mkdocs/docs/api/macros/index.md b/docs/mkdocs/docs/api/macros/index.md index ffeb9639c..eb2807b69 100644 --- a/docs/mkdocs/docs/api/macros/index.md +++ b/docs/mkdocs/docs/api/macros/index.md @@ -61,6 +61,11 @@ header. See also the [macro overview page](../../features/macros.md). - [**JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS**](json_use_objects_for_enum_keyed_maps.md) - opt in to storing maps with enum keys as objects +## 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_use_implicit_conversions.md b/docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md index 113344412..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: implicit conversion" +??? example "Example: implicit and explicit conversions" This is an example for an implicit conversion: 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 4fd05c12c..ef41ce0d5 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 e2e234929..5b23366bb 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 30edb4a3b..92f52aedc 100644 --- a/include/nlohmann/detail/json_pointer.hpp +++ b/include/nlohmann/detail/json_pointer.hpp @@ -81,9 +81,13 @@ class json_pointer /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/ JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string()) operator string_t() const +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return to_string(); } +#endif #ifndef JSON_NO_IO /// @brief write string representation of the JSON pointer to stream @@ -1022,9 +1026,13 @@ class json_pointer /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer)) bool operator==(const string_t& rhs) const +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return *this == json_pointer(rhs); } +#endif /// @brief 3-way compares two JSON pointers template @@ -1102,18 +1110,26 @@ template& lhs, const StringType& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return lhs == json_pointer(rhs); } +#endif template::string_t> JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) inline bool operator==(const StringType& lhs, const json_pointer& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return json_pointer(lhs) == rhs; } +#endif template inline bool operator!=(const json_pointer& lhs, @@ -1127,18 +1143,26 @@ template& lhs, const StringType& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return !(lhs == rhs); } +#endif template::string_t> JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) inline bool operator!=(const StringType& lhs, const json_pointer& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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 75bf14c92..494cba0d8 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 #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS #endif diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp index ca9682bd5..e1eeac12c 100644 --- a/include/nlohmann/json.hpp +++ b/include/nlohmann/json.hpp @@ -3492,9 +3492,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec && !std::is_same>::value, int > = 0 > 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return value(ptr.convert(), default_value); } +#endif template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type::type, detail::enable_if_t < @@ -3503,9 +3507,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec && !std::is_same>::value, int > = 0 > 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return value(ptr.convert(), std::forward(default_value)); } +#endif /// @brief access the first element /// @sa https://json.nlohmann.me/api/basic_json/front/ @@ -3863,9 +3871,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec JSON_HEDLEY_WARN_UNUSED_RESULT 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.contains(this); } +#endif /// @} @@ -3976,9 +3988,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(reference ref) noexcept +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ref.items(); } +#endif /// @brief wrapper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ @@ -3987,9 +4003,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(const_reference ref) noexcept +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ref.items(); } +#endif /// @brief helper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ @@ -5307,9 +5327,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// replace calls like `j >> o;` with `o << j;`. JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&)) friend std::ostream& operator>>(const basic_json& j, std::ostream& o) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return o << j; } +#endif #endif // JSON_NO_IO /// @} @@ -5361,12 +5385,16 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool allow_exceptions = true, const bool ignore_comments = false, const bool ignore_trailing_commas = false) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { basic_json result; auto p = parser(i.get(), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas); p.parse(true, result); return result; } +#endif /// @brief check if the input is valid JSON /// @sa https://json.nlohmann.me/api/basic_json/accept/ @@ -5396,9 +5424,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static bool accept(detail::span_input_adapter&& i, const bool ignore_comments = false, const bool ignore_trailing_commas = false) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -5459,6 +5491,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool strict = true, const bool ignore_comments = false, const bool ignore_trailing_commas = false) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { auto ia = i.get(); return format == input_format_t::json @@ -5467,6 +5502,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 @@ -5479,9 +5515,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// replace calls like `j << i;` with `i >> j;`. JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&)) friend std::istream& operator<<(basic_json& j, std::istream& i) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return operator>>(i, j); } +#endif /// @brief deserialize from stream /// @sa https://json.nlohmann.me/api/operator_gtgt/ @@ -5829,9 +5869,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool strict = true, const bool allow_exceptions = true, const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) @@ -5839,9 +5883,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool strict = true, const bool allow_exceptions = true, const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -5874,18 +5922,26 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_msgpack(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_msgpack(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT 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, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -5918,18 +5974,26 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_ubjson(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_ubjson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT 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, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -5962,9 +6026,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_bjdata(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -5995,9 +6063,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_bon8(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -6030,18 +6102,26 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_bson(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_bson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT 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, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions); } +#endif /// @} ////////////////////////// @@ -6061,9 +6141,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ @@ -6075,9 +6159,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -6089,9 +6177,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.get_checked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -6103,9 +6195,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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 ef6f3d26a..b427b247e 100644 --- a/single_include/nlohmann/json.hpp +++ b/single_include/nlohmann/json.hpp @@ -3225,6 +3225,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 @@ -19930,9 +19934,13 @@ class json_pointer /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/ JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string()) operator string_t() const +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return to_string(); } +#endif #ifndef JSON_NO_IO /// @brief write string representation of the JSON pointer to stream @@ -20871,9 +20879,13 @@ class json_pointer /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer)) bool operator==(const string_t& rhs) const +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return *this == json_pointer(rhs); } +#endif /// @brief 3-way compares two JSON pointers template @@ -20951,18 +20963,26 @@ template& lhs, const StringType& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return lhs == json_pointer(rhs); } +#endif template::string_t> JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) inline bool operator==(const StringType& lhs, const json_pointer& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return json_pointer(lhs) == rhs; } +#endif template inline bool operator!=(const json_pointer& lhs, @@ -20976,18 +20996,26 @@ template& lhs, const StringType& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return !(lhs == rhs); } +#endif template::string_t> JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) inline bool operator!=(const StringType& lhs, const json_pointer& rhs) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return !(lhs == rhs); } +#endif template inline bool operator<(const json_pointer& lhs, @@ -30614,9 +30642,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec && !std::is_same>::value, int > = 0 > 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return value(ptr.convert(), default_value); } +#endif template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type::type, detail::enable_if_t < @@ -30625,9 +30657,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec && !std::is_same>::value, int > = 0 > 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return value(ptr.convert(), std::forward(default_value)); } +#endif /// @brief access the first element /// @sa https://json.nlohmann.me/api/basic_json/front/ @@ -30985,9 +31021,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec JSON_HEDLEY_WARN_UNUSED_RESULT 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.contains(this); } +#endif /// @} @@ -31098,9 +31138,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(reference ref) noexcept +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ref.items(); } +#endif /// @brief wrapper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ @@ -31109,9 +31153,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy iterator_wrapper(const_reference ref) noexcept +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ref.items(); } +#endif /// @brief helper to access iterator member functions in range-based for /// @sa https://json.nlohmann.me/api/basic_json/items/ @@ -32429,9 +32477,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// replace calls like `j >> o;` with `o << j;`. JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&)) friend std::ostream& operator>>(const basic_json& j, std::ostream& o) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return o << j; } +#endif #endif // JSON_NO_IO /// @} @@ -32483,12 +32535,16 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool allow_exceptions = true, const bool ignore_comments = false, const bool ignore_trailing_commas = false) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { basic_json result; auto p = parser(i.get(), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas); p.parse(true, result); return result; } +#endif /// @brief check if the input is valid JSON /// @sa https://json.nlohmann.me/api/basic_json/accept/ @@ -32518,9 +32574,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static bool accept(detail::span_input_adapter&& i, const bool ignore_comments = false, const bool ignore_trailing_commas = false) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -32581,6 +32641,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool strict = true, const bool ignore_comments = false, const bool ignore_trailing_commas = false) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { auto ia = i.get(); return format == input_format_t::json @@ -32589,6 +32652,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 @@ -32601,9 +32665,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec /// replace calls like `j << i;` with `i >> j;`. JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&)) friend std::istream& operator<<(basic_json& j, std::istream& i) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return operator>>(i, j); } +#endif /// @brief deserialize from stream /// @sa https://json.nlohmann.me/api/operator_gtgt/ @@ -32951,9 +33019,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool strict = true, const bool allow_exceptions = true, const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) @@ -32961,9 +33033,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec const bool strict = true, const bool allow_exceptions = true, const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -32996,18 +33072,26 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_msgpack(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_msgpack(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT 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, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -33040,18 +33124,26 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_ubjson(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_ubjson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT 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, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -33084,9 +33176,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_bjdata(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -33117,9 +33213,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_bon8(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { 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/ @@ -33152,18 +33252,26 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec static basic_json from_bson(const T* ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_bson(ptr, ptr + len, strict, allow_exceptions); } +#endif JSON_HEDLEY_WARN_UNUSED_RESULT 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, const bool allow_exceptions = true) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions); } +#endif /// @} ////////////////////////// @@ -33183,9 +33291,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ @@ -33197,9 +33309,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.get_unchecked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -33211,9 +33327,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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) +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.get_checked(this); } +#endif /// @brief access specified element via JSON Pointer /// @sa https://json.nlohmann.me/api/basic_json/at/ @@ -33225,9 +33345,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template::value, int> = 0> 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 +#if JSON_DELETE_DEPRECATED_FUNCTIONS + = delete; +#else { return ptr.get_checked(this); } +#endif /// @brief return flattened JSON value /// @sa https://json.nlohmann.me/api/basic_json/flatten/ @@ -34387,6 +34511,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 #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS #endif diff --git a/tests/src/unit-bjdata.cpp b/tests/src/unit-bjdata.cpp index 06646c1d0..5e703a357 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 9a9116e12..b1d82ca29 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 @@ -1028,6 +1036,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 @@ -1040,6 +1049,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 17819dc65..c9c96b693 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; @@ -1261,8 +1269,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") @@ -1740,6 +1750,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 @@ -1754,6 +1765,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 546e256b1..1f584d3b3 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 @@ -2613,12 +2623,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 c4b447d64..d0db8438c 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 80ca214a4..a4060bd53 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");