Merge b6e2fd10bb into 6eab7a2b18

docs/examples/json_base_class_t.cpp

@@ -79,8 +79,8 @@ int main()
 
     // visit and output
     j.visit(
-        [&](const json::json_pointer & p,
+         [&](const json::json_pointer & p,
-            const json & j)
+             const json & j)
     {
         std::cout << (p.empty() ? std::string{"/"} : p.to_string())
                   << " - metadata = " << j.metadata << " -> " << j.dump() << '\n';

docs/mkdocs/docs/api/macros/nlohmann_define_derived_type.md

@@ -0,0 +1,118 @@
+# NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT
+
+# NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT
+
+```cpp
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(type, base_type, member...)                  // (1)
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(type, base_type, member...)     // (2)
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(type, base_type, member...)              // (3)
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(type, base_type, member...) // (4)
+```
+
+These macros can be used to simplify the serialization/deserialization of derived types if you want to use a JSON
+object as serialization and want to use the member variable names as object keys in that object.
+
+- Macros 1 and 2 are to be defined **inside** the class/struct to create code for.
+Like [`NLOHMANN_DEFINE_TYPE_INTRUSIVE`](nlohmann_define_type_intrusive.md), they can access private members.
+- Macros 3 and 4 are to be defined **outside** the class/struct to create code for, but **inside** its namespace.
+Like [`NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`](nlohmann_define_type_non_intrusive.md),
+they **cannot** access private members.
+
+
+The first  parameter is the name of the derived class/struct,
+the second parameter is the name of the base class/struct and all remaining parameters name the members.
+The base type **must** be already serializable/deserializable.
+
+- Macros 1 and 3 will use [`at`](../basic_json/at.md) during deserialization and will throw
+  [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a key is missing in the JSON object.
+- Macros 2 and 4 will use [`value`](../basic_json/value.md) during deserialization and fall back to the default value for the
+   respective type of the member variable if a key in the JSON object is missing. The generated `from_json()` function
+   default constructs an object and uses its values as the defaults when calling the `value` function.
+
+## Parameters
+
+`type` (in)
+:   name of the type (class, struct) to serialize/deserialize
+
+`base_type` (in)
+:   name of the base type (class, struct) `type` is derived from
+
+`member` (in)
+:   name of the member variable to serialize/deserialize; up to 64 members can be given as comma-separated list
+
+## Default definition
+
+Macros 1 and 2 add two friend functions to the class which take care of the serialization and deserialization:
+
+```cpp
+friend void to_json(nlohmann::json&, const type&);
+friend void from_json(const nlohmann::json&, type&);
+```
+
+Macros 3 and 4 add two functions to the namespace which take care of the serialization and deserialization:
+
+```cpp
+void to_json(nlohmann::json&, const type&);
+void from_json(const nlohmann::json&, type&);
+```
+
+In both cases they call the `to_json`/`from_json` functions of the base type
+before serializing/deserializing the members of the derived type:
+
+```cpp
+class A { /* ... */ };
+class B : public A { /* ... */ };
+
+void to_json(nlohmann::json& j, const B& b) {
+    nlohmann::to_json(j, static_cast<const A&>(b));
+    // ...
+}
+
+void from_json(const nlohmann::json& j, B& b) {
+    nlohmann::from_json(j, static_cast<A&>(b));
+    // ...
+}
+```
+
+## Notes
+
+!!! info "Prerequisites"
+
+    - Macros 1 and 2 have the same prerequisites of NLOHMANN_DEFINE_TYPE_INTRUSIVE. 
+    - Macros 3 and 3 have the same prerequisites of NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE.
+    - Serialization/deserialization of base types must be defined.
+
+!!! warning "Implementation limits"
+
+    - See Implementation limits for NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE.
+
+## Examples
+
+Example of `NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE` usage:
+
+```cpp
+class A {
+  double Aa;
+  double Ab;
+  NLOHMANN_DEFINE_TYPE_INTRUSIVE(A, Aa, Ab)
+};
+
+class B : public A {
+  int Ba;
+  int Bb;
+  NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(B, A, Ba, Bb)
+};
+```
+
+## See also
+
+- [NLOHMANN_DEFINE_TYPE_INTRUSIVE / NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT](nlohmann_define_type_intrusive.md)
+  for similar macros that can be defined _inside_ a non-derived type.
+- [NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE / NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT](nlohmann_define_type_non_intrusive.md)
+  for a similar macros that can be defined _outside_ a non-derived type.
+- [Arbitrary Type Conversions](../../features/arbitrary_types.md) for an overview.
+
+## Version history
+
+1. Added in version 3.11.x.

include/nlohmann/detail/abi_macros.hpp

@@ -53,8 +53,8 @@
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
-            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+        NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
-            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+        NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -79,8 +79,8 @@
 #ifndef NLOHMANN_JSON_NAMESPACE
 #define NLOHMANN_JSON_NAMESPACE               \
     nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
-            NLOHMANN_JSON_ABI_TAGS,           \
+        NLOHMANN_JSON_ABI_TAGS,           \
-            NLOHMANN_JSON_NAMESPACE_VERSION)
+        NLOHMANN_JSON_NAMESPACE_VERSION)
 #endif
 
 #ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -88,8 +88,8 @@
     namespace nlohmann                               \
     {                                                \
     inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
-                NLOHMANN_JSON_ABI_TAGS,              \
+            NLOHMANN_JSON_ABI_TAGS,              \
-                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+            NLOHMANN_JSON_NAMESPACE_VERSION)     \
     {
 #endif
 

include/nlohmann/detail/conversions/from_json.hpp

@@ -263,7 +263,7 @@ template < typename BasicJsonType, typename ConstructibleArrayType,
 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
 j.template get<typename ConstructibleArrayType::value_type>(),
-void())
+ void())
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
     {
@@ -275,7 +275,7 @@ void())
 
 template < typename BasicJsonType, typename T, std::size_t... Idx >
 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
-        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+                    identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
 {
     return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
 }

include/nlohmann/detail/input/binary_reader.hpp

@@ -525,7 +525,7 @@ class binary_reader
             {
                 std::uint64_t number{};
                 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
-                        - static_cast<number_integer_t>(number));
+                       - static_cast<number_integer_t>(number));
             }
 
             // Binary data (0x00..0x17 bytes follow)

include/nlohmann/detail/iterators/iteration_proxy.hpp

@@ -220,7 +220,7 @@ namespace std
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
-            : public std::integral_constant<std::size_t, 2> {};
+        : public std::integral_constant<std::size_t, 2> {};
 
 template<std::size_t N, typename IteratorType>
 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)

include/nlohmann/detail/iterators/iterator_traits.hpp

@@ -43,7 +43,7 @@ struct iterator_traits
 
 template<typename T>
 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
-            : iterator_types<T>
+        : iterator_types<T>
 {
 };
 

include/nlohmann/detail/macro_scope.hpp

@@ -261,70 +261,70 @@
 #define NLOHMANN_JSON_EXPAND( x ) x
 #define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
