Merge branch 'nlohmann:develop' into main

.clang-tidy

@@ -43,8 +43,10 @@ Checks: '*,
          -misc-non-private-member-variables-in-classes,
          -modernize-concat-nested-namespaces,
          -modernize-type-traits,
+         -modernize-use-constraints,
          -modernize-use-nodiscard,
          -modernize-use-trailing-return-type,
+         -performance-enum-size,
          -readability-function-cognitive-complexity,
          -readability-function-size,
          -readability-identifier-length,

.github/workflows/windows.yml

@@ -29,6 +29,7 @@ jobs:
         uses: egor-tensin/setup-mingw@v2
         with:
           platform: ${{ matrix.architecture }}
+          version: 12.2.0 # https://github.com/egor-tensin/setup-mingw/issues/14
       - name: Run CMake
         run: cmake -S . -B build -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
       - name: Build

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.1...3.14)
 
 ##
 ## PROJECT

Makefile

@@ -156,7 +156,8 @@ pretty:
 	    --pad-header \
 	    --align-pointer=type \
 	    --align-reference=type \
-	    --add-brackets \
+	    --add-braces \
+	    --squeeze-lines=2 \
 	    --convert-tabs \
 	    --close-templates \
 	    --lineend=linux \

docs/examples/at__json_pointer.cpp

@@ -35,14 +35,13 @@ int main()
     // output the changed array
     std::cout << j["array"] << '\n';
 
