Make serializer's indent_string lazily allocated

The serializer constructor unconditionally allocated a 512-byte
indent_string, even though it is only ever read inside the
pretty_print branches of dump(). This wasted a heap allocation (and
its matching deallocation) on every compact (i.e. default, non-pretty)
dump() call.

indent_string is now default-constructed empty and lazily grown to
512 bytes, filled with indent_char, the first time a pretty-print
branch actually needs it. The existing doubling/growth logic for
larger indents is otherwise untouched, so output remains byte-identical
to before -- including in the pre-existing edge case where growth
beyond the initial buffer fills with ' ' instead of indent_char
(tracked separately by open PR #5186, which is left alone here).

The second, larger optimization mentioned in #5413 (removing the
shared_ptr-based output adapter) is intentionally out of scope, as it
overlaps open PR #5285.

Fixes #5413

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

Makefile

@@ -241,7 +241,7 @@ update_hedley:
 	rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
-	grep -oE "#[[:blank:]]*define[[:blank:]]+JSON_HEDLEY_[A-Za-z0-9_]+" include/nlohmann/thirdparty/hedley/hedley.hpp | awk '{print $$NF}' | grep -v "__" | sort -u | $(SED) 's/^/#undef /' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
+	grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | $(SED) 's/ //g' | $(SED) 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(MAKE) amalgamate

include/nlohmann/detail/conversions/to_chars.hpp

@@ -1074,9 +1074,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '-';
     }
 
-    JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
     if (value == 0) // +-0
     {
@@ -1086,7 +1086,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '0';
         return first;
     }
-    JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 
     JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
 

include/nlohmann/detail/exceptions.hpp

@@ -32,9 +32,9 @@
 // functions to. As a result, we suppress this warning here to avoid client
 // code stumbling over this. See https://github.com/nlohmann/json/issues/4087
 // for a discussion.
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -286,4 +286,6 @@ class other_error : public exception
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif

include/nlohmann/detail/iterators/iteration_proxy.hpp

@@ -18,7 +18,6 @@
 #endif
 
 #include <nlohmann/detail/abi_macros.hpp>
-#include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>
@@ -207,10 +206,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {
 
-// Fix: https://github.com/nlohmann/json/issues/1401
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
@@ -224,7 +223,9 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                      get<N>(std::declval <
                             ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
 
 }  // namespace std
 

include/nlohmann/detail/output/binary_writer.hpp

@@ -1849,9 +1849,9 @@ class binary_writer
 
     void write_compact_float(const number_float_t n, detail::input_format_t format)
     {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                                    static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
@@ -1869,7 +1869,9 @@ class binary_writer
                                 : get_msgpack_float_prefix(n));
             write_number(n);
         }
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
   public:

include/nlohmann/detail/output/serializer.hpp

@@ -71,7 +71,7 @@ class serializer
         , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
         , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
         , indent_char(ichar)
-        , indent_string(512, indent_char)
+        , indent_string()
         , error_handler(error_handler_)
     {}
 
@@ -126,6 +126,10 @@ class serializer
 
                     // variable to hold indentation for recursive calls
                     const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