-        NLOHMANN_JSON_PASTE64, \
+    NLOHMANN_JSON_PASTE64, \
-        NLOHMANN_JSON_PASTE63, \
+    NLOHMANN_JSON_PASTE63, \
-        NLOHMANN_JSON_PASTE62, \
+    NLOHMANN_JSON_PASTE62, \
-        NLOHMANN_JSON_PASTE61, \
+    NLOHMANN_JSON_PASTE61, \
-        NLOHMANN_JSON_PASTE60, \
+    NLOHMANN_JSON_PASTE60, \
-        NLOHMANN_JSON_PASTE59, \
+    NLOHMANN_JSON_PASTE59, \
-        NLOHMANN_JSON_PASTE58, \
+    NLOHMANN_JSON_PASTE58, \
-        NLOHMANN_JSON_PASTE57, \
+    NLOHMANN_JSON_PASTE57, \
-        NLOHMANN_JSON_PASTE56, \
+    NLOHMANN_JSON_PASTE56, \
-        NLOHMANN_JSON_PASTE55, \
+    NLOHMANN_JSON_PASTE55, \
-        NLOHMANN_JSON_PASTE54, \
+    NLOHMANN_JSON_PASTE54, \
-        NLOHMANN_JSON_PASTE53, \
+    NLOHMANN_JSON_PASTE53, \
-        NLOHMANN_JSON_PASTE52, \
+    NLOHMANN_JSON_PASTE52, \
-        NLOHMANN_JSON_PASTE51, \
+    NLOHMANN_JSON_PASTE51, \
-        NLOHMANN_JSON_PASTE50, \
+    NLOHMANN_JSON_PASTE50, \
-        NLOHMANN_JSON_PASTE49, \
+    NLOHMANN_JSON_PASTE49, \
-        NLOHMANN_JSON_PASTE48, \
+    NLOHMANN_JSON_PASTE48, \
-        NLOHMANN_JSON_PASTE47, \
+    NLOHMANN_JSON_PASTE47, \
-        NLOHMANN_JSON_PASTE46, \
+    NLOHMANN_JSON_PASTE46, \
-        NLOHMANN_JSON_PASTE45, \
+    NLOHMANN_JSON_PASTE45, \
-        NLOHMANN_JSON_PASTE44, \
+    NLOHMANN_JSON_PASTE44, \
-        NLOHMANN_JSON_PASTE43, \
+    NLOHMANN_JSON_PASTE43, \
-        NLOHMANN_JSON_PASTE42, \
+    NLOHMANN_JSON_PASTE42, \
-        NLOHMANN_JSON_PASTE41, \
+    NLOHMANN_JSON_PASTE41, \
-        NLOHMANN_JSON_PASTE40, \
+    NLOHMANN_JSON_PASTE40, \
-        NLOHMANN_JSON_PASTE39, \
+    NLOHMANN_JSON_PASTE39, \
-        NLOHMANN_JSON_PASTE38, \
+    NLOHMANN_JSON_PASTE38, \
-        NLOHMANN_JSON_PASTE37, \
+    NLOHMANN_JSON_PASTE37, \
-        NLOHMANN_JSON_PASTE36, \
+    NLOHMANN_JSON_PASTE36, \
-        NLOHMANN_JSON_PASTE35, \
+    NLOHMANN_JSON_PASTE35, \
-        NLOHMANN_JSON_PASTE34, \
+    NLOHMANN_JSON_PASTE34, \
-        NLOHMANN_JSON_PASTE33, \
+    NLOHMANN_JSON_PASTE33, \
-        NLOHMANN_JSON_PASTE32, \
+    NLOHMANN_JSON_PASTE32, \
-        NLOHMANN_JSON_PASTE31, \
+    NLOHMANN_JSON_PASTE31, \
-        NLOHMANN_JSON_PASTE30, \
+    NLOHMANN_JSON_PASTE30, \
-        NLOHMANN_JSON_PASTE29, \
+    NLOHMANN_JSON_PASTE29, \
-        NLOHMANN_JSON_PASTE28, \
+    NLOHMANN_JSON_PASTE28, \
-        NLOHMANN_JSON_PASTE27, \
+    NLOHMANN_JSON_PASTE27, \
-        NLOHMANN_JSON_PASTE26, \
+    NLOHMANN_JSON_PASTE26, \
-        NLOHMANN_JSON_PASTE25, \
+    NLOHMANN_JSON_PASTE25, \
-        NLOHMANN_JSON_PASTE24, \
+    NLOHMANN_JSON_PASTE24, \
-        NLOHMANN_JSON_PASTE23, \
+    NLOHMANN_JSON_PASTE23, \
-        NLOHMANN_JSON_PASTE22, \
+    NLOHMANN_JSON_PASTE22, \
-        NLOHMANN_JSON_PASTE21, \
+    NLOHMANN_JSON_PASTE21, \
-        NLOHMANN_JSON_PASTE20, \
+    NLOHMANN_JSON_PASTE20, \
-        NLOHMANN_JSON_PASTE19, \
+    NLOHMANN_JSON_PASTE19, \
-        NLOHMANN_JSON_PASTE18, \
+    NLOHMANN_JSON_PASTE18, \
-        NLOHMANN_JSON_PASTE17, \
+    NLOHMANN_JSON_PASTE17, \
-        NLOHMANN_JSON_PASTE16, \
+    NLOHMANN_JSON_PASTE16, \
-        NLOHMANN_JSON_PASTE15, \
+    NLOHMANN_JSON_PASTE15, \
-        NLOHMANN_JSON_PASTE14, \
+    NLOHMANN_JSON_PASTE14, \
-        NLOHMANN_JSON_PASTE13, \
+    NLOHMANN_JSON_PASTE13, \
-        NLOHMANN_JSON_PASTE12, \
+    NLOHMANN_JSON_PASTE12, \
-        NLOHMANN_JSON_PASTE11, \
+    NLOHMANN_JSON_PASTE11, \
-        NLOHMANN_JSON_PASTE10, \
+    NLOHMANN_JSON_PASTE10, \
-        NLOHMANN_JSON_PASTE9, \
+    NLOHMANN_JSON_PASTE9, \
-        NLOHMANN_JSON_PASTE8, \
+    NLOHMANN_JSON_PASTE8, \
-        NLOHMANN_JSON_PASTE7, \
+    NLOHMANN_JSON_PASTE7, \
-        NLOHMANN_JSON_PASTE6, \
+    NLOHMANN_JSON_PASTE6, \
-        NLOHMANN_JSON_PASTE5, \
+    NLOHMANN_JSON_PASTE5, \
-        NLOHMANN_JSON_PASTE4, \
+    NLOHMANN_JSON_PASTE4, \
-        NLOHMANN_JSON_PASTE3, \
+    NLOHMANN_JSON_PASTE3, \
-        NLOHMANN_JSON_PASTE2, \
+    NLOHMANN_JSON_PASTE2, \
-        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+    NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
@@ -419,6 +419,32 @@
     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__)) }
 
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE
+@since version 3.11.x
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE
+@since version 3.11.x
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(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) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(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) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(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/meta/type_traits.hpp

@@ -203,19 +203,19 @@ struct is_default_constructible : std::is_default_constructible<T> {};
 
 template <typename T1, typename T2>
 struct is_default_constructible<std::pair<T1, T2>>
-            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+        : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
 
 template <typename T1, typename T2>
 struct is_default_constructible<const std::pair<T1, T2>>
-            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+        : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
 
 template <typename... Ts>
 struct is_default_constructible<std::tuple<Ts...>>
-            : conjunction<is_default_constructible<Ts>...> {};
+        : conjunction<is_default_constructible<Ts>...> {};
 
 template <typename... Ts>
 struct is_default_constructible<const std::tuple<Ts...>>
-            : conjunction<is_default_constructible<Ts>...> {};
+        : conjunction<is_default_constructible<Ts>...> {};
 
 template <typename T, typename... Args>
 struct is_constructible : std::is_constructible<T, Args...> {};
@@ -396,7 +396,7 @@ struct is_constructible_array_type_impl <
     BasicJsonType, ConstructibleArrayType,
     enable_if_t<std::is_same<ConstructibleArrayType,
     typename BasicJsonType::value_type>::value >>
-            : std::true_type {};
+        : std::true_type {};
 
 template<typename BasicJsonType, typename ConstructibleArrayType>
 struct is_constructible_array_type_impl <
@@ -413,8 +413,8 @@ is_detected<range_value_t, ConstructibleArrayType>::value&&
 // special case for types like std::filesystem::path whose iterator's value_type are themselves
 // c.f. https://github.com/nlohmann/json/pull/3073
 !std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
-        is_complete_type <
+    is_complete_type <
-        detected_t<range_value_t, ConstructibleArrayType >>::value >>
+    detected_t<range_value_t, ConstructibleArrayType >>::value >>
 {
     using value_type = range_value_t<ConstructibleArrayType>;
 
@@ -537,12 +537,12 @@ using is_usable_as_key_type = typename std::conditional <
 template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
          bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
 using is_usable_as_basic_json_key_type = typename std::conditional <
-        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
+    is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
-        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
+    typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
-        RequireTransparentComparator, ExcludeObjectKeyType>::value
+    RequireTransparentComparator, ExcludeObjectKeyType>::value
-        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
+    && !is_json_iterator_of<BasicJsonType, KeyType>::value,
-        std::true_type,
+    std::true_type,
-        std::false_type >::type;
+    std::false_type >::type;
 
 template<typename ObjectType, typename KeyType>
 using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));