-
     // out_of_range.106
     try
     {
         // try to use an array index with leading '0'
         json::reference ref = j.at("/array/01"_json_pointer);
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -53,7 +52,7 @@ int main()
         // try to use an array index that is not a number
         json::reference ref = j.at("/array/one"_json_pointer);
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -64,7 +63,7 @@ int main()
         // try to use an invalid array index
         json::reference ref = j.at("/array/4"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -75,7 +74,7 @@ int main()
         // try to use the array index '-'
         json::reference ref = j.at("/array/-"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -86,7 +85,7 @@ int main()
         // try to use a JSON pointer to a nonexistent object key
         json::const_reference ref = j.at("/foo"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -97,7 +96,7 @@ int main()
         // try to use a JSON pointer that cannot be resolved
         json::reference ref = j.at("/number/foo"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/at__json_pointer_const.cpp

@@ -29,7 +29,7 @@ int main()
         // try to use an array index that is not a number
         json::const_reference ref = j.at("/array/one"_json_pointer);
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -40,7 +40,7 @@ int main()
         // try to use an invalid array index
         json::const_reference ref = j.at("/array/4"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -51,7 +51,7 @@ int main()
         // try to use the array index '-'
         json::const_reference ref = j.at("/array/-"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -62,7 +62,7 @@ int main()
         // try to use a JSON pointer to a nonexistent object key
         json::const_reference ref = j.at("/foo"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -73,7 +73,7 @@ int main()
         // try to use a JSON pointer that cannot be resolved
         json::const_reference ref = j.at("/number/foo"_json_pointer);
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/at__keytype.c++17.cpp

@@ -24,7 +24,6 @@ int main()
     // output changed array
     std::cout << object << '\n';
 
-
     // exception type_error.304
     try
     {
@@ -32,7 +31,7 @@ int main()
         json str = "I am a string";
         str.at("the good"sv) = "Another string";
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -43,7 +42,7 @@ int main()
         // try to write at a nonexisting key using string_view
         object.at("the fast"sv) = "il rapido";
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/at__keytype_const.c++17.cpp

@@ -18,7 +18,6 @@ int main()
     // output element with key "the ugly" using string_view
     std::cout << object.at("the ugly"sv) << '\n';
 
-
     // exception type_error.304
     try
     {
@@ -26,7 +25,7 @@ int main()
         const json str = "I am a string";
         std::cout << str.at("the good"sv) << '\n';
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -37,7 +36,7 @@ int main()
         // try to read from a nonexisting key using string_view
         std::cout << object.at("the fast"sv) << '\n';
     }
-    catch (json::out_of_range)
+    catch (const json::out_of_range)
     {
         std::cout << "out of range" << '\n';
     }

docs/examples/at__object_t_key_type.cpp

@@ -22,7 +22,6 @@ int main()
     // output changed array
     std::cout << object << '\n';
 
-
     // exception type_error.304
     try
     {
@@ -30,7 +29,7 @@ int main()
         json str = "I am a string";
         str.at("the good") = "Another string";
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -41,7 +40,7 @@ int main()
         // try to write at a nonexisting key
         object.at("the fast") = "il rapido";
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/at__object_t_key_type_const.cpp

@@ -16,7 +16,6 @@ int main()
     // output element with key "the ugly"
     std::cout << object.at("the ugly") << '\n';
 
-
     // exception type_error.304
     try
     {
@@ -24,7 +23,7 @@ int main()
         const json str = "I am a string";
         std::cout << str.at("the good") << '\n';
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -35,7 +34,7 @@ int main()
         // try to read from a nonexisting key
         std::cout << object.at("the fast") << '\n';
     }
-    catch (json::out_of_range)
+    catch (const json::out_of_range)
     {
         std::cout << "out of range" << '\n';
     }

docs/examples/at__size_type.cpp

@@ -17,7 +17,6 @@ int main()
     // output changed array
     std::cout << array << '\n';
 
-
     // exception type_error.304
     try
     {
@@ -25,7 +24,7 @@ int main()
         json str = "I am a string";
         str.at(0) = "Another string";
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -36,7 +35,7 @@ int main()
         // try to write beyond the array limit
         array.at(5) = "sixth";
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/at__size_type_const.cpp

@@ -11,7 +11,6 @@ int main()
     // output element at index 2 (third element)
     std::cout << array.at(2) << '\n';
 
-
     // exception type_error.304
     try
     {
@@ -19,7 +18,7 @@ int main()
         const json str = "I am a string";
         std::cout << str.at(0) << '\n';
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -30,7 +29,7 @@ int main()
         // try to read beyond the array limit
         std::cout << array.at(5) << '\n';
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/back.cpp

@@ -31,7 +31,7 @@ int main()
         json j_null;
         j_null.back();
     }
-    catch (json::invalid_iterator& e)
+    catch (const json::invalid_iterator& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/basic_json__CompatibleType.cpp

@@ -55,7 +55,6 @@ int main()
     std::cout << j_mmap << '\n';
     std::cout << j_ummap << "\n\n";
 
-
     // ===========
     // array types
     // ===========
@@ -117,7 +116,6 @@ int main()
     std::cout << j_mset << '\n';
     std::cout << j_umset << "\n\n";
 
-
     // ============
     // string types
     // ============
@@ -138,7 +136,6 @@ int main()
     std::cout << j_string_literal << '\n';
     std::cout << j_stdstring << "\n\n";
 
-
     // ============
     // number types
     // ============
@@ -203,7 +200,6 @@ int main()
     std::cout << j_float_nan << '\n';
     std::cout << j_double << "\n\n";
 
-
     // =============
     // boolean types
     // =============

docs/examples/basic_json__InputIt_InputIt.cpp

@@ -25,7 +25,7 @@ int main()
     {
         json j_invalid(j_number.begin() + 1, j_number.end());
     }
-    catch (json::invalid_iterator& e)
+    catch (const json::invalid_iterator& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/cbor_tag_handler_t.cpp

@@ -13,7 +13,7 @@ int main()
     {
         auto b_throw_on_tag = json::from_cbor(vec, true, true, json::cbor_tag_handler_t::error);
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << std::endl;
     }

docs/examples/contains__json_pointer.cpp

@@ -26,7 +26,7 @@ int main()
         // try to use an array index with leading '0'
         j.contains("/array/01"_json_pointer);
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -36,7 +36,7 @@ int main()
         // try to use an array index that is not a number
         j.contains("/array/one"_json_pointer);
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/diagnostics_extended.cpp

@@ -15,7 +15,7 @@ int main()
     {
         int housenumber = j["address"]["housenumber"];
     }
-    catch (json::exception& e)
+    catch (const json::exception& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/diagnostics_standard.cpp

@@ -13,7 +13,7 @@ int main()
     {
         int housenumber = j["address"]["housenumber"];
     }
-    catch (json::exception& e)
+    catch (const json::exception& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/dump.cpp

@@ -35,7 +35,7 @@ int main()
     {
         std::cout << j_invalid.dump() << std::endl;
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << std::endl;
     }

docs/examples/error_handler_t.cpp

@@ -11,7 +11,7 @@ int main()
     {
         std::cout << j_invalid.dump() << std::endl;
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << std::endl;
     }

docs/examples/exception.cpp

@@ -11,7 +11,7 @@ int main()
         json j = {{"foo", "bar"}};
         json k = j.at("non-existing");
     }
-    catch (json::exception& e)
+    catch (const json::exception& e)
     {
         // output exception information
         std::cout << "message: " << e.what() << '\n'

docs/examples/get_ref.cpp

@@ -20,7 +20,7 @@ int main()
     {
         auto r3 = value.get_ref<json::number_float_t&>();
     }
-    catch (json::type_error& ex)
+    catch (const json::type_error& ex)
     {
         std::cout << ex.what() << '\n';
     }

docs/examples/get_to.cpp

@@ -30,7 +30,6 @@ int main()
     std::vector<short> v7;
     std::unordered_map<std::string, json> v8;
 
-
     // use explicit conversions
     json_types["boolean"].get_to(v1);
     json_types["number"]["integer"].get_to(v2);

docs/examples/invalid_iterator.cpp

@@ -12,7 +12,7 @@ int main()
         json::iterator it = j.begin();
         auto k = it.key();
     }
-    catch (json::invalid_iterator& e)
+    catch (const json::invalid_iterator& e)
     {
         // output exception information
         std::cout << "message: " << e.what() << '\n'

docs/examples/json_pointer.cpp

@@ -20,7 +20,7 @@ int main()
     {
         json::json_pointer p9("foo");
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -30,7 +30,7 @@ int main()
     {
         json::json_pointer p10("/foo/~");
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }
@@ -40,7 +40,7 @@ int main()
     {
         json::json_pointer p11("/foo/~3");
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/nlohmann_define_type_intrusive_explicit.cpp

@@ -53,7 +53,7 @@ int main()
     {
         auto p3 = j3.template get<ns::person>();
     }
-    catch (json::exception& e)
+    catch (const json::exception& e)
     {
         std::cout << "deserialization failed: " << e.what() << std::endl;
     }

docs/examples/nlohmann_define_type_intrusive_macro.cpp

@@ -41,7 +41,7 @@ int main()
     {
         auto p3 = j3.template get<ns::person>();
     }
-    catch (json::exception& e)
+    catch (const json::exception& e)
     {
         std::cout << "deserialization failed: " << e.what() << std::endl;
     }

docs/examples/nlohmann_define_type_non_intrusive_explicit.cpp

@@ -46,7 +46,7 @@ int main()
     {
         auto p3 = j3.template get<ns::person>();
     }
-    catch (json::exception& e)
+    catch (const json::exception& e)
     {
         std::cout << "deserialization failed: " << e.what() << std::endl;
     }

docs/examples/nlohmann_define_type_non_intrusive_macro.cpp

@@ -34,7 +34,7 @@ int main()
     {
         auto p3 = j3.template get<ns::person>();
     }
-    catch (json::exception& e)
+    catch (const json::exception& e)
     {
         std::cout << "deserialization failed: " << e.what() << std::endl;
     }

docs/examples/object.cpp

@@ -21,7 +21,7 @@ int main()
         // can only create an object from a list of pairs
         json j_invalid_object = json::object({{ "one", 1, 2 }});
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/operator__ValueType.cpp

@@ -53,7 +53,7 @@ int main()
     {
         bool v1 = json_types["string"];
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         std::cout << e.what() << '\n';
     }

docs/examples/operator_spaceship__const_reference.c++20.cpp

@@ -32,7 +32,6 @@ int main()
     json string = "foo";
     json discarded = json(json::value_t::discarded);
 
-
     // output values and comparisons
     std::cout << array_1 << " <=> " << array_2 << " := " << to_string(array_1 <=> array_2) << '\n'; // *NOPAD*
     std::cout << object_1 << " <=> " << object_2 << " := " << to_string(object_1 <=> object_2) << '\n'; // *NOPAD*

docs/examples/operator_spaceship__scalartype.c++20.cpp

@@ -31,7 +31,6 @@ int main()
     json number = 17;
     json string = "17";
 
-
     // output values and comparisons
     std::cout << std::boolalpha << std::fixed;
     std::cout << boolean << " <=> " << true << " := " << to_string(boolean <=> true) << '\n'; // *NOPAD*

docs/examples/other_error.cpp

@@ -21,7 +21,7 @@ int main()
         }])"_json;
         value.patch(patch);
     }
-    catch (json::other_error& e)
+    catch (const json::other_error& e)
     {
         // output exception information
         std::cout << "message: " << e.what() << '\n'

docs/examples/out_of_range.cpp

@@ -11,7 +11,7 @@ int main()
         json j = {1, 2, 3, 4};
         j.at(4) = 10;
     }
-    catch (json::out_of_range& e)
+    catch (const json::out_of_range& e)
     {
         // output exception information
         std::cout << "message: " << e.what() << '\n'

docs/examples/parse__allow_exceptions.cpp

@@ -17,7 +17,7 @@ int main()
     {
         json j = json::parse(text);
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         std::cout << e.what() << std::endl;
     }

docs/examples/parse__istream__parser_callback_t.cpp

@@ -33,7 +33,6 @@ int main()
     json j_complete = json::parse(ss);
     std::cout << std::setw(4) << j_complete << "\n\n";
 
-
     // define parser callback
     json::parser_callback_t cb = [](int depth, json::parse_event_t event, json & parsed)
     {

docs/examples/parse__string__parser_callback_t.cpp

@@ -28,7 +28,6 @@ int main()
     json j_complete = json::parse(text);
     std::cout << std::setw(4) << j_complete << "\n\n";
 
-
     // define parser callback
     json::parser_callback_t cb = [](int depth, json::parse_event_t event, json & parsed)
     {

docs/examples/parse_error.cpp

@@ -10,7 +10,7 @@ int main()
         // parsing input with a syntax error
         json::parse("[1,2,3,]");
     }
-    catch (json::parse_error& e)
+    catch (const json::parse_error& e)
     {
         // output exception information
         std::cout << "message: " << e.what() << '\n'

docs/examples/type_error.cpp

@@ -11,7 +11,7 @@ int main()
         json j = "string";
         j.push_back("another string");
     }
-    catch (json::type_error& e)
+    catch (const json::type_error& e)
     {
         // output exception information
         std::cout << "message: " << e.what() << '\n'

docs/mkdocs/docs/api/basic_json/index.md

@@ -13,8 +13,8 @@ template<
     class NumberFloatType = double,
     template<typename U> class AllocatorType = std::allocator,
     template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer,
-    class BinaryType = std::vector<std::uint8_t,
-    class CustomBaseClass = void>
+    class BinaryType = std::vector<std::uint8_t>,
+    class CustomBaseClass = void
 >
 class basic_json;
 ```

docs/mkdocs/docs/api/macros/json_has_static_rtti.md

@@ -0,0 +1,31 @@
+# JSON_HAS_STATIC_RTTI
+
+```cpp
+#define JSON_HAS_STATIC_RTTI /* value */
+```
+
+This macro indicates whether the standard library has any support for RTTI (run time type information).
+Possible values are `1` when supported or `0` when unsupported.
+
+## Default definition
+
+The default value is detected based on the preprocessor macro `#!cpp _HAS_STATIC_RTTI`.
+
+When the macro is not defined, the library will define it to its default value.
+
+## Examples
+
+??? example
+
+    The code below forces the library to enable support for libraries with RTTI dependence:
+
+    ```cpp
+    #define JSON_HAS_STATIC_RTTI 1
+    #include <nlohmann/json.hpp>
+
+    ...
+    ```
+    
+## Version history
+
+- Added in version ?.

docs/mkdocs/docs/api/macros/nlohmann_define_type_intrusive.md

@@ -59,7 +59,7 @@ See examples below for the concrete generated code.
 
     Consider the following complete example:
 
-    ```cpp hl_lines="21"
+    ```cpp hl_lines="22"
     --8<-- "examples/nlohmann_define_type_intrusive_macro.cpp"
     ```
     
@@ -80,7 +80,7 @@ See examples below for the concrete generated code.
 
     The macro is equivalent to:
 
-    ```cpp hl_lines="21 22 23 24 25 26 27 28 29 30 31 32 33"
+    ```cpp hl_lines="22 23 24 25 26 27 28 29 30 31 32 33 34"
     --8<-- "examples/nlohmann_define_type_intrusive_explicit.cpp"
     ```
 
@@ -88,7 +88,7 @@ See examples below for the concrete generated code.
 
     Consider the following complete example:
 
-    ```cpp hl_lines="21"
+    ```cpp hl_lines="22"
     --8<-- "examples/nlohmann_define_type_intrusive_with_default_macro.cpp"
     ```
     
@@ -108,7 +108,7 @@ See examples below for the concrete generated code.
 
     The macro is equivalent to:
 
-    ```cpp hl_lines="21 22 23 24 25 26 27 28 29 30 31 32 33 34"
+    ```cpp hl_lines="21 22 23 24 25 26 27 28 29 30 31 32 33 34 35"
     --8<-- "examples/nlohmann_define_type_intrusive_with_default_explicit.cpp"
     ```
 

docs/mkdocs/docs/api/macros/nlohmann_define_type_non_intrusive.md

@@ -60,7 +60,7 @@ See examples below for the concrete generated code.
 
     Consider the following complete example:
 
-    ```cpp hl_lines="15"
+    ```cpp hl_lines="16"
     --8<-- "examples/nlohmann_define_type_non_intrusive_macro.cpp"
     ```
     
@@ -80,7 +80,7 @@ See examples below for the concrete generated code.
 
     The macro is equivalent to:
 
-    ```cpp hl_lines="15 16 17 18 19 20 21 22 23 24 25 26 27"
+    ```cpp hl_lines="16 17 18 19 20 21 22 23 24 25 26 27 28"
     --8<-- "examples/nlohmann_define_type_non_intrusive_explicit.cpp"
     ```
 
@@ -88,7 +88,7 @@ See examples below for the concrete generated code.
 
     Consider the following complete example:
 
-    ```cpp hl_lines="20"
+    ```cpp hl_lines="21"
     --8<-- "examples/nlohmann_define_type_non_intrusive_with_default_macro.cpp"
     ```
     
@@ -109,7 +109,7 @@ See examples below for the concrete generated code.
 
     The macro is equivalent to:
 
-    ```cpp hl_lines="20 21 22 23 24 25 26 27 28 29 30 31 32 33"
+    ```cpp hl_lines="21 22 23 24 25 26 27 28 29 30 31 32 33 34"
     --8<-- "examples/nlohmann_define_type_non_intrusive_with_default_explicit.cpp"
     ```
 

docs/mkdocs/docs/api/operator_literal_json.md

@@ -1,7 +1,7 @@
 # <small>nlohmann::</small>operator""_json
 
 ```cpp
-json operator "" _json(const char* s, std::size_t n);
+json operator ""_json(const char* s, std::size_t n);
 ```
 
 This operator implements a user-defined string literal for JSON objects. It can be used by adding `#!cpp _json` to a
@@ -9,7 +9,7 @@ string literal and returns a [`json`](json.md) object if no parse error occurred
 
 It is recommended to bring the operator into scope using any of the following lines:
 ```cpp
-using nlohmann::literals::operator "" _json;
+using nlohmann::literals::operator ""_json;
 using namespace nlohmann::literals;
 using namespace nlohmann::json_literals;
 using namespace nlohmann::literals::json_literals;

docs/mkdocs/docs/api/operator_literal_json_pointer.md

@@ -1,7 +1,7 @@
 # <small>nlohmann::</small>operator""_json_pointer
 
 ```cpp
-json_pointer operator "" _json_pointer(const char* s, std::size_t n);
+json_pointer operator ""_json_pointer(const char* s, std::size_t n);
 ```
 
 This operator implements a user-defined string literal for JSON Pointers. It can be used by adding `#!cpp _json_pointer`
@@ -9,7 +9,7 @@ to a string literal and returns a [`json_pointer`](json_pointer/index.md) object
 
 It is recommended to bring the operator into scope using any of the following lines:
 ```cpp
-using nlohmann::literals::operator "" _json_pointer;
+using nlohmann::literals::operator ""_json_pointer;
 using namespace nlohmann::literals;
 using namespace nlohmann::json_literals;
 using namespace nlohmann::literals::json_literals;

include/nlohmann/detail/exceptions.hpp

@@ -25,7 +25,6 @@
 #include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 
-
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {

include/nlohmann/detail/input/binary_reader.hpp

@@ -55,7 +55,6 @@ static inline bool little_endianness(int num = 1) noexcept
     return *reinterpret_cast<char*>(&num) == 1;
 }
 
-
 ///////////////////
 // binary reader //
 ///////////////////

include/nlohmann/detail/input/input_adapters.hpp

@@ -71,7 +71,6 @@ class file_input_adapter
     std::FILE* m_file;
 };
 
-
 /*!
 Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
 beginning of input. Does not support changing the underlying std::streambuf
@@ -170,7 +169,6 @@ class iterator_input_adapter
     }
 };
 
-
 template<typename BaseInputAdapter, size_t T>
 struct wide_string_input_helper;
 
@@ -294,7 +292,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
     }
 };
 
-// Wraps another input apdater to convert wide character types into individual bytes.
+// Wraps another input adapter to convert wide character types into individual bytes.
 template<typename BaseInputAdapter, typename WideCharType>
 class wide_string_input_adapter
 {
@@ -339,7 +337,6 @@ class wide_string_input_adapter
     std::size_t utf8_bytes_filled = 0;
 };
 
-
 template<typename IteratorType, typename Enable = void>
 struct iterator_input_adapter_factory
 {

include/nlohmann/detail/input/json_sax.hpp

@@ -142,7 +142,6 @@ struct json_sax
     virtual ~json_sax() = default;
 };
 
-
 namespace detail
 {
 /*!
@@ -591,7 +590,7 @@ class json_sax_dom_callback_parser
         if (ref_stack.empty())
         {
             root = std::move(value);
-            return {true, &root};
+            return {true, & root};
         }
 
         // skip this value if we already decided to skip the parent
@@ -608,7 +607,7 @@ class json_sax_dom_callback_parser
         if (ref_stack.back()->is_array())
         {
             ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
-            return {true, &(ref_stack.back()->m_data.m_value.array->back())};
+            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
         }
 
         // object

include/nlohmann/detail/input/lexer.hpp

@@ -222,7 +222,7 @@ class lexer : public lexer_base<BasicJsonType>
         for (auto range = ranges.begin(); range != ranges.end(); ++range)
         {
             get();
-            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
             {
                 add(current);
             }

include/nlohmann/detail/iterators/iteration_proxy.hpp

@@ -69,10 +69,10 @@ template<typename IteratorType> class iteration_proxy_value
     // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
     iteration_proxy_value(iteration_proxy_value&&)
     noexcept(std::is_nothrow_move_constructible<IteratorType>::value
-             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
     iteration_proxy_value& operator=(iteration_proxy_value&&)
     noexcept(std::is_nothrow_move_assignable<IteratorType>::value
-             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
     ~iteration_proxy_value() = default;
 
     /// dereference operator (needed for range-based for)

include/nlohmann/detail/macro_scope.hpp

@@ -133,6 +133,14 @@
     #endif
 #endif
 
+#ifndef JSON_HAS_STATIC_RTTI
+    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
+        #define JSON_HAS_STATIC_RTTI 1
+    #else
+        #define JSON_HAS_STATIC_RTTI 0
+    #endif
+#endif
+
 #ifdef JSON_HAS_CPP_17
     #define JSON_INLINE_VARIABLE inline
 #else
@@ -411,7 +419,6 @@
     inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
     inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
 
-
 // inspired from https://stackoverflow.com/a/26745591
 // allows to call any std function as if (e.g. with begin):
 // using std::begin; begin(x);

include/nlohmann/detail/macro_unscope.hpp

@@ -38,6 +38,7 @@
     #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
     #undef JSON_HAS_THREE_WAY_COMPARISON
     #undef JSON_HAS_RANGES
+    #undef JSON_HAS_STATIC_RTTI
     #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
 #endif
 

include/nlohmann/detail/meta/type_traits.hpp

@@ -217,7 +217,6 @@ template <typename... Ts>
 struct is_default_constructible<const std::tuple<Ts...>>
             : conjunction<is_default_constructible<Ts>...> {};
 
-
 template <typename T, typename... Args>
 struct is_constructible : std::is_constructible<T, Args...> {};
 
@@ -233,7 +232,6 @@ struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple
 template <typename... Ts>
 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
 
-
 template<typename T, typename = void>
 struct is_iterator_traits : std::false_type {};
 
@@ -643,7 +641,6 @@ struct value_in_range_of_impl2<OfType, T, false, true>
     }
 };
 
-
 template<typename OfType, typename T>
 struct value_in_range_of_impl2<OfType, T, true, true>
 {

include/nlohmann/json.hpp

@@ -62,7 +62,9 @@
 #include <nlohmann/ordered_map.hpp>
 
 #if defined(JSON_HAS_CPP_17)
-    #include <any>
+    #if JSON_HAS_STATIC_RTTI
+        #include <any>
+    #endif
     #include <string_view>
 #endif
 
@@ -192,7 +194,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     /////////////////////
     // container types //
     /////////////////////
@@ -234,7 +235,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     /// @brief returns the allocator associated with the container
     /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
     static allocator_type get_allocator()
@@ -297,7 +297,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
 #endif
 
-
 #if defined(_MSVC_LANG)
         result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
 #elif defined(__cplusplus)
@@ -308,7 +307,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return result;
     }
 
-
     ///////////////////////////
     // JSON value data types //
     ///////////////////////////
@@ -910,7 +908,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         bool is_an_object = std::all_of(init.begin(), init.end(),
                                         [](const detail::json_ref<basic_json>& element_ref)
         {
-            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
+            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
+            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
+            // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
         });
 
         // adjust type if type deduction is not wanted
@@ -1130,7 +1131,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         assert_invariant();
     }
 
-
     ///////////////////////////////////////
     // other constructors and destructor //
     ///////////////////////////////////////
@@ -1888,7 +1888,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
                                                 detail::negation<std::is_same<ValueType, std::string_view>>,
 #endif
-#if defined(JSON_HAS_CPP_17)
+#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
                                                 detail::negation<std::is_same<ValueType, std::any>>,
 #endif
                                                 detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
@@ -1925,7 +1925,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ////////////////////
     // element access //
     ////////////////////
@@ -2640,7 +2639,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ////////////
     // lookup //
     ////////////
@@ -2758,7 +2756,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ///////////////
     // iterators //
     ///////////////
@@ -2897,7 +2894,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     //////////////
     // capacity //
     //////////////
@@ -3019,7 +3015,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ///////////////
     // modifiers //
     ///////////////
@@ -3467,7 +3462,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     void swap(reference other) noexcept (
         std::is_nothrow_move_constructible<value_t>::value&&
         std::is_nothrow_move_assignable<value_t>::value&&
-        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
         std::is_nothrow_move_assignable<json_value>::value
     )
     {
@@ -3484,7 +3479,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     friend void swap(reference left, reference right) noexcept (
         std::is_nothrow_move_constructible<value_t>::value&&
         std::is_nothrow_move_assignable<value_t>::value&&
-        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
         std::is_nothrow_move_assignable<json_value>::value
     )
     {
@@ -3493,7 +3488,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(array_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for arrays
         if (JSON_HEDLEY_LIKELY(is_array()))
@@ -3509,7 +3504,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(object_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for objects
         if (JSON_HEDLEY_LIKELY(is_object()))
@@ -3525,7 +3520,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(string_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for strings
         if (JSON_HEDLEY_LIKELY(is_string()))
@@ -3541,7 +3536,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(binary_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for strings
         if (JSON_HEDLEY_LIKELY(is_binary()))
@@ -4006,7 +4001,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #endif  // JSON_NO_IO
     /// @}
 
-
     /////////////////////
     // deserialization //
     /////////////////////
@@ -4187,7 +4181,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-
   JSON_PRIVATE_UNLESS_TESTED:
     //////////////////////
     // member variables //
@@ -4405,7 +4398,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
     }
 
-
     JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
     static basic_json from_cbor(detail::span_input_adapter&& i,
@@ -4529,7 +4521,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return res ? result : basic_json(value_t::discarded);
     }
 
-
     /// @brief create a JSON value from an input in BJData format
     /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
     template<typename InputType>
@@ -4810,7 +4801,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         };
 
         // wrapper for "remove" operation; remove value at ptr
-        const auto operation_remove = [this, &result](json_pointer & ptr)
+        const auto operation_remove = [this, & result](json_pointer & ptr)
         {
             // get reference to parent of JSON pointer ptr
             const auto last_path = ptr.back();
@@ -5173,7 +5164,11 @@ inline namespace json_literals
 /// @brief user-defined string literal for JSON values
 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
 JSON_HEDLEY_NON_NULL(1)
-inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
+#else
+    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#endif
 {
     return nlohmann::json::parse(s, s + n);
 }
@@ -5181,7 +5176,11 @@ inline nlohmann::json operator "" _json(const char* s, std::size_t n)
 /// @brief user-defined string literal for JSON pointer
 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
 JSON_HEDLEY_NON_NULL(1)
-inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
+#else
+    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#endif
 {
     return nlohmann::json::json_pointer(std::string(s, n));
 }
@@ -5234,7 +5233,7 @@ struct less< ::nlohmann::detail::value_t> // do not remove the space after '<',
 /// @sa https://json.nlohmann.me/api/basic_json/std_swap/
 NLOHMANN_BASIC_JSON_TPL_DECLARATION
 inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
-    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
 {
     j1.swap(j2);
@@ -5245,8 +5244,13 @@ inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC
 }  // namespace std
 
 #if JSON_USE_GLOBAL_UDLS
-    using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
-    using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #else
+        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #endif
 #endif
 
 #include <nlohmann/detail/macro_unscope.hpp>

single_include/nlohmann/json.hpp

@@ -2485,6 +2485,14 @@ JSON_HEDLEY_DIAGNOSTIC_POP
     #endif
 #endif
 
+#ifndef JSON_HAS_STATIC_RTTI
+    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
+        #define JSON_HAS_STATIC_RTTI 1
+    #else
+        #define JSON_HAS_STATIC_RTTI 0
+    #endif
+#endif
+
 #ifdef JSON_HAS_CPP_17
     #define JSON_INLINE_VARIABLE inline
 #else
@@ -2763,7 +2771,6 @@ JSON_HEDLEY_DIAGNOSTIC_POP
     inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
     inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
 
-
 // inspired from https://stackoverflow.com/a/26745591
 // allows to call any std function as if (e.g. with begin):
 // using std::begin; begin(x);
@@ -3617,7 +3624,6 @@ template <typename... Ts>
 struct is_default_constructible<const std::tuple<Ts...>>
             : conjunction<is_default_constructible<Ts>...> {};
 
-
 template <typename T, typename... Args>
 struct is_constructible : std::is_constructible<T, Args...> {};
 
@@ -3633,7 +3639,6 @@ struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple
 template <typename... Ts>
 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
 
-
 template<typename T, typename = void>
 struct is_iterator_traits : std::false_type {};
 
@@ -4043,7 +4048,6 @@ struct value_in_range_of_impl2<OfType, T, false, true>
     }
 };
 
-
 template<typename OfType, typename T>
 struct value_in_range_of_impl2<OfType, T, true, true>
 {
@@ -4290,7 +4294,6 @@ inline OutStringType concat(Args && ... args)
 NLOHMANN_JSON_NAMESPACE_END
 
 
-
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
@@ -5151,10 +5154,10 @@ template<typename IteratorType> class iteration_proxy_value
     // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
     iteration_proxy_value(iteration_proxy_value&&)
     noexcept(std::is_nothrow_move_constructible<IteratorType>::value
-             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
     iteration_proxy_value& operator=(iteration_proxy_value&&)
     noexcept(std::is_nothrow_move_assignable<IteratorType>::value
-             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
     ~iteration_proxy_value() = default;
 
     /// dereference operator (needed for range-based for)
@@ -6144,7 +6147,6 @@ class file_input_adapter
     std::FILE* m_file;
 };
 
-
 /*!
 Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
 beginning of input. Does not support changing the underlying std::streambuf
@@ -6243,7 +6245,6 @@ class iterator_input_adapter
     }
 };
 
-
 template<typename BaseInputAdapter, size_t T>
 struct wide_string_input_helper;
 
@@ -6367,7 +6368,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
     }
 };
 
-// Wraps another input apdater to convert wide character types into individual bytes.
+// Wraps another input adapter to convert wide character types into individual bytes.
 template<typename BaseInputAdapter, typename WideCharType>
 class wide_string_input_adapter
 {
@@ -6412,7 +6413,6 @@ class wide_string_input_adapter
     std::size_t utf8_bytes_filled = 0;
 };
 
-
 template<typename IteratorType, typename Enable = void>
 struct iterator_input_adapter_factory
 {
@@ -6714,7 +6714,6 @@ struct json_sax
     virtual ~json_sax() = default;
 };
 
-
 namespace detail
 {
 /*!
@@ -7163,7 +7162,7 @@ class json_sax_dom_callback_parser
         if (ref_stack.empty())
         {
             root = std::move(value);
-            return {true, &root};
+            return {true, & root};
         }
 
         // skip this value if we already decided to skip the parent
@@ -7180,7 +7179,7 @@ class json_sax_dom_callback_parser
         if (ref_stack.back()->is_array())
         {
             ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
-            return {true, &(ref_stack.back()->m_data.m_value.array->back())};
+            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
         }
 
         // object
@@ -7527,7 +7526,7 @@ class lexer : public lexer_base<BasicJsonType>
         for (auto range = ranges.begin(); range != ranges.end(); ++range)
         {
             get();
-            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
             {
                 add(current);
             }
@@ -9133,7 +9132,6 @@ static inline bool little_endianness(int num = 1) noexcept
     return *reinterpret_cast<char*>(&num) == 1;
 }
 
-
 ///////////////////
 // binary reader //
 ///////////////////
@@ -19278,7 +19276,9 @@ NLOHMANN_JSON_NAMESPACE_END
 
 
 #if defined(JSON_HAS_CPP_17)
-    #include <any>
+    #if JSON_HAS_STATIC_RTTI
+        #include <any>
+    #endif
     #include <string_view>
 #endif
 
@@ -19408,7 +19408,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     /////////////////////
     // container types //
     /////////////////////
@@ -19450,7 +19449,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     /// @brief returns the allocator associated with the container
     /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
     static allocator_type get_allocator()
@@ -19513,7 +19511,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
 #endif
 
-
 #if defined(_MSVC_LANG)
         result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
 #elif defined(__cplusplus)
@@ -19524,7 +19521,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return result;
     }
 
-
     ///////////////////////////
     // JSON value data types //
     ///////////////////////////
@@ -20126,7 +20122,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         bool is_an_object = std::all_of(init.begin(), init.end(),
                                         [](const detail::json_ref<basic_json>& element_ref)
         {
-            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
+            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
+            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
+            // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
         });
 
         // adjust type if type deduction is not wanted
@@ -20346,7 +20345,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         assert_invariant();
     }
 
-
     ///////////////////////////////////////
     // other constructors and destructor //
     ///////////////////////////////////////
@@ -21104,7 +21102,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
                                                 detail::negation<std::is_same<ValueType, std::string_view>>,
 #endif
-#if defined(JSON_HAS_CPP_17)
+#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
                                                 detail::negation<std::is_same<ValueType, std::any>>,
 #endif
                                                 detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
@@ -21141,7 +21139,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ////////////////////
     // element access //
     ////////////////////
@@ -21856,7 +21853,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ////////////
     // lookup //
     ////////////
@@ -21974,7 +21970,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ///////////////
     // iterators //
     ///////////////
@@ -22113,7 +22108,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     //////////////
     // capacity //
     //////////////
@@ -22235,7 +22229,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @}
 
-
     ///////////////
     // modifiers //
     ///////////////
@@ -22683,7 +22676,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     void swap(reference other) noexcept (
         std::is_nothrow_move_constructible<value_t>::value&&
         std::is_nothrow_move_assignable<value_t>::value&&
-        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
         std::is_nothrow_move_assignable<json_value>::value
     )
     {
@@ -22700,7 +22693,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     friend void swap(reference left, reference right) noexcept (
         std::is_nothrow_move_constructible<value_t>::value&&
         std::is_nothrow_move_assignable<value_t>::value&&
-        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
         std::is_nothrow_move_assignable<json_value>::value
     )
     {
@@ -22709,7 +22702,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(array_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for arrays
         if (JSON_HEDLEY_LIKELY(is_array()))
@@ -22725,7 +22718,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(object_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for objects
         if (JSON_HEDLEY_LIKELY(is_object()))
@@ -22741,7 +22734,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(string_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for strings
         if (JSON_HEDLEY_LIKELY(is_string()))
@@ -22757,7 +22750,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
-    void swap(binary_t& other) // NOLINT(bugprone-exception-escape)
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         // swap only works for strings
         if (JSON_HEDLEY_LIKELY(is_binary()))
@@ -23222,7 +23215,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #endif  // JSON_NO_IO
     /// @}
 
-
     /////////////////////
     // deserialization //
     /////////////////////
@@ -23403,7 +23395,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-
   JSON_PRIVATE_UNLESS_TESTED:
     //////////////////////
     // member variables //
@@ -23621,7 +23612,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
     }
 
-
     JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
     static basic_json from_cbor(detail::span_input_adapter&& i,
@@ -23745,7 +23735,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return res ? result : basic_json(value_t::discarded);
     }
 
-
     /// @brief create a JSON value from an input in BJData format
     /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
     template<typename InputType>
@@ -24026,7 +24015,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         };
 
         // wrapper for "remove" operation; remove value at ptr
-        const auto operation_remove = [this, &result](json_pointer & ptr)
+        const auto operation_remove = [this, & result](json_pointer & ptr)
         {
             // get reference to parent of JSON pointer ptr
             const auto last_path = ptr.back();
@@ -24389,7 +24378,11 @@ inline namespace json_literals
 /// @brief user-defined string literal for JSON values
 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
 JSON_HEDLEY_NON_NULL(1)
-inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
+#else
+    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#endif
 {
     return nlohmann::json::parse(s, s + n);
 }
@@ -24397,7 +24390,11 @@ inline nlohmann::json operator "" _json(const char* s, std::size_t n)
 /// @brief user-defined string literal for JSON pointer
 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
 JSON_HEDLEY_NON_NULL(1)
-inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
+#else
+    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#endif
 {
     return nlohmann::json::json_pointer(std::string(s, n));
 }
@@ -24450,7 +24447,7 @@ struct less< ::nlohmann::detail::value_t> // do not remove the space after '<',
 /// @sa https://json.nlohmann.me/api/basic_json/std_swap/
 NLOHMANN_BASIC_JSON_TPL_DECLARATION
 inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
-    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
 {
     j1.swap(j2);
@@ -24461,8 +24458,13 @@ inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC
 }  // namespace std
 
 #if JSON_USE_GLOBAL_UDLS
-    using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
-    using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #else
+        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #endif
 #endif
 
 // #include <nlohmann/detail/macro_unscope.hpp>
@@ -24506,6 +24508,7 @@ inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC
     #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
     #undef JSON_HAS_THREE_WAY_COMPARISON
     #undef JSON_HAS_RANGES
+    #undef JSON_HAS_STATIC_RTTI
     #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
 #endif
 

tests/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.13...3.14)
 
 option(JSON_Valgrind    "Execute test suite with Valgrind." OFF)
 option(JSON_FastTests   "Skip expensive/slow tests." OFF)

tests/abi/include/nlohmann/json_v3_10_5.hpp

@@ -5491,7 +5491,7 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
     }
 };
 
-// Wraps another input apdater to convert wide character types into individual bytes.
+// Wraps another input adapter to convert wide character types into individual bytes.
 template<typename BaseInputAdapter, typename WideCharType>
 class wide_string_input_adapter
 {

tests/benchmarks/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.11)
+cmake_minimum_required(VERSION 3.11...3.14)
 project(JSON_Benchmarks LANGUAGES CXX)
 
 # set compiler flags

tests/benchmarks/src/benchmarks.cpp

@@ -81,7 +81,6 @@ BENCHMARK_CAPTURE(ParseString, signed_ints,       TEST_DATA_DIRECTORY "/regressi
 BENCHMARK_CAPTURE(ParseString, unsigned_ints,     TEST_DATA_DIRECTORY "/regression/unsigned_ints.json");
 BENCHMARK_CAPTURE(ParseString, small_signed_ints, TEST_DATA_DIRECTORY "/regression/small_signed_ints.json");
 
-
 //////////////////////////////////////////////////////////////////////////////
 // serialize JSON
 //////////////////////////////////////////////////////////////////////////////
@@ -116,7 +115,6 @@ BENCHMARK_CAPTURE(Dump, unsigned_ints / 4,     TEST_DATA_DIRECTORY "/regression/
 BENCHMARK_CAPTURE(Dump, small_signed_ints / -, TEST_DATA_DIRECTORY "/regression/small_signed_ints.json",      -1);
 BENCHMARK_CAPTURE(Dump, small_signed_ints / 4, TEST_DATA_DIRECTORY "/regression/small_signed_ints.json",      4);
 
-
 //////////////////////////////////////////////////////////////////////////////
 // serialize CBOR
 //////////////////////////////////////////////////////////////////////////////

tests/cmake_add_subdirectory/project/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.1...3.14)
 
 project(DummyImport CXX)
 

tests/cmake_fetch_content/project/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.11)
+cmake_minimum_required(VERSION 3.11...3.14)
 
 project(DummyImport CXX)
 

tests/cmake_import/project/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.1...3.14)
 
 project(DummyImport CXX)
 

tests/cmake_import_minver/project/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.1...3.14)
 
 project(DummyImportMinVer CXX)
 

tests/cmake_target_include_directories/project/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.1...3.14)
 
 project(DummyImport CXX)
 

tests/src/fuzzer-parse_bjdata.cpp

@@ -45,7 +45,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
             // step 2.1: round trip without adding size annotations to container types
             std::vector<uint8_t> const vec2 = json::to_bjdata(j1, false, false);
 
-            // step 2.2: round trip with adding size annotations but without adding type annonations to container types
+            // step 2.2: round trip with adding size annotations but without adding type annotations to container types
             std::vector<uint8_t> const vec3 = json::to_bjdata(j1, true, false);
 
             // step 2.3: round trip with adding size as well as type annotations to container types

tests/src/fuzzer-parse_ubjson.cpp

@@ -45,7 +45,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
             // step 2.1: round trip without adding size annotations to container types
             std::vector<uint8_t> const vec2 = json::to_ubjson(j1, false, false);
 
-            // step 2.2: round trip with adding size annotations but without adding type annonations to container types
+            // step 2.2: round trip with adding size annotations but without adding type annotations to container types
             std::vector<uint8_t> const vec3 = json::to_ubjson(j1, true, false);
 
             // step 2.3: round trip with adding size as well as type annotations to container types

tests/src/unit-32bit.cpp

@@ -14,7 +14,6 @@ using nlohmann::json;
 #include <climits> // SIZE_MAX
 #include <limits> // numeric_limits
 
-
 template <typename OfType, typename T, bool MinInRange, bool MaxInRange>
 struct trait_test_arg
 {
@@ -88,7 +87,6 @@ TEST_CASE_TEMPLATE_DEFINE("value_in_range_of trait", T, value_in_range_of_test)
     }
 }
 
-
 TEST_CASE("32bit")
 {
     REQUIRE(SIZE_MAX == 0xffffffff);

tests/src/unit-algorithms.cpp

@@ -319,7 +319,6 @@ TEST_CASE("algorithms")
         }
     }
 
-
     SECTION("copy")
     {
         SECTION("copy without if")
@@ -336,7 +335,6 @@ TEST_CASE("algorithms")
             json dest_arr;
             const json source_arr = {0, 3, 6, 9, 12, 15, 20};
 
-
             std::copy_if(source_arr.begin(), source_arr.end(), std::back_inserter(dest_arr), [](const json & _value)
             {
                 return _value.get<int>() % 3 == 0;
@@ -364,6 +362,4 @@ TEST_CASE("algorithms")
         }
     }
 
-
-
 }

tests/src/unit-alt-string.cpp

@@ -14,7 +14,6 @@
 #include <string>
 #include <utility>
 
-
 /* forward declarations */
 class alt_string;
 bool operator<(const char* op1, const alt_string& op2) noexcept;
@@ -180,7 +179,6 @@ using alt_json = nlohmann::basic_json <
                  std::allocator,
                  nlohmann::adl_serializer >;
 
-
 bool operator<(const char* op1, const alt_string& op2) noexcept
 {
     return op1 < op2.str_impl;

tests/src/unit-bjdata.cpp

@@ -1499,7 +1499,6 @@ TEST_CASE("BJData")
             }
         }
 
-
         SECTION("binary")
         {
             SECTION("N = 0..127")

tests/src/unit-bson.cpp

@@ -562,7 +562,7 @@ TEST_CASE("BSON")
         }
     }
 
-    SECTION("Examples from http://bsonspec.org/faq.html")
+    SECTION("Examples from https://bsonspec.org/faq.html")
     {
         SECTION("Example 1")
         {
@@ -919,7 +919,6 @@ TEST_CASE("BSON numerical data")
                 }
             }
 
-
             SECTION("signed std::int32_t: INT32_MIN .. INT32_MAX")
             {
                 std::vector<int32_t> const numbers

tests/src/unit-cbor.cpp

@@ -1962,7 +1962,7 @@ TEST_CASE("CBOR regressions")
                     CHECK(false);
                 }
             }
-            catch (const json::parse_error&)
+            catch (const json::parse_error&) // NOLINT(bugprone-empty-catch)
             {
                 // parse errors are ok, because input may be random bytes
             }

tests/src/unit-class_parser.cpp

@@ -542,13 +542,13 @@ TEST_CASE("parser class")
                     CHECK(parser_helper("9007199254740991").get<int64_t>() == 9007199254740991);
                 }
 
-                SECTION("over the edge cases")  // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers)
+                SECTION("over the edge cases")  // issue #178 - Integer conversion to unsigned (incorrect handling of 64-bit integers)
                 {
                     // While RFC8259, Section 6 specifies a preference for support
                     // for ranges in range of IEEE 754-2008 binary64 (double precision)
-                    // this does not accommodate 64 bit integers without loss of accuracy.
-                    // As 64 bit integers are now widely used in software, it is desirable
-                    // to expand support to to the full 64 bit (signed and unsigned) range
+                    // this does not accommodate 64-bit integers without loss of accuracy.
+                    // As 64-bit integers are now widely used in software, it is desirable
+                    // to expand support to the full 64 bit (signed and unsigned) range
                     // i.e. -(2**63) -> (2**64)-1.
 
                     // -(2**63)    ** Note: compilers see negative literals as negated positive numbers (hence the -1))
@@ -822,7 +822,7 @@ TEST_CASE("parser class")
                     CHECK(accept_helper("9007199254740991"));
                 }
 
-                SECTION("over the edge cases")  // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers)
+                SECTION("over the edge cases")  // issue #178 - Integer conversion to unsigned (incorrect handling of 64-bit integers)
                 {
                     // While RFC8259, Section 6 specifies a preference for support
                     // for ranges in range of IEEE 754-2008 binary64 (double precision)

tests/src/unit-constructor1.cpp

@@ -172,7 +172,6 @@ TEST_CASE("constructors")
             CHECK(j == j_reference);
         }
 
-
         SECTION("std::multimap<json::string_t, json>")
         {
             std::multimap<json::string_t, json> const o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

tests/src/unit-custom-base-class.cpp

@@ -229,7 +229,6 @@ using json_with_visitor_t = nlohmann::basic_json <
                             visitor_adaptor
                             >;
 
-
 template <class Fnc>
 void visitor_adaptor::visit(const Fnc& fnc) const
 {

tests/src/unit-element_access2.cpp

@@ -72,7 +72,6 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j
                 CHECK_THROWS_WITH_AS(j.at("foo"), "[json.exception.out_of_range.403] key 'foo' not found", typename Json::out_of_range&);
                 CHECK_THROWS_WITH_AS(j_const.at("foo"), "[json.exception.out_of_range.403] key 'foo' not found", typename Json::out_of_range&);
 
-
 #ifdef JSON_HAS_CPP_17
                 CHECK_THROWS_WITH_AS(j.at(std::string_view("foo")), "[json.exception.out_of_range.403] key 'foo' not found", typename Json::out_of_range&);
                 CHECK_THROWS_WITH_AS(j_const.at(std::string_view("foo")), "[json.exception.out_of_range.403] key 'foo' not found", typename Json::out_of_range&);
@@ -1522,9 +1521,9 @@ TEST_CASE_TEMPLATE("element access 2 (additional value() tests)", Json, nlohmann
             CHECK(j.value("foo", cpstr) == "bar");
             CHECK(j.value("foo", castr) == "bar");
             CHECK(j.value("foo", str) == "bar");
-            // this test is in fact different than the one below,
+            // this test is in fact different from the one below,
             // because of 0 considering const char * overloads
-            // where as any other number does not
+            // whereas any other number does not
             CHECK(j.value("baz", 0) == 42);
             CHECK(j.value("baz", 47) == 42);
             CHECK(j.value("baz", integer) == 42);

tests/src/unit-iterators2.cpp

@@ -873,7 +873,6 @@ TEST_CASE("iterators 2")
         }
     }
 
-
 #if JSON_HAS_RANGES
     // JSON_HAS_CPP_20 (do not remove; see note at top of file)
     SECTION("ranges")

tests/src/unit-json_pointer.cpp

@@ -123,8 +123,7 @@ TEST_CASE("JSON pointers")
             CHECK(j.contains(json::json_pointer("/a~1b")));
             CHECK(j.contains(json::json_pointer("/m~0n")));
 
-            // unescaped access
-            // access to nonexisting values yield object creation
+            // unescaped access to nonexisting values yield object creation
             CHECK(!j.contains(json::json_pointer("/a/b")));
             CHECK_NOTHROW(j[json::json_pointer("/a/b")] = 42);
             CHECK(j.contains(json::json_pointer("/a/b")));

tests/src/unit-msgpack.cpp

@@ -1124,7 +1124,7 @@ TEST_CASE("MessagePack")
                 // Checking against an expected vector byte by byte is
                 // difficult, because no assumption on the order of key/value
                 // pairs are made. We therefore only check the prefix (type and
-                // size and the overall size. The rest is then handled in the
+                // size) and the overall size. The rest is then handled in the
                 // roundtrip check.
                 CHECK(result.size() == 67); // 1 type, 2 size, 16*4 content
                 CHECK(result[0] == 0xde); // map 16
@@ -1153,7 +1153,7 @@ TEST_CASE("MessagePack")
                 // Checking against an expected vector byte by byte is
                 // difficult, because no assumption on the order of key/value
                 // pairs are made. We therefore only check the prefix (type and
-                // size and the overall size. The rest is then handled in the
+                // size) and the overall size. The rest is then handled in the
                 // roundtrip check.
                 CHECK(result.size() == 458757); // 1 type, 4 size, 65536*7 content
                 CHECK(result[0] == 0xdf); // map 32

tests/src/unit-no-mem-leak-on-adl-serialize.cpp

@@ -51,7 +51,7 @@ TEST_CASE("check_for_mem_leak_on_adl_to_json-1")
         const nlohmann::json j = Foo {1, 0};
         std::cout << j.dump() << "\n";
     }
-    catch (...)
+    catch (...) // NOLINT(bugprone-empty-catch)
     {
         // just ignore the exception in this POC
     }
@@ -64,7 +64,7 @@ TEST_CASE("check_for_mem_leak_on_adl_to_json-2")
         const nlohmann::json j = Foo {1, 1};
         std::cout << j.dump() << "\n";
     }
-    catch (...)
+    catch (...) // NOLINT(bugprone-empty-catch)
     {
         // just ignore the exception in this POC
     }
@@ -77,7 +77,7 @@ TEST_CASE("check_for_mem_leak_on_adl_to_json-2")
         const nlohmann::json j = Foo {1, 2};
         std::cout << j.dump() << "\n";
     }
-    catch (...)
+    catch (...) // NOLINT(bugprone-empty-catch)
     {
         // just ignore the exception in this POC
     }

tests/src/unit-ordered_json.cpp

@@ -12,7 +12,6 @@
 using nlohmann::json;
 using nlohmann::ordered_json;
 
-
 TEST_CASE("ordered_json")
 {
     json j;

tests/src/unit-ordered_map.cpp

@@ -11,7 +11,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::ordered_map;
 
-
 TEST_CASE("ordered_map")
 {
     SECTION("constructor")

tests/src/unit-regression1.cpp

@@ -1203,7 +1203,6 @@ TEST_CASE("regression tests 1")
         CHECK(j["a"] >= 3);
         CHECK(j["a"] >  3);
 
-
         CHECK(!(j["a"] <= 4));
         CHECK(!(j["a"] <  4));
         CHECK(!(j["a"] >= 6));

tests/src/unit-unicode1.cpp

@@ -442,7 +442,7 @@ TEST_CASE("Markus Kuhn's UTF-8 decoder capability and stress test")
 
         SECTION("4.1  Examples of an overlong ASCII character")
         {
-            // With a safe UTF-8 decoder, all of the following five overlong
+            // With a safe UTF-8 decoder, all the following five overlong
             // representations of the ASCII character slash ("/") should be rejected
             // like a malformed UTF-8 sequence, for instance by substituting it with
             // a replacement character. If you see a slash below, you do not have a

tests/thirdparty/Fuzzer/afl/afl_driver.cpp

@@ -71,7 +71,7 @@ statistics from the file. If that fails then the process will quit.
 #endif
 
 // Used to avoid repeating error checking boilerplate. If cond is false, a
-// fatal error has occured in the program. In this event print error_message
+// fatal error has occurred in the program. In this event print error_message
 // to stderr and abort(). Otherwise do nothing. Note that setting
 // AFL_DRIVER_STDERR_DUPLICATE_FILENAME may cause error_message to be appended
 // to the file as well, if the error occurs after the duplication is performed.

tests/thirdparty/fifo_map/fifo_map.hpp

@@ -393,7 +393,7 @@ template <
     }
 
     /// swaps the contents
-    void swap(fifo_map& other)
+    void swap(fifo_map& other) // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
     {
         std::swap(m_map, other.m_map);
         std::swap(m_compare, other.m_compare);
@@ -520,7 +520,7 @@ template <
 namespace std // NOLINT(cert-dcl58-cpp,-warnings-as-errors)
 {
 template <class Key, class T, class Compare, class Allocator>
-inline void swap(nlohmann::fifo_map<Key, T, Compare, Allocator>& m1, // NOLINT(cert-dcl58-cpp)
+inline void swap(nlohmann::fifo_map<Key, T, Compare, Allocator>& m1, // NOLINT(cert-dcl58-cpp,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
                  nlohmann::fifo_map<Key, T, Compare, Allocator>& m2)
 {
     m1.swap(m2);

tools/serve_header/README.md

@@ -65,7 +65,7 @@ An annotated example configuration can be found in `tools/serve_header/serve_hea
 `serve_header.py` was designed with the goal of supporting multiple project roots or working trees at the same time.
 The recommended directory structure is shown below but `serve_header.py` can work with other structures as well, including a nested hierarchy.
 ```
-json/          ⮜ the parent or web server root directoy
+json/          ⮜ the parent or web server root directory
 ├── develop/   ⮜ the main git checkout
 │   └── ...
 ├── feature1/