+                    {
+                        indent_string.resize(512, indent_char);
+                    }
                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                     {
                         indent_string.resize(indent_string.size() * 2, ' ');
@@ -199,6 +203,10 @@ class serializer
 
                     // variable to hold indentation for recursive calls
                     const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
+                    {
+                        indent_string.resize(512, indent_char);
+                    }
                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                     {
                         indent_string.resize(indent_string.size() * 2, ' ');
@@ -260,6 +268,10 @@ class serializer
 
                     // variable to hold indentation for recursive calls
                     const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
+                    {
+                        indent_string.resize(512, indent_char);
+                    }
                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                     {
                         indent_string.resize(indent_string.size() * 2, ' ');
@@ -1010,7 +1022,7 @@ class serializer
 
     /// the indentation character
     const char indent_char;
-    /// the indentation string
+    /// the indentation string (lazily allocated on first use by a pretty-print branch)
     string_t indent_string;
 
     /// error_handler how to react on decoding errors

include/nlohmann/json.hpp

@@ -3769,13 +3769,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     bool operator==(const_reference rhs) const noexcept
     {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         const_reference lhs = *this;
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal
@@ -3860,12 +3862,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     friend bool operator==(const_reference lhs, const_reference rhs) noexcept
     {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal

include/nlohmann/thirdparty/hedley/hedley_undef.hpp

@@ -17,7 +17,7 @@
 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -108,10 +108,7 @@
 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 #undef JSON_HEDLEY_PGI_VERSION
 #undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PRAGMA
 #undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PREDICT_FALSE
-#undef JSON_HEDLEY_PREDICT_TRUE
 #undef JSON_HEDLEY_PRINTF_FORMAT
 #undef JSON_HEDLEY_PRIVATE
 #undef JSON_HEDLEY_PUBLIC

single_include/nlohmann/json.hpp

@@ -4944,9 +4944,9 @@ NLOHMANN_JSON_NAMESPACE_END
 // functions to. As a result, we suppress this warning here to avoid client
 // code stumbling over this. See https://github.com/nlohmann/json/issues/4087
 // for a discussion.
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -5198,7 +5198,9 @@ class other_error : public exception
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
 
 // #include <nlohmann/detail/macro_scope.hpp>
 
@@ -5973,8 +5975,6 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/abi_macros.hpp>
 
-// #include <nlohmann/detail/macro_scope.hpp>
-
 // #include <nlohmann/detail/meta/type_traits.hpp>
 
 // #include <nlohmann/detail/string_utils.hpp>
@@ -6204,10 +6204,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {
 
-// Fix: https://github.com/nlohmann/json/issues/1401
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
@@ -6221,7 +6221,9 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                      get<N>(std::declval <
                             ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
 
 }  // namespace std
 
@@ -18855,9 +18857,9 @@ class binary_writer
 
     void write_compact_float(const number_float_t n, detail::input_format_t format)
     {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                                    static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
@@ -18875,7 +18877,9 @@ class binary_writer
                                 : get_msgpack_float_prefix(n));
             write_number(n);
         }
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
   public:
@@ -20048,9 +20052,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '-';
     }
 
-    JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
     if (value == 0) // +-0
     {
@@ -20060,7 +20064,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '0';
         return first;
     }
-    JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 
     JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
 
@@ -20144,7 +20150,7 @@ class serializer
         , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
         , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
         , indent_char(ichar)
-        , indent_string(512, indent_char)
+        , indent_string()
         , error_handler(error_handler_)
     {}
 
@@ -20199,6 +20205,10 @@ class serializer
 
                     // variable to hold indentation for recursive calls
                     const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
+                    {
+                        indent_string.resize(512, indent_char);
+                    }
                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                     {
                         indent_string.resize(indent_string.size() * 2, ' ');
@@ -20272,6 +20282,10 @@ class serializer
 
                     // variable to hold indentation for recursive calls
                     const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
+                    {
+                        indent_string.resize(512, indent_char);
+                    }
                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                     {
                         indent_string.resize(indent_string.size() * 2, ' ');
@@ -20333,6 +20347,10 @@ class serializer
 
                     // variable to hold indentation for recursive calls
                     const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.empty()))
+                    {
+                        indent_string.resize(512, indent_char);
+                    }
                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                     {
                         indent_string.resize(indent_string.size() * 2, ' ');
@@ -21083,7 +21101,7 @@ class serializer
 
     /// the indentation character
     const char indent_char;
-    /// the indentation string
+    /// the indentation string (lazily allocated on first use by a pretty-print branch)
     string_t indent_string;
 
     /// error_handler how to react on decoding errors
@@ -25191,13 +25209,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     bool operator==(const_reference rhs) const noexcept
     {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         const_reference lhs = *this;
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal
@@ -25282,12 +25302,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     friend bool operator==(const_reference lhs, const_reference rhs) noexcept
     {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal
@@ -26955,7 +26977,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -27046,10 +27068,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 #undef JSON_HEDLEY_PGI_VERSION
 #undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PRAGMA
 #undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PREDICT_FALSE
-#undef JSON_HEDLEY_PREDICT_TRUE
 #undef JSON_HEDLEY_PRINTF_FORMAT
 #undef JSON_HEDLEY_PRIVATE
 #undef JSON_HEDLEY_PUBLIC

tests/src/unit-no-macro-leak.cpp

@@ -1,486 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file makes sure that none of the internal JSON_HEDLEY_* macros (vendored
-// from https://nemequ.github.io/hedley/, see
-// include/nlohmann/thirdparty/hedley/hedley.hpp) leak into the including
-// translation unit. include/nlohmann/detail/macro_unscope.hpp is supposed to
-// #undef every JSON_HEDLEY_* macro (via hedley_undef.hpp) once json.hpp has
-// been fully processed. See https://github.com/nlohmann/json/issues/5408,
-// where JSON_HEDLEY_PRAGMA, JSON_HEDLEY_PREDICT_TRUE, JSON_HEDLEY_PREDICT_FALSE,
-// and JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE escaped this cleanup because
-// hedley_undef.hpp had no matching #undef for them.
-//
-// The #ifdef/#error checks below are mechanically derived from the full list
-// of macro names in hedley_undef.hpp, so every JSON_HEDLEY_* macro is covered
-// -- not just the four that leaked historically.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#ifdef JSON_HEDLEY_ALWAYS_INLINE
-    #error "JSON_HEDLEY_ALWAYS_INLINE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ARM_VERSION
-    #error "JSON_HEDLEY_ARM_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ARM_VERSION_CHECK
-    #error "JSON_HEDLEY_ARM_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ARRAY_PARAM
-    #error "JSON_HEDLEY_ARRAY_PARAM must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_ASSUME
-    #error "JSON_HEDLEY_ASSUME must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_BEGIN_C_DECLS
-    #error "JSON_HEDLEY_BEGIN_C_DECLS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_CLANG_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_BUILTIN
-    #error "JSON_HEDLEY_CLANG_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_EXTENSION
-    #error "JSON_HEDLEY_CLANG_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_FEATURE
-    #error "JSON_HEDLEY_CLANG_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CLANG_HAS_WARNING
-    #error "JSON_HEDLEY_CLANG_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_COMPCERT_VERSION
-    #error "JSON_HEDLEY_COMPCERT_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-    #error "JSON_HEDLEY_COMPCERT_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT
-    #error "JSON_HEDLEY_CONCAT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT3
-    #error "JSON_HEDLEY_CONCAT3 must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT3_EX
-    #error "JSON_HEDLEY_CONCAT3_EX must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONCAT_EX
-    #error "JSON_HEDLEY_CONCAT_EX must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONST
-    #error "JSON_HEDLEY_CONST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONSTEXPR
-    #error "JSON_HEDLEY_CONSTEXPR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CONST_CAST
-    #error "JSON_HEDLEY_CONST_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CPP_CAST
-    #error "JSON_HEDLEY_CPP_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CRAY_VERSION
-    #error "JSON_HEDLEY_CRAY_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_CRAY_VERSION_CHECK
-    #error "JSON_HEDLEY_CRAY_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_C_DECL
-    #error "JSON_HEDLEY_C_DECL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DEPRECATED
-    #error "JSON_HEDLEY_DEPRECATED must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DEPRECATED_FOR
-    #error "JSON_HEDLEY_DEPRECATED_FOR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
-    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_POP
-    #error "JSON_HEDLEY_DIAGNOSTIC_POP must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DIAGNOSTIC_PUSH
-    #error "JSON_HEDLEY_DIAGNOSTIC_PUSH must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DMC_VERSION
-    #error "JSON_HEDLEY_DMC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_DMC_VERSION_CHECK
-    #error "JSON_HEDLEY_DMC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_EMPTY_BASES
-    #error "JSON_HEDLEY_EMPTY_BASES must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION
-    #error "JSON_HEDLEY_EMSCRIPTEN_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-    #error "JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_END_C_DECLS
-    #error "JSON_HEDLEY_END_C_DECLS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_FALL_THROUGH
-    #error "JSON_HEDLEY_FALL_THROUGH must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_FLAGS
-    #error "JSON_HEDLEY_FLAGS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_FLAGS_CAST
-    #error "JSON_HEDLEY_FLAGS_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_GCC_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_BUILTIN
-    #error "JSON_HEDLEY_GCC_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_EXTENSION
-    #error "JSON_HEDLEY_GCC_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_FEATURE
-    #error "JSON_HEDLEY_GCC_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_HAS_WARNING
-    #error "JSON_HEDLEY_GCC_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-    #error "JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_VERSION
-    #error "JSON_HEDLEY_GCC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GCC_VERSION_CHECK
-    #error "JSON_HEDLEY_GCC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_GNUC_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_BUILTIN
-    #error "JSON_HEDLEY_GNUC_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_EXTENSION
-    #error "JSON_HEDLEY_GNUC_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_FEATURE
-    #error "JSON_HEDLEY_GNUC_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_HAS_WARNING
-    #error "JSON_HEDLEY_GNUC_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_VERSION
-    #error "JSON_HEDLEY_GNUC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_GNUC_VERSION_CHECK
-    #error "JSON_HEDLEY_GNUC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_ATTRIBUTE
-    #error "JSON_HEDLEY_HAS_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_BUILTIN
-    #error "JSON_HEDLEY_HAS_BUILTIN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-    #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-    #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-    #error "JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_EXTENSION
-    #error "JSON_HEDLEY_HAS_EXTENSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_FEATURE
-    #error "JSON_HEDLEY_HAS_FEATURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_HAS_WARNING
-    #error "JSON_HEDLEY_HAS_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IAR_VERSION
-    #error "JSON_HEDLEY_IAR_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IAR_VERSION_CHECK
-    #error "JSON_HEDLEY_IAR_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IBM_VERSION
-    #error "JSON_HEDLEY_IBM_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IBM_VERSION_CHECK
-    #error "JSON_HEDLEY_IBM_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IMPORT
-    #error "JSON_HEDLEY_IMPORT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INLINE
-    #error "JSON_HEDLEY_INLINE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_CL_VERSION
-    #error "JSON_HEDLEY_INTEL_CL_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
-    #error "JSON_HEDLEY_INTEL_CL_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_VERSION
-    #error "JSON_HEDLEY_INTEL_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_INTEL_VERSION_CHECK
-    #error "JSON_HEDLEY_INTEL_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IS_CONSTANT
-    #error "JSON_HEDLEY_IS_CONSTANT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_IS_CONSTEXPR_
-    #error "JSON_HEDLEY_IS_CONSTEXPR_ must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_LIKELY
-    #error "JSON_HEDLEY_LIKELY must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MALLOC
-    #error "JSON_HEDLEY_MALLOC must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MCST_LCC_VERSION
-    #error "JSON_HEDLEY_MCST_LCC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
-    #error "JSON_HEDLEY_MCST_LCC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MESSAGE
-    #error "JSON_HEDLEY_MESSAGE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MSVC_VERSION
-    #error "JSON_HEDLEY_MSVC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_MSVC_VERSION_CHECK
-    #error "JSON_HEDLEY_MSVC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NEVER_INLINE
-    #error "JSON_HEDLEY_NEVER_INLINE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NON_NULL
-    #error "JSON_HEDLEY_NON_NULL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NO_ESCAPE
-    #error "JSON_HEDLEY_NO_ESCAPE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NO_RETURN
-    #error "JSON_HEDLEY_NO_RETURN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NO_THROW
-    #error "JSON_HEDLEY_NO_THROW must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_NULL
-    #error "JSON_HEDLEY_NULL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PELLES_VERSION
-    #error "JSON_HEDLEY_PELLES_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PELLES_VERSION_CHECK
-    #error "JSON_HEDLEY_PELLES_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PGI_VERSION
-    #error "JSON_HEDLEY_PGI_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PGI_VERSION_CHECK
-    #error "JSON_HEDLEY_PGI_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PRAGMA
-    #error "JSON_HEDLEY_PRAGMA must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PREDICT
-    #error "JSON_HEDLEY_PREDICT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PREDICT_FALSE
-    #error "JSON_HEDLEY_PREDICT_FALSE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PREDICT_TRUE
-    #error "JSON_HEDLEY_PREDICT_TRUE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PRINTF_FORMAT
-    #error "JSON_HEDLEY_PRINTF_FORMAT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PRIVATE
-    #error "JSON_HEDLEY_PRIVATE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PUBLIC
-    #error "JSON_HEDLEY_PUBLIC must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_PURE
-    #error "JSON_HEDLEY_PURE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REINTERPRET_CAST
-    #error "JSON_HEDLEY_REINTERPRET_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REQUIRE
-    #error "JSON_HEDLEY_REQUIRE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REQUIRE_CONSTEXPR
-    #error "JSON_HEDLEY_REQUIRE_CONSTEXPR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_REQUIRE_MSG
-    #error "JSON_HEDLEY_REQUIRE_MSG must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_RESTRICT
-    #error "JSON_HEDLEY_RESTRICT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_RETURNS_NON_NULL
-    #error "JSON_HEDLEY_RETURNS_NON_NULL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_SENTINEL
-    #error "JSON_HEDLEY_SENTINEL must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STATIC_ASSERT
-    #error "JSON_HEDLEY_STATIC_ASSERT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STATIC_CAST
-    #error "JSON_HEDLEY_STATIC_CAST must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STRINGIFY
-    #error "JSON_HEDLEY_STRINGIFY must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_STRINGIFY_EX
-    #error "JSON_HEDLEY_STRINGIFY_EX must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_SUNPRO_VERSION
-    #error "JSON_HEDLEY_SUNPRO_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-    #error "JSON_HEDLEY_SUNPRO_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TINYC_VERSION
-    #error "JSON_HEDLEY_TINYC_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TINYC_VERSION_CHECK
-    #error "JSON_HEDLEY_TINYC_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_ARMCL_VERSION
-    #error "JSON_HEDLEY_TI_ARMCL_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_ARMCL_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL2000_VERSION
-    #error "JSON_HEDLEY_TI_CL2000_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL2000_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL430_VERSION
-    #error "JSON_HEDLEY_TI_CL430_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL430_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL430_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL6X_VERSION
-    #error "JSON_HEDLEY_TI_CL6X_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL6X_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL7X_VERSION
-    #error "JSON_HEDLEY_TI_CL7X_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CL7X_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CLPRU_VERSION
-    #error "JSON_HEDLEY_TI_CLPRU_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_CLPRU_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_VERSION
-    #error "JSON_HEDLEY_TI_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_TI_VERSION_CHECK
-    #error "JSON_HEDLEY_TI_VERSION_CHECK must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNAVAILABLE
-    #error "JSON_HEDLEY_UNAVAILABLE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNLIKELY
-    #error "JSON_HEDLEY_UNLIKELY must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNPREDICTABLE
-    #error "JSON_HEDLEY_UNPREDICTABLE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNREACHABLE
-    #error "JSON_HEDLEY_UNREACHABLE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_UNREACHABLE_RETURN
-    #error "JSON_HEDLEY_UNREACHABLE_RETURN must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION
-    #error "JSON_HEDLEY_VERSION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_DECODE_MAJOR
-    #error "JSON_HEDLEY_VERSION_DECODE_MAJOR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_DECODE_MINOR
-    #error "JSON_HEDLEY_VERSION_DECODE_MINOR must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_DECODE_REVISION
-    #error "JSON_HEDLEY_VERSION_DECODE_REVISION must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_VERSION_ENCODE
-    #error "JSON_HEDLEY_VERSION_ENCODE must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_WARNING
-    #error "JSON_HEDLEY_WARNING must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT
-    #error "JSON_HEDLEY_WARN_UNUSED_RESULT must not remain defined after including json.hpp"
-#endif
-#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
-    #error "JSON_HEDLEY_WARN_UNUSED_RESULT_MSG must not remain defined after including json.hpp"
-#endif
-
-TEST_CASE("no JSON_HEDLEY_* macro leaks after including json.hpp")
-{
-    // if this test compiles at all, none of the JSON_HEDLEY_* macros checked
-    // above remained defined after including <nlohmann/json.hpp>
-    CHECK(true);
-}

tests/src/unit-serialization.cpp

@@ -14,6 +14,40 @@ using nlohmann::json;
 #include <array>
 #include <sstream>
 #include <iomanip>
+#include <cstdlib>
+#include <new>
+
+namespace
+{
+// heap allocation counter used by the regression test for issue #5413
+// (https://github.com/nlohmann/json/issues/5413); disabled (and thus a
+// no-op besides the counting) unless explicitly toggled on
+bool count_heap_allocations = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+std::size_t heap_allocations = 0; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+} // namespace
+
+void* operator new (std::size_t size) // NOLINT(cppcoreguidelines-owning-memory,misc-new-delete-overloads)
+{
+    if (count_heap_allocations)
+    {
+        ++heap_allocations;
+    }
+    if (void* ptr = std::malloc(size)) // NOLINT(cppcoreguidelines-no-malloc,cppcoreguidelines-owning-memory)
+    {
+        return ptr;
+    }
+    throw std::bad_alloc(); // NOLINT(hicpp-exception-baseclass)
+}
+
+void operator delete (void* ptr) noexcept // NOLINT(cppcoreguidelines-owning-memory,misc-new-delete-overloads)
+{
+    std::free(ptr); // NOLINT(cppcoreguidelines-no-malloc,cppcoreguidelines-owning-memory)
+}
+
+void operator delete (void* ptr, std::size_t /*size*/) noexcept // NOLINT(cppcoreguidelines-owning-memory,misc-new-delete-overloads)
+{
+    std::free(ptr); // NOLINT(cppcoreguidelines-no-malloc,cppcoreguidelines-owning-memory)
+}
 
 TEST_CASE("serialization")
 {
@@ -382,3 +416,76 @@ TEST_CASE("dump for basic_json with long double number_float_t")
         check_same(100.0L,  100.0);
     }
 }
+
+TEST_CASE("regression test for issue #5413 - lazily allocated indent_string")
+{
+    // the serializer used to unconditionally allocate a 512-byte
+    // indent_string in its constructor, even though it is only ever read
+    // inside the pretty_print branches of dump(). This wasted a heap
+    // allocation (and its matching deallocation) on every single compact
+    // (i.e. non-pretty, the default) dump() call. indent_string is now
+    // allocated lazily, the first time a pretty-print branch actually
+    // needs it -- so a compact dump() must perform strictly fewer heap
+    // allocations than a pretty dump() of the same value.
+    const json j = {{"level", "info"}, {"msg", "hello world"}, {"id", 12345}};
+
+    // warm up anything unrelated to indentation (e.g., one-time locale
+    // lookups) that might otherwise allocate on first use regardless of
+    // pretty-printing, so it does not skew the counts measured below
+    const auto warmup = j.dump();
+    const auto warmup_pretty = j.dump(4);
+    CHECK(!warmup.empty());
+    CHECK(!warmup_pretty.empty());
+
+    SECTION("compact dump() has a stable, minimal allocation count")
+    {
+        count_heap_allocations = true;
+
+        heap_allocations = 0;
+        const auto compact1 = j.dump();
+        const auto allocs_compact1 = heap_allocations;
+
+        heap_allocations = 0;
+        const auto compact2 = j.dump(-1);
+        const auto allocs_compact2 = heap_allocations;
+
+        count_heap_allocations = false;
+
+        CHECK(compact1 == compact2);
+        // dump() and dump(-1) both take the compact code path and must
+        // never touch indent_string, so they allocate identically often
+        CHECK(allocs_compact1 == allocs_compact2);
+    }
+
+    SECTION("first pretty dump() allocates more than a compact dump()")
+    {
+        // use a tiny value whose compact ({"a":1}, 7 bytes) and pretty
+        // ({"a": 1} with 1-space indent, 11 bytes) serializations both stay
+        // well inside every common std::string small-string-optimization
+        // buffer (>= 15 bytes on libstdc++/MSVC STL, >= 22 on libc++), so
+        // building the result string itself causes no heap allocation
+        // either way -- isolating indent_string as the only thing that can
+        // possibly account for a difference in allocation count
+        const json tiny = {{"a", 1}};
+
+        count_heap_allocations = true;
+
+        heap_allocations = 0;
+        const auto compact = tiny.dump();
+        const auto allocs_compact = heap_allocations;
+
+        heap_allocations = 0;
+        const auto pretty = tiny.dump(1);
+        const auto allocs_pretty = heap_allocations;
+
+        count_heap_allocations = false;
+
+        CHECK(compact == "{\"a\":1}");
+        CHECK(pretty == "{\n \"a\": 1\n}");
+        // a fresh serializer is created per dump() call; the pretty branch
+        // lazily allocates indent_string on its first use, so it must
+        // allocate at least once more than the compact branch, which never
+        // touches indent_string at all
+        CHECK(allocs_pretty > allocs_compact);
+    }
+}