include/nlohmann/detail/output/binary_writer.hpp

@@ -1162,7 +1162,7 @@ class binary_writer
     @return The calculated size for the BSON document entry for @a j with the given @a name.
     */
     static std::size_t calc_bson_element_size(const string_t& name,
-            const BasicJsonType& j)
+        const BasicJsonType& j)
     {
         const auto header_size = calc_bson_entry_header_size(name, j);
         switch (j.type())

include/nlohmann/json.hpp

@@ -137,7 +137,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     )
     {
         return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
-                std::move(cb), allow_exceptions, ignore_comments);
+               std::move(cb), allow_exceptions, ignore_comments);
     }
 
   private:
@@ -833,8 +833,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                detail::enable_if_t <
                    !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
     basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
-                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+            JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
-                                           std::forward<CompatibleType>(val))))
+                                       std::forward<CompatibleType>(val))))
     {
         JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
         set_parents();
@@ -940,8 +940,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             {
                 auto element = element_ref.moved_or_copied();
                 m_data.m_value.object->emplace(
-                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
+                          std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
-                    std::move((*element.m_data.m_value.array)[1]));
+                          std::move((*element.m_data.m_value.array)[1]));
             }
         }
         else
@@ -1604,7 +1604,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    detail::has_from_json<basic_json_t, ValueType>::value,
                    int > = 0 >
     ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
-                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
     {
         auto ret = ValueType();
         JSONSerializer<ValueType>::from_json(*this, ret);
@@ -1646,7 +1646,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    detail::has_non_default_from_json<basic_json_t, ValueType>::value,
                    int > = 0 >
     ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
-                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
     {
         return JSONSerializer<ValueType>::from_json(*this);
     }
@@ -1796,7 +1796,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    detail::has_from_json<basic_json_t, ValueType>::value,
                    int > = 0 >
     ValueType & get_to(ValueType& v) const noexcept(noexcept(
-                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
     {
         JSONSerializer<ValueType>::from_json(*this, v);
         return v;
@@ -1886,13 +1886,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                                         detail::negation<detail::is_basic_json<ValueType>>,
                                         detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
 #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>>,
+                                            detail::negation<std::is_same<ValueType, std::string_view>>,
 #endif
 #if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
-                                                detail::negation<std::is_same<ValueType, std::any>>,
+                                            detail::negation<std::is_same<ValueType, std::any>>,
 #endif
-                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                            detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
-                                                >::value, int >::type = 0 >
+                                            >::value, int >::type = 0 >
                                         JSON_EXPLICIT operator ValueType() const
     {
         // delegate the call to get<>() const
@@ -4281,8 +4281,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief create a UBJSON serialization of a given JSON value
     /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
     static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
-            const bool use_size = false,
+        const bool use_size = false,
-            const bool use_type = false)
+        const bool use_type = false)
     {
         std::vector<std::uint8_t> result;
         to_ubjson(j, result, use_size, use_type);
@@ -4308,8 +4308,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief create a BJData serialization of a given JSON value
     /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
     static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
-            const bool use_size = false,
+        const bool use_size = false,
-            const bool use_type = false)
+        const bool use_type = false)
     {
         std::vector<std::uint8_t> result;
         to_bjdata(j, result, use_size, use_type);

include/nlohmann/ordered_map.hpp

@@ -26,7 +26,7 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
 /// for use within nlohmann::basic_json<ordered_map>
 template <class Key, class T, class IgnoredLess = std::less<Key>,
           class Allocator = std::allocator<std::pair<const Key, T>>>
-                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+              struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
 {
     using key_type = Key;
     using mapped_type = T;
@@ -341,7 +341,7 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
 
     template<typename InputIt>
     using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
-            std::input_iterator_tag>::value>::type;
+        std::input_iterator_tag>::value>::type;
 
     template<typename InputIt, typename = require_input_iter<InputIt>>
     void insert(InputIt first, InputIt last)

include/nlohmann/thirdparty/hedley/hedley.hpp

@@ -1811,13 +1811,13 @@ JSON_HEDLEY_DIAGNOSTIC_POP
        defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
        defined(__clang__)
 #    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
-        sizeof(void) != \
+    sizeof(void) != \
-        sizeof(*( \
+    sizeof(*( \
-                  1 ? \
+              1 ? \
-                  ((void*) ((expr) * 0L) ) : \
+              ((void*) ((expr) * 0L) ) : \
 ((struct { char v[sizeof(void) * 2]; } *) 1) \
-                ) \
+            ) \
-              ) \
+          ) \
                                             )
 #  endif
 #endif

single_include/nlohmann/json.hpp

@@ -41,7 +41,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 #include <utility>
 
 // #include <nlohmann/detail/abi_macros.hpp>
@@ -54,7 +53,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 // This file contains all macro definitions affecting or depending on the ABI
 
 #ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
@@ -100,8 +98,8 @@
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
-            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+        NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
-            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+        NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -126,8 +124,8 @@
 #ifndef NLOHMANN_JSON_NAMESPACE
 #define NLOHMANN_JSON_NAMESPACE               \
     nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
-            NLOHMANN_JSON_ABI_TAGS,           \
+        NLOHMANN_JSON_ABI_TAGS,           \
-            NLOHMANN_JSON_NAMESPACE_VERSION)
+        NLOHMANN_JSON_NAMESPACE_VERSION)
 #endif
 
 #ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -135,8 +133,8 @@
     namespace nlohmann                               \
     {                                                \
     inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
-                NLOHMANN_JSON_ABI_TAGS,              \
+            NLOHMANN_JSON_ABI_TAGS,              \
-                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+            NLOHMANN_JSON_NAMESPACE_VERSION)     \
     {
 #endif
 
@@ -156,7 +154,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 #include <algorithm> // transform
 #include <array> // array
 #include <forward_list> // forward_list
@@ -179,7 +176,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstddef> // nullptr_t
 #include <exception> // exception
 #if JSON_DIAGNOSTICS
@@ -199,7 +195,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 #include <array> // array
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t
@@ -215,7 +210,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 #include <utility> // declval, pair
 // #include <nlohmann/detail/meta/detected.hpp>
 //     __ _____ _____ _____
@@ -227,7 +221,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 #include <type_traits>
 
 // #include <nlohmann/detail/meta/void_t.hpp>
@@ -240,7 +233,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 // #include <nlohmann/detail/abi_macros.hpp>
 
 
@@ -2129,13 +2121,13 @@ JSON_HEDLEY_DIAGNOSTIC_POP
        defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
        defined(__clang__)
 #    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
-        sizeof(void) != \
+    sizeof(void) != \
-        sizeof(*( \
+    sizeof(*( \
-                  1 ? \
+              1 ? \
-                  ((void*) ((expr) * 0L) ) : \
+              ((void*) ((expr) * 0L) ) : \
 ((struct { char v[sizeof(void) * 2]; } *) 1) \
-                ) \
+            ) \
-              ) \
+          ) \
                                             )
 #  endif
 #endif
@@ -2613,70 +2605,70 @@ JSON_HEDLEY_DIAGNOSTIC_POP
 #define NLOHMANN_JSON_EXPAND( x ) x
 #define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
-        NLOHMANN_JSON_PASTE64, \
+    NLOHMANN_JSON_PASTE64, \
-        NLOHMANN_JSON_PASTE63, \
+    NLOHMANN_JSON_PASTE63, \
-        NLOHMANN_JSON_PASTE62, \
+    NLOHMANN_JSON_PASTE62, \
-        NLOHMANN_JSON_PASTE61, \
+    NLOHMANN_JSON_PASTE61, \
-        NLOHMANN_JSON_PASTE60, \
+    NLOHMANN_JSON_PASTE60, \
-        NLOHMANN_JSON_PASTE59, \
+    NLOHMANN_JSON_PASTE59, \
-        NLOHMANN_JSON_PASTE58, \
+    NLOHMANN_JSON_PASTE58, \
-        NLOHMANN_JSON_PASTE57, \
+    NLOHMANN_JSON_PASTE57, \
-        NLOHMANN_JSON_PASTE56, \
+    NLOHMANN_JSON_PASTE56, \
-        NLOHMANN_JSON_PASTE55, \
+    NLOHMANN_JSON_PASTE55, \
-        NLOHMANN_JSON_PASTE54, \
+    NLOHMANN_JSON_PASTE54, \
-        NLOHMANN_JSON_PASTE53, \
+    NLOHMANN_JSON_PASTE53, \
-        NLOHMANN_JSON_PASTE52, \
+    NLOHMANN_JSON_PASTE52, \
-        NLOHMANN_JSON_PASTE51, \
+    NLOHMANN_JSON_PASTE51, \
-        NLOHMANN_JSON_PASTE50, \
+    NLOHMANN_JSON_PASTE50, \
-        NLOHMANN_JSON_PASTE49, \
+    NLOHMANN_JSON_PASTE49, \
-        NLOHMANN_JSON_PASTE48, \
+    NLOHMANN_JSON_PASTE48, \
-        NLOHMANN_JSON_PASTE47, \
+    NLOHMANN_JSON_PASTE47, \
-        NLOHMANN_JSON_PASTE46, \
+    NLOHMANN_JSON_PASTE46, \
-        NLOHMANN_JSON_PASTE45, \
+    NLOHMANN_JSON_PASTE45, \
-        NLOHMANN_JSON_PASTE44, \
+    NLOHMANN_JSON_PASTE44, \
-        NLOHMANN_JSON_PASTE43, \
+    NLOHMANN_JSON_PASTE43, \
-        NLOHMANN_JSON_PASTE42, \
+    NLOHMANN_JSON_PASTE42, \
-        NLOHMANN_JSON_PASTE41, \
+    NLOHMANN_JSON_PASTE41, \
-        NLOHMANN_JSON_PASTE40, \
+    NLOHMANN_JSON_PASTE40, \
-        NLOHMANN_JSON_PASTE39, \
+    NLOHMANN_JSON_PASTE39, \
-        NLOHMANN_JSON_PASTE38, \
+    NLOHMANN_JSON_PASTE38, \
-        NLOHMANN_JSON_PASTE37, \
+    NLOHMANN_JSON_PASTE37, \
-        NLOHMANN_JSON_PASTE36, \
+    NLOHMANN_JSON_PASTE36, \
-        NLOHMANN_JSON_PASTE35, \
+    NLOHMANN_JSON_PASTE35, \
-        NLOHMANN_JSON_PASTE34, \
+    NLOHMANN_JSON_PASTE34, \
-        NLOHMANN_JSON_PASTE33, \
+    NLOHMANN_JSON_PASTE33, \
-        NLOHMANN_JSON_PASTE32, \
+    NLOHMANN_JSON_PASTE32, \
-        NLOHMANN_JSON_PASTE31, \
+    NLOHMANN_JSON_PASTE31, \
-        NLOHMANN_JSON_PASTE30, \
+    NLOHMANN_JSON_PASTE30, \
-        NLOHMANN_JSON_PASTE29, \
+    NLOHMANN_JSON_PASTE29, \
-        NLOHMANN_JSON_PASTE28, \
+    NLOHMANN_JSON_PASTE28, \
-        NLOHMANN_JSON_PASTE27, \
+    NLOHMANN_JSON_PASTE27, \
-        NLOHMANN_JSON_PASTE26, \
+    NLOHMANN_JSON_PASTE26, \
-        NLOHMANN_JSON_PASTE25, \
+    NLOHMANN_JSON_PASTE25, \
-        NLOHMANN_JSON_PASTE24, \
+    NLOHMANN_JSON_PASTE24, \
-        NLOHMANN_JSON_PASTE23, \
+    NLOHMANN_JSON_PASTE23, \
-        NLOHMANN_JSON_PASTE22, \
+    NLOHMANN_JSON_PASTE22, \
-        NLOHMANN_JSON_PASTE21, \
+    NLOHMANN_JSON_PASTE21, \
-        NLOHMANN_JSON_PASTE20, \
+    NLOHMANN_JSON_PASTE20, \
-        NLOHMANN_JSON_PASTE19, \
+    NLOHMANN_JSON_PASTE19, \
-        NLOHMANN_JSON_PASTE18, \
+    NLOHMANN_JSON_PASTE18, \
-        NLOHMANN_JSON_PASTE17, \
+    NLOHMANN_JSON_PASTE17, \
-        NLOHMANN_JSON_PASTE16, \
+    NLOHMANN_JSON_PASTE16, \
-        NLOHMANN_JSON_PASTE15, \
+    NLOHMANN_JSON_PASTE15, \
-        NLOHMANN_JSON_PASTE14, \
+    NLOHMANN_JSON_PASTE14, \
-        NLOHMANN_JSON_PASTE13, \
+    NLOHMANN_JSON_PASTE13, \
-        NLOHMANN_JSON_PASTE12, \
+    NLOHMANN_JSON_PASTE12, \
-        NLOHMANN_JSON_PASTE11, \
+    NLOHMANN_JSON_PASTE11, \
-        NLOHMANN_JSON_PASTE10, \
+    NLOHMANN_JSON_PASTE10, \
-        NLOHMANN_JSON_PASTE9, \
+    NLOHMANN_JSON_PASTE9, \
-        NLOHMANN_JSON_PASTE8, \
+    NLOHMANN_JSON_PASTE8, \
-        NLOHMANN_JSON_PASTE7, \
+    NLOHMANN_JSON_PASTE7, \
-        NLOHMANN_JSON_PASTE6, \
+    NLOHMANN_JSON_PASTE6, \
-        NLOHMANN_JSON_PASTE5, \
+    NLOHMANN_JSON_PASTE5, \
-        NLOHMANN_JSON_PASTE4, \
+    NLOHMANN_JSON_PASTE4, \
-        NLOHMANN_JSON_PASTE3, \
+    NLOHMANN_JSON_PASTE3, \
-        NLOHMANN_JSON_PASTE2, \
+    NLOHMANN_JSON_PASTE2, \
-        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+    NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
@@ -2771,6 +2763,33 @@ 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__)) }
 
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE
+@since version 3.11.x
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE
+@since version 3.11.x
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(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) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(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) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(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);
@@ -2940,7 +2959,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 // #include <nlohmann/detail/abi_macros.hpp>
 
 
@@ -3015,7 +3033,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstddef> // size_t
 
 // #include <nlohmann/detail/abi_macros.hpp>
@@ -3058,7 +3075,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <array> // array
 #include <cstddef> // size_t
 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
@@ -3231,7 +3247,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <limits> // numeric_limits
 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
 #include <utility> // declval
@@ -3247,7 +3262,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <iterator> // random_access_iterator_tag
 
 // #include <nlohmann/detail/abi_macros.hpp>
@@ -3286,7 +3300,7 @@ struct iterator_traits
 
 template<typename T>
 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
-            : iterator_types<T>
+        : iterator_types<T>
 {
 };
 
@@ -3315,7 +3329,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 // #include <nlohmann/detail/macro_scope.hpp>
 
 
@@ -3335,7 +3348,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 // #include <nlohmann/detail/macro_scope.hpp>
 
 
@@ -3610,19 +3622,19 @@ struct is_default_constructible : std::is_default_constructible<T> {};
 
 template <typename T1, typename T2>
 struct is_default_constructible<std::pair<T1, T2>>
-            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+        : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
 
 template <typename T1, typename T2>
 struct is_default_constructible<const std::pair<T1, T2>>
-            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+        : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
 
 template <typename... Ts>
 struct is_default_constructible<std::tuple<Ts...>>
-            : conjunction<is_default_constructible<Ts>...> {};
+        : conjunction<is_default_constructible<Ts>...> {};
 
 template <typename... Ts>
 struct is_default_constructible<const std::tuple<Ts...>>
-            : conjunction<is_default_constructible<Ts>...> {};
+        : conjunction<is_default_constructible<Ts>...> {};
 
 template <typename T, typename... Args>
 struct is_constructible : std::is_constructible<T, Args...> {};
@@ -3803,7 +3815,7 @@ struct is_constructible_array_type_impl <
     BasicJsonType, ConstructibleArrayType,
     enable_if_t<std::is_same<ConstructibleArrayType,
     typename BasicJsonType::value_type>::value >>
-            : std::true_type {};
+        : std::true_type {};
 
 template<typename BasicJsonType, typename ConstructibleArrayType>
 struct is_constructible_array_type_impl <
@@ -3820,8 +3832,8 @@ is_detected<range_value_t, ConstructibleArrayType>::value&&
 // special case for types like std::filesystem::path whose iterator's value_type are themselves
 // c.f. https://github.com/nlohmann/json/pull/3073
 !std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
-        is_complete_type <
+    is_complete_type <
-        detected_t<range_value_t, ConstructibleArrayType >>::value >>
+    detected_t<range_value_t, ConstructibleArrayType >>::value >>
 {
     using value_type = range_value_t<ConstructibleArrayType>;
 
@@ -3944,12 +3956,12 @@ using is_usable_as_key_type = typename std::conditional <
 template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
          bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
 using is_usable_as_basic_json_key_type = typename std::conditional <
-        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
+    is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
-        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
+    typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
-        RequireTransparentComparator, ExcludeObjectKeyType>::value
+    RequireTransparentComparator, ExcludeObjectKeyType>::value
-        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
+    && !is_json_iterator_of<BasicJsonType, KeyType>::value,
-        std::true_type,
+    std::true_type,
-        std::false_type >::type;
+    std::false_type >::type;
 
 template<typename ObjectType, typename KeyType>
 using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
@@ -4153,7 +4165,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstring> // strlen
 #include <string> // string
 #include <utility> // forward
@@ -4539,7 +4550,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 // #include <nlohmann/detail/abi_macros.hpp>
 
 
@@ -4563,7 +4573,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 // #include <nlohmann/detail/macro_scope.hpp>
 
 
@@ -4826,7 +4835,7 @@ template < typename BasicJsonType, typename ConstructibleArrayType,
 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
 j.template get<typename ConstructibleArrayType::value_type>(),
-void())
+ void())
 {
     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
     {
@@ -4838,7 +4847,7 @@ void())
 
 template < typename BasicJsonType, typename T, std::size_t... Idx >
 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
-        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+                    identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
 {
     return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
 }
@@ -5069,7 +5078,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <algorithm> // copy
 #include <iterator> // begin, end
 #include <string> // string
@@ -5089,7 +5097,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstddef> // size_t
 #include <iterator> // input_iterator_tag
 #include <string> // string, to_string
@@ -5305,7 +5312,7 @@ namespace std
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
-            : public std::integral_constant<std::size_t, 2> {};
+        : public std::integral_constant<std::size_t, 2> {};
 
 template<std::size_t N, typename IteratorType>
 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
@@ -5810,7 +5817,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstdint> // uint8_t, uint64_t
 #include <tuple> // tie
 #include <utility> // move
@@ -5922,7 +5928,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstdint> // uint8_t
 #include <cstddef> // size_t
 #include <functional> // hash
@@ -6055,7 +6060,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <algorithm> // generate_n
 #include <array> // array
 #include <cmath> // ldexp
@@ -6081,7 +6085,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <array> // array
 #include <cstddef> // size_t
 #include <cstring> // strlen
@@ -6576,7 +6579,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstddef>
 #include <string> // string
 #include <utility> // move
@@ -7308,7 +7310,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <array> // array
 #include <clocale> // localeconv
 #include <cstddef> // size_t
@@ -8947,7 +8948,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstdint> // size_t
 #include <utility> // declval
 #include <string> // string
@@ -9602,7 +9602,7 @@ class binary_reader
             {
                 std::uint64_t number{};
                 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
-                        - static_cast<number_integer_t>(number));
+                       - static_cast<number_integer_t>(number));
             }
 
             // Binary data (0x00..0x17 bytes follow)
@@ -12099,7 +12099,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cmath> // isfinite
 #include <cstdint> // uint8_t
 #include <functional> // function
@@ -12628,7 +12627,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 // #include <nlohmann/detail/abi_macros.hpp>
 
 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
@@ -12641,7 +12639,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstddef> // ptrdiff_t
 #include <limits>  // numeric_limits
 
@@ -12800,7 +12797,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
 #include <type_traits> // conditional, is_const, remove_const
 
@@ -13562,7 +13558,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <cstddef> // ptrdiff_t
 #include <iterator> // reverse_iterator
 #include <utility> // declval
@@ -13731,7 +13726,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <algorithm> // all_of
 #include <cctype> // isdigit
 #include <cerrno> // errno, ERANGE
@@ -14726,7 +14720,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <initializer_list>
 #include <utility>
 
@@ -14818,7 +14811,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <algorithm> // reverse
 #include <array> // array
 #include <map> // map
@@ -14844,7 +14836,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <algorithm> // copy
 #include <cstddef> // size_t
 #include <iterator> // back_inserter
@@ -16125,7 +16116,7 @@ class binary_writer
     @return The calculated size for the BSON document entry for @a j with the given @a name.
     */
     static std::size_t calc_bson_element_size(const string_t& name,
-            const BasicJsonType& j)
+        const BasicJsonType& j)
     {
         const auto header_size = calc_bson_entry_header_size(name, j);
         switch (j.type())
@@ -16813,7 +16804,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <algorithm> // reverse, remove, fill, find, none_of
 #include <array> // array
 #include <clocale> // localeconv, lconv
@@ -16838,7 +16828,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <array> // array
 #include <cmath>   // signbit, isfinite
 #include <cstdint> // intN_t, uintN_t
@@ -18933,7 +18922,6 @@ NLOHMANN_JSON_NAMESPACE_END
 // SPDX-License-Identifier: MIT
 
 
-
 #include <functional> // equal_to, less
 #include <initializer_list> // initializer_list
 #include <iterator> // input_iterator_tag, iterator_traits
@@ -18954,7 +18942,7 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
 /// for use within nlohmann::basic_json<ordered_map>
 template <class Key, class T, class IgnoredLess = std::less<Key>,
           class Allocator = std::allocator<std::pair<const Key, T>>>
-                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+              struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
 {
     using key_type = Key;
     using mapped_type = T;
@@ -19269,7 +19257,7 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
 
     template<typename InputIt>
     using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
-            std::input_iterator_tag>::value>::type;
+        std::input_iterator_tag>::value>::type;
 
     template<typename InputIt, typename = require_input_iter<InputIt>>
     void insert(InputIt first, InputIt last)
@@ -19363,7 +19351,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                                  )
     {
         return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
-                std::move(cb), allow_exceptions, ignore_comments);
+            std::move(cb), allow_exceptions, ignore_comments);
     }
 
   private:
@@ -20059,8 +20047,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                detail::enable_if_t <
                    !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
     basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
-                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+            JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
-                                           std::forward<CompatibleType>(val))))
+                                       std::forward<CompatibleType>(val))))
     {
         JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
         set_parents();
@@ -20166,8 +20154,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             {
                 auto element = element_ref.moved_or_copied();
                 m_data.m_value.object->emplace(
-                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
+                          std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
-                    std::move((*element.m_data.m_value.array)[1]));
+                          std::move((*element.m_data.m_value.array)[1]));
             }
         }
         else
@@ -20830,7 +20818,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    detail::has_from_json<basic_json_t, ValueType>::value,
                    int > = 0 >
     ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
-                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
     {
         auto ret = ValueType();
         JSONSerializer<ValueType>::from_json(*this, ret);
@@ -20872,7 +20860,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    detail::has_non_default_from_json<basic_json_t, ValueType>::value,
                    int > = 0 >
     ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
-                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
     {
         return JSONSerializer<ValueType>::from_json(*this);
     }
@@ -21022,7 +21010,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    detail::has_from_json<basic_json_t, ValueType>::value,
                    int > = 0 >
     ValueType & get_to(ValueType& v) const noexcept(noexcept(
-                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
     {
         JSONSerializer<ValueType>::from_json(*this, v);
         return v;
@@ -21112,13 +21100,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                                         detail::negation<detail::is_basic_json<ValueType>>,
                                         detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
 #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>>,
+                                            detail::negation<std::is_same<ValueType, std::string_view>>,
 #endif
 #if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
-                                                detail::negation<std::is_same<ValueType, std::any>>,
+                                            detail::negation<std::is_same<ValueType, std::any>>,
 #endif
-                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                            detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
-                                                >::value, int >::type = 0 >
+                                            >::value, int >::type = 0 >
                                         JSON_EXPLICIT operator ValueType() const
     {
         // delegate the call to get<>() const
@@ -23507,8 +23495,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief create a UBJSON serialization of a given JSON value
     /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
     static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
-            const bool use_size = false,
+        const bool use_size = false,
-            const bool use_type = false)
+        const bool use_type = false)
     {
         std::vector<std::uint8_t> result;
         to_ubjson(j, result, use_size, use_type);
@@ -23534,8 +23522,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief create a BJData serialization of a given JSON value
     /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
     static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
-            const bool use_size = false,
+        const bool use_size = false,
-            const bool use_type = false)
+        const bool use_type = false)
     {
         std::vector<std::uint8_t> result;
         to_bjdata(j, result, use_size, use_type);
@@ -24489,7 +24477,6 @@ inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC
 // SPDX-License-Identifier: MIT
 
 
-
 // restore clang diagnostic settings
 #if defined(__clang__)
     #pragma clang diagnostic pop
@@ -24534,7 +24521,6 @@ inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC
 // SPDX-License-Identifier: MIT
 
 
-
 #undef JSON_HEDLEY_ALWAYS_INLINE
 #undef JSON_HEDLEY_ARM_VERSION
 #undef JSON_HEDLEY_ARM_VERSION_CHECK
@@ -24685,5 +24671,4 @@ inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC
 #undef JSON_HEDLEY_FALL_THROUGH
 
 
-
 #endif  // INCLUDE_NLOHMANN_JSON_HPP_

single_include/nlohmann/json_fwd.hpp

@@ -25,7 +25,6 @@
 // SPDX-License-Identifier: MIT
 
 
-
 // This file contains all macro definitions affecting or depending on the ABI
 
 #ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
@@ -71,8 +70,8 @@
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
-            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+        NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
-            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+        NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -97,8 +96,8 @@
 #ifndef NLOHMANN_JSON_NAMESPACE
 #define NLOHMANN_JSON_NAMESPACE               \
     nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
-            NLOHMANN_JSON_ABI_TAGS,           \
+        NLOHMANN_JSON_ABI_TAGS,           \
-            NLOHMANN_JSON_NAMESPACE_VERSION)
+        NLOHMANN_JSON_NAMESPACE_VERSION)
 #endif
 
 #ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -106,8 +105,8 @@
     namespace nlohmann                               \
     {                                                \
     inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
-                NLOHMANN_JSON_ABI_TAGS,              \
+            NLOHMANN_JSON_ABI_TAGS,              \
-                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+            NLOHMANN_JSON_NAMESPACE_VERSION)     \
     {
 #endif
 

tests/src/unit-bjdata.cpp

@@ -339,13 +339,13 @@ TEST_CASE("BJData")
                     std::vector<int32_t> const numbers
                     {
                         -32769,
-                            -100000,
+                        -100000,
-                            -1000000,
+                        -1000000,
-                            -10000000,
+                        -10000000,
-                            -100000000,
+                        -100000000,
-                            -1000000000,
+                        -1000000000,
-                            -2147483647 - 1, // https://stackoverflow.com/a/29356002/266378
+                        -2147483647 - 1, // https://stackoverflow.com/a/29356002/266378
-                        };
+                    };
                     for (const auto i : numbers)
                     {
                         CAPTURE(i)

tests/src/unit-cbor.cpp

@@ -241,13 +241,13 @@ TEST_CASE("CBOR")
                     const std::vector<int64_t> numbers
                     {
                         -65537,
-                            -100000,
+                        -100000,
-                            -1000000,
+                        -1000000,
-                            -10000000,
+                        -10000000,
-                            -100000000,
+                        -100000000,
-                            -1000000000,
+                        -1000000000,
-                            -4294967296,
+                        -4294967296,
-                        };
+                    };
                     for (const auto i : numbers)
                     {
                         CAPTURE(i)

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

@@ -303,8 +303,8 @@ TEST_CASE("JSON Visit Node")
     };
 
     json.visit(
-        [&](const json_with_visitor_t::json_pointer & p,
+            [&](const json_with_visitor_t::json_pointer & p,
-            const json_with_visitor_t& j)
+                const json_with_visitor_t& j)
     {
         std::stringstream str;
         str << p.to_string() << " - " ;
@@ -351,6 +351,6 @@ TEST_CASE("JSON Visit Node")
         CHECK(expected.count(str.str()) == 1);
         expected.erase(str.str());
     }
-    );
+        );
     CHECK(expected.empty());
 }

tests/src/unit-msgpack.cpp

@@ -479,11 +479,11 @@ TEST_CASE("MessagePack")
                     std::vector<int32_t> const numbers
                     {
                         -32769,
-                            -65536,
+                        -65536,
-                            -77777,
+                        -77777,
-                            -1048576,
+                        -1048576,
-                            -2147483648LL,
+                        -2147483648LL,
-                        };
+                    };
                     for (auto i : numbers)
                     {
                         CAPTURE(i)

tests/src/unit-regression1.cpp

@@ -1328,10 +1328,10 @@ TEST_CASE("regression tests 1")
         {
             std::ifstream is;
             is.exceptions(
-                is.exceptions()
+                  is.exceptions()
-                | std::ios_base::failbit
+                  | std::ios_base::failbit
-                | std::ios_base::badbit
+                  | std::ios_base::badbit
-            ); // handle different exceptions as 'file not found', 'permission denied'
+              ); // handle different exceptions as 'file not found', 'permission denied'
 
             is.open(TEST_DATA_DIRECTORY "/regression/working_file.json");
             json _;
@@ -1341,10 +1341,10 @@ TEST_CASE("regression tests 1")
         {
             std::ifstream is;
             is.exceptions(
-                is.exceptions()
+                  is.exceptions()
-                | std::ios_base::failbit
+                  | std::ios_base::failbit
-                | std::ios_base::badbit
+                  | std::ios_base::badbit
-            ); // handle different exceptions as 'file not found', 'permission denied'
+              ); // handle different exceptions as 'file not found', 'permission denied'
 
             is.open(TEST_DATA_DIRECTORY "/json_nlohmann_tests/all_unicode.json.cbor",
                     std::ios_base::in | std::ios_base::binary);

tests/src/unit-udt_macro.cpp

@@ -38,6 +38,26 @@ class person_with_private_data
     NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_with_private_data, age, name, metadata)
 };
 
+class derived_person_with_private_data : public person_with_private_data
+{
+  private:
+    std::string hair_color{"blue"};
+
+  public:
+    bool operator==(const derived_person_with_private_data& rhs) const
+    {
+        return person_with_private_data::operator==(rhs) && hair_color == rhs.hair_color;
+    }
+
+    derived_person_with_private_data() = default;
+    derived_person_with_private_data(std::string name_, int age_, json metadata_, std::string hair_color_)
+        : person_with_private_data(std::move(name_), age_, std::move(metadata_))
+        , hair_color(std::move(hair_color_))
+    {}
+
+    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(derived_person_with_private_data, person_with_private_data, hair_color)
+};
+
 class person_with_private_data_2
 {
   private:
@@ -74,6 +94,31 @@ class person_with_private_data_2
     NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(person_with_private_data_2, age, name, metadata)
 };
 
+class derived_person_with_private_data_2 : public person_with_private_data_2
+{
+  private:
+    std::string hair_color{"blue"};
+
+  public:
+    bool operator==(const derived_person_with_private_data_2& rhs) const
+    {
+        return person_with_private_data_2::operator==(rhs) && hair_color == rhs.hair_color;
+    }
+
+    derived_person_with_private_data_2() = default;
+    derived_person_with_private_data_2(std::string name_, int age_, json metadata_, std::string hair_color_)
+        : person_with_private_data_2(std::move(name_), age_, std::move(metadata_))
+        , hair_color(std::move(hair_color_))
+    {}
+
+    std::string getHairColor() const
+    {
+        return hair_color;
+    }
+
+    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(derived_person_with_private_data_2, person_with_private_data_2, hair_color)
+};
+
 class person_without_private_data_1
 {
   public:
@@ -96,6 +141,26 @@ class person_without_private_data_1
     NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_without_private_data_1, age, name, metadata)
 };
 
+class derived_person_without_private_data_1 : public person_without_private_data_1
+{
+  public:
+    std::string hair_color{"blue"};
+
+  public:
+    bool operator==(const derived_person_without_private_data_1& rhs) const
+    {
+        return person_without_private_data_1::operator==(rhs) && hair_color == rhs.hair_color;
+    }
+
+    derived_person_without_private_data_1() = default;
+    derived_person_without_private_data_1(std::string name_, int age_, json metadata_, std::string hair_color_)
+        : person_without_private_data_1(std::move(name_), age_, std::move(metadata_))
+        , hair_color(std::move(hair_color_))
+    {}
+
+    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(derived_person_without_private_data_1, person_without_private_data_1, hair_color)
+};
+
 class person_without_private_data_2
 {
   public:
@@ -118,6 +183,26 @@ class person_without_private_data_2
 
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person_without_private_data_2, age, name, metadata)
 
+class derived_person_without_private_data_2 : public person_without_private_data_2
+{
+  public:
+    std::string hair_color{"blue"};
+
+  public:
+    bool operator==(const derived_person_without_private_data_2& rhs) const
+    {
+        return person_without_private_data_2::operator==(rhs) && hair_color == rhs.hair_color;
+    }
+
+    derived_person_without_private_data_2() = default;
+    derived_person_without_private_data_2(std::string name_, int age_, json metadata_, std::string hair_color_)
+        : person_without_private_data_2(std::move(name_), age_, std::move(metadata_))
+        , hair_color(std::move(hair_color_))
+    {}
+};
+
+NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(derived_person_without_private_data_2, person_without_private_data_2, hair_color)
+
 class person_without_private_data_3
 {
   public:
@@ -153,6 +238,31 @@ class person_without_private_data_3
 
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(person_without_private_data_3, age, name, metadata)
 
+class derived_person_without_private_data_3 : public person_without_private_data_3
+{
+  public:
+    std::string hair_color{"blue"};
+
+  public:
+    bool operator==(const derived_person_without_private_data_3& rhs) const
+    {
+        return person_without_private_data_3::operator==(rhs) && hair_color == rhs.hair_color;
+    }
+
+    derived_person_without_private_data_3() = default;
+    derived_person_without_private_data_3(std::string name_, int age_, json metadata_, std::string hair_color_)
+        : person_without_private_data_3(std::move(name_), age_, std::move(metadata_))
+        , hair_color(std::move(hair_color_))
+    {}
+
+    std::string getHairColor() const
+    {
+        return hair_color;
+    }
+};
+
+NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(derived_person_without_private_data_3, person_without_private_data_3, hair_color)
+
 class person_with_private_alphabet
 {
   public:
@@ -216,6 +326,19 @@ class person_with_private_alphabet
     NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_with_private_alphabet, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
 };
 
+class derived_person_with_private_alphabet : public person_with_private_alphabet
+{
+  public:
+    bool operator==(const derived_person_with_private_alphabet& other) const
+    {
+        return person_with_private_alphabet::operator==(other) && schwa == other.schwa;
+    }
+
+  private:
+    int schwa = 0;
+    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(derived_person_with_private_alphabet, person_with_private_alphabet, schwa)
+};
+
 class person_with_public_alphabet
 {
   public:
@@ -279,6 +402,18 @@ class person_with_public_alphabet
 
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person_with_public_alphabet, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
 
+class derived_person_with_public_alphabet : public person_with_public_alphabet
+{
+  public:
+    bool operator==(const derived_person_with_public_alphabet& other) const
+    {
+        return person_with_public_alphabet::operator==(other) && schwa == other.schwa;
+    }
+    int schwa = 0;
+};
+
+NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(derived_person_with_public_alphabet, person_with_public_alphabet, schwa)
+
 } // namespace persons
 
 TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE", T,
@@ -307,6 +442,32 @@ TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_TYPE_INTRU
     }
 }
 
+TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE and NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE", T,
+                   persons::derived_person_with_private_data,
+                   persons::derived_person_without_private_data_1,
+                   persons::derived_person_without_private_data_2)
+{
+    SECTION("person")
+    {
+        // serialization
+        T p1("Erik", 1, {{"haircuts", 2}}, "red");
+        CHECK(json(p1).dump() == "{\"age\":1,\"hair_color\":\"red\",\"metadata\":{\"haircuts\":2},\"name\":\"Erik\"}");
+
+        // deserialization
+        auto p2 = json(p1).get<T>();
+        CHECK(p2 == p1);
+
+        // roundtrip
+        CHECK(T(json(p1)) == p1);
+        CHECK(json(T(json(p1))) == json(p1));
+
+        // check exception in case of missing field
+        json j = json(p1);
+        j.erase("age");
+        CHECK_THROWS_WITH_AS(j.get<T>(), "[json.exception.out_of_range.403] key 'age' not found", json::out_of_range);
+    }
+}
+
 TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT", T,
                    persons::person_with_private_data_2,
                    persons::person_without_private_data_3)
@@ -341,6 +502,42 @@ TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_TYPE_INTRU
     }
 }
 
+TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT and NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT", T,
+                   persons::derived_person_with_private_data_2,
+                   persons::derived_person_without_private_data_3)
+{
+    SECTION("derived person with default values")
+    {
+        // serialization of default constructed object
+        T p0;
+        CHECK(json(p0).dump() == "{\"age\":0,\"hair_color\":\"blue\",\"metadata\":null,\"name\":\"\"}");
+
+        // serialization
+        T p1("Erik", 1, {{"haircuts", 2}}, "red");
+        CHECK(json(p1).dump() == "{\"age\":1,\"hair_color\":\"red\",\"metadata\":{\"haircuts\":2},\"name\":\"Erik\"}");
+
+        // deserialization
+        auto p2 = json(p1).get<T>();
+        CHECK(p2 == p1);
+
+        // roundtrip
+        CHECK(T(json(p1)) == p1);
+        CHECK(json(T(json(p1))) == json(p1));
+
+        // check default value in case of missing field
+        json j = json(p1);
+        j.erase("name");
+        j.erase("age");
+        j.erase("metadata");
+        j.erase("hair_color");
+        T p3 = j.get<T>();
+        CHECK(p3.getName() == "");
+        CHECK(p3.getAge() == 0);
+        CHECK(p3.getMetadata() == nullptr);
+        CHECK(p3.getHairColor() == "blue");
+    }
+}
+
 TEST_CASE_TEMPLATE("Serialization/deserialization of classes with 26 public/private member variables via NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE", T,
                    persons::person_with_private_alphabet,
                    persons::person_with_public_alphabet)
@@ -412,3 +609,75 @@ TEST_CASE_TEMPLATE("Serialization/deserialization of classes with 26 public/priv
         }
     }
 }
+
+TEST_CASE_TEMPLATE("Serialization/deserialization of classes with 27 public/private member variables via NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE and NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE", T,
+                   persons::derived_person_with_private_alphabet,
+                   persons::derived_person_with_public_alphabet)
+{
+    SECTION("alphabet")
+    {
+        {
+            T obj1;
+            nlohmann::json const j = obj1; //via json object
+            T obj2;
+            j.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json const j1 = obj1; //via json string
+            std::string const s = j1.dump();
+            nlohmann::json const j2 = nlohmann::json::parse(s);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json const j1 = obj1; //via msgpack
+            std::vector<uint8_t> const buf = nlohmann::json::to_msgpack(j1);
+            nlohmann::json const j2 = nlohmann::json::from_msgpack(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json const j1 = obj1; //via bson
+            std::vector<uint8_t> const buf = nlohmann::json::to_bson(j1);
+            nlohmann::json const j2 = nlohmann::json::from_bson(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json const j1 = obj1; //via cbor
+            std::vector<uint8_t> const buf = nlohmann::json::to_cbor(j1);
+            nlohmann::json const j2 = nlohmann::json::from_cbor(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json const j1 = obj1; //via ubjson
+            std::vector<uint8_t> const buf = nlohmann::json::to_ubjson(j1);
+            nlohmann::json const j2 = nlohmann::json::from_ubjson(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+    }
+}