From e6aa7003608dd0607f304f506303fafebbc65094 Mon Sep 17 00:00:00 2001
From: Niels Lohmann <mail@nlohmann.me>
Date: Wed, 26 Jul 2017 23:44:55 +0200
Subject: [PATCH] :hammer: cleanup

---
 src/json.hpp | 885 +++++++++++++++++++++++----------------------------
 1 file changed, 398 insertions(+), 487 deletions(-)

diff --git a/src/json.hpp b/src/json.hpp
index 7c4fec5b..69ecab0f 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -119,28 +119,28 @@ template<typename = void, typename = void>
 struct adl_serializer;
 
 // forward declaration of basic_json (required to split the class)
-template <template <typename U, typename V, typename... Args> class ObjectType =
-          std::map,
-          template <typename U, typename... Args> class ArrayType = std::vector,
-          class StringType = std::string, class BooleanType = bool,
-          class NumberIntegerType = std::int64_t,
-          class NumberUnsignedType = std::uint64_t,
-          class NumberFloatType = double,
-          template <typename U> class AllocatorType = std::allocator,
-          template <typename T, typename SFINAE = void> class JSONSerializer =
-          adl_serializer>
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer>
 class basic_json;
 
 // Ugly macros to avoid uglier copy-paste when specializing basic_json
 // This is only temporary and will be removed in 3.0
 
 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                 \
-    template <template <typename, typename, typename...> class ObjectType,  \
-              template <typename, typename...> class ArrayType,             \
-              class StringType, class BooleanType, class NumberIntegerType, \
-              class NumberUnsignedType, class NumberFloatType,              \
-              template <typename> class AllocatorType,                      \
-              template <typename, typename = void> class JSONSerializer>
+    template<template<typename, typename, typename...> class ObjectType,  \
+             template<typename, typename...> class ArrayType,             \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                      \
+             template<typename, typename = void> class JSONSerializer>
 
 #define NLOHMANN_BASIC_JSON_TPL                                             \
     basic_json<ObjectType, ArrayType, StringType, BooleanType,              \
@@ -188,8 +188,7 @@ class exception : public std::exception
     const int id;
 
   protected:
-    exception(int id_, const char* what_arg)
-        : id(id_), m(what_arg) {}
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
 
     static std::string name(const std::string& ename, int id)
     {
@@ -341,8 +340,7 @@ class type_error : public exception
     }
 
   private:
-    type_error(int id_, const char* what_arg)
-        : exception(id_, what_arg) {}
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
 };
 
 /*!
@@ -371,8 +369,7 @@ class out_of_range : public exception
     }
 
   private:
-    out_of_range(int id_, const char* what_arg)
-        : exception(id_, what_arg) {}
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
 };
 
 /*!
@@ -397,8 +394,7 @@ class other_error : public exception
     }
 
   private:
-    other_error(int id_, const char* what_arg)
-        : exception(id_, what_arg) {}
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
 };
 
 
@@ -433,15 +429,15 @@ value with the default value for a given type
 */
 enum class value_t : uint8_t
 {
-    null,            ///< null value
-    object,          ///< object (unordered set of name/value pairs)
-    array,           ///< array (ordered collection of values)
-    string,          ///< string value
-    boolean,         ///< boolean value
-    number_integer,  ///< number value (signed integer)
-    number_unsigned, ///< number value (unsigned integer)
-    number_float,    ///< number value (floating-point)
-    discarded        ///< discarded by the the parser callback function
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    discarded         ///< discarded by the the parser callback function
 };
 
 /*!
@@ -482,9 +478,10 @@ inline bool operator<(const value_t lhs, const value_t rhs) noexcept
 // helpers //
 /////////////
 
-template <typename> struct is_basic_json : std::false_type {};
+template<typename> struct is_basic_json : std::false_type {};
 
-NLOHMANN_BASIC_JSON_TPL_DECLARATION struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
 
 // alias templates to reduce boilerplate
 template<bool B, typename T = void>
@@ -495,7 +492,7 @@ using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::typ
 
 // implementation of C++14 index_sequence and affiliates
 // source: https://stackoverflow.com/a/32223343
-template <std::size_t... Ints>
+template<std::size_t... Ints>
 struct index_sequence
 {
     using type = index_sequence;
@@ -506,15 +503,15 @@ struct index_sequence
     }
 };
 
-template <class Sequence1, class Sequence2>
+template<class Sequence1, class Sequence2>
 struct merge_and_renumber;
 
-template <std::size_t... I1, std::size_t... I2>
+template<std::size_t... I1, std::size_t... I2>
 struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
         : index_sequence < I1..., (sizeof...(I1) + I2)... >
           { };
 
-template <std::size_t N>
+template<std::size_t N>
 struct make_index_sequence
     : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
       typename make_index_sequence < N - N / 2 >::type >
@@ -722,10 +719,8 @@ template<class RealType, class CompatibleObjectType>
 struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType>
 {
     static constexpr auto value =
-        std::is_constructible<typename RealType::key_type,
-        typename CompatibleObjectType::key_type>::value and
-        std::is_constructible<typename RealType::mapped_type,
-        typename CompatibleObjectType::mapped_type>::value;
+        std::is_constructible<typename RealType::key_type, typename CompatibleObjectType::key_type>::value and
+        std::is_constructible<typename RealType::mapped_type, typename CompatibleObjectType::mapped_type>::value;
 };
 
 template<class BasicJsonType, class CompatibleObjectType>
@@ -772,8 +767,7 @@ struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIn
     using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
 
     static constexpr auto value =
-        std::is_constructible<RealIntegerType,
-        CompatibleNumberIntegerType>::value and
+        std::is_constructible<RealIntegerType, CompatibleNumberIntegerType>::value and
         CompatibleLimits::is_integer and
         RealLimits::is_signed == CompatibleLimits::is_signed;
 };
@@ -917,28 +911,28 @@ void to_json(BasicJsonType& j, const  CompatibleObjectType& arr)
     external_constructor<value_t::object>::construct(j, arr);
 }
 
-template <typename BasicJsonType, typename T, std::size_t N,
-          enable_if_t<not std::is_constructible<
-                          typename BasicJsonType::string_t, T (&)[N]>::value,
-                      int> = 0>
+template<typename BasicJsonType, typename T, std::size_t N,
+         enable_if_t<not std::is_constructible<
+                         typename BasicJsonType::string_t, T (&)[N]>::value,
+                     int> = 0>
 void to_json(BasicJsonType& j, T (&arr)[N])
 {
     external_constructor<value_t::array>::construct(j, arr);
 }
 
-template <typename BasicJsonType, typename... Args>
+template<typename BasicJsonType, typename... Args>
 void to_json(BasicJsonType& j, const std::pair<Args...>& p)
 {
     j = {p.first, p.second};
 }
 
-template <typename BasicJsonType, typename Tuple, std::size_t... Idx>
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
 void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...>)
 {
     j = {std::get<Idx>(t)...};
 }
 
-template <typename BasicJsonType, typename... Args>
+template<typename BasicJsonType, typename... Args>
 void to_json(BasicJsonType& j, const std::tuple<Args...>& t)
 {
     to_json_tuple_impl(j, t, index_sequence_for<Args...> {});
@@ -960,25 +954,22 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
     {
         case value_t::number_unsigned:
         {
-            val = static_cast<ArithmeticType>(
-                      *j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
             break;
         }
         case value_t::number_integer:
         {
-            val = static_cast<ArithmeticType>(
-                      *j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
             break;
         }
         case value_t::number_float:
         {
-            val = static_cast<ArithmeticType>(
-                      *j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
             break;
         }
         default:
         {
-            JSON_THROW(type_error::create(302, "type must be number, but is " + j.type_name()));
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
         }
     }
 }
@@ -986,9 +977,9 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
 template<typename BasicJsonType>
 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
 {
-    if (not j.is_boolean())
+    if (JSON_UNLIKELY(not j.is_boolean()))
     {
-        JSON_THROW(type_error::create(302, "type must be boolean, but is " + j.type_name()));
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
     }
     b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
 }
@@ -996,9 +987,9 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
 template<typename BasicJsonType>
 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
 {
-    if (not j.is_string())
+    if (JSON_UNLIKELY(not j.is_string()))
     {
-        JSON_THROW(type_error::create(302, "type must be string, but is " + j.type_name()));
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
     }
     s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
 }
@@ -1033,9 +1024,9 @@ void from_json(const BasicJsonType& j, EnumType& e)
 template<typename BasicJsonType>
 void from_json(const BasicJsonType& j, typename BasicJsonType::array_t& arr)
 {
-    if (not j.is_array())
+    if (JSON_UNLIKELY(not j.is_array()))
     {
-        JSON_THROW(type_error::create(302, "type must be array, but is " + j.type_name()));
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
     }
     arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
 }
@@ -1045,9 +1036,9 @@ template<typename BasicJsonType, typename T, typename Allocator,
          enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
 {
-    if (not j.is_array())
+    if (JSON_UNLIKELY(not j.is_array()))
     {
-        JSON_THROW(type_error::create(302, "type must be array, but is " + j.type_name()));
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
     }
 
     for (auto it = j.rbegin(), end = j.rend(); it != end; ++it)
@@ -1059,7 +1050,6 @@ void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
 template<typename BasicJsonType, typename CompatibleArrayType>
 void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0> /*unused*/)
 {
-    using std::begin;
     using std::end;
 
     std::transform(j.begin(), j.end(),
@@ -1077,7 +1067,6 @@ auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, prio
     arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),
     void())
 {
-    using std::begin;
     using std::end;
 
     arr.reserve(j.size());
@@ -1090,7 +1079,7 @@ auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, prio
     });
 }
 
-template <typename BasicJsonType, typename T, std::size_t N>
+template<typename BasicJsonType, typename T, std::size_t N>
 void from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr, priority_tag<2> /*unused*/)
 {
     for (std::size_t i = 0; i < N; ++i)
@@ -1105,9 +1094,9 @@ template<typename BasicJsonType, typename CompatibleArrayType,
                      not std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value, int> = 0>
 void from_json(const BasicJsonType& j, CompatibleArrayType& arr)
 {
-    if (not j.is_array())
+    if (JSON_UNLIKELY(not j.is_array()))
     {
-        JSON_THROW(type_error::create(302, "type must be array, but is " + j.type_name()));
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
     }
 
     from_json_array_impl(j, arr, priority_tag<2> {});
@@ -1117,14 +1106,12 @@ template<typename BasicJsonType, typename CompatibleObjectType,
          enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>
 void from_json(const BasicJsonType& j, CompatibleObjectType& obj)
 {
-    if (not j.is_object())
+    if (JSON_UNLIKELY(not j.is_object()))
     {
-        JSON_THROW(type_error::create(302, "type must be object, but is " + j.type_name()));
+        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
     }
 
     auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
-    using std::begin;
-    using std::end;
     using value_type = typename CompatibleObjectType::value_type;
     std::transform(
         inner_object->begin(), inner_object->end(),
@@ -1132,8 +1119,7 @@ void from_json(const BasicJsonType& j, CompatibleObjectType& obj)
         [](typename BasicJsonType::object_t::value_type const & p)
     {
         return value_type(
-                   p.first,
-                   p.second
+                   p.first, p.second
                    .template get<typename CompatibleObjectType::mapped_type>());
     });
 }
@@ -1176,24 +1162,24 @@ void from_json(const BasicJsonType& j, ArithmeticType& val)
         }
         default:
         {
-            JSON_THROW(type_error::create(302, "type must be number, but is " + j.type_name()));
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
         }
     }
 }
 
-template <typename BasicJsonType, typename... Args>
+template<typename BasicJsonType, typename... Args>
 void from_json(const BasicJsonType& j, std::pair<Args...>& p)
 {
     p = {j.at(0), j.at(1)};
 }
 
-template <typename BasicJsonType, typename Tuple, std::size_t... Idx>
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
 void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)
 {
     t = std::make_tuple(j.at(Idx)...);
 }
 
-template <typename BasicJsonType, typename... Args>
+template<typename BasicJsonType, typename... Args>
 void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
 {
     from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
@@ -1299,9 +1285,9 @@ class cached_input_stream_adapter : public input_adapter_protocol
     {
         // clear stream flags
         is.clear();
-        // We initially read a lot of characters into the buffer, and we may not
-        // have processed all of them. Therefore, we need to "rewind" the stream
-        // after the last processed char.
+        // We initially read a lot of characters into the buffer, and we may
+        // not have processed all of them. Therefore, we need to "rewind" the
+        // stream after the last processed char.
         is.seekg(start_position);
         is.ignore(static_cast<std::streamsize>(processed_chars));
         // clear stream flags
@@ -1443,37 +1429,37 @@ class input_adapter
         : ia(std::make_shared<cached_input_stream_adapter<16384>>(i)) {}
 
     /// input adapter for buffer
-    template <typename CharT,
-              typename std::enable_if<
-                  std::is_pointer<CharT>::value and
-                  std::is_integral<
-                      typename std::remove_pointer<CharT>::type>::value and
-                  sizeof(typename std::remove_pointer<CharT>::type) == 1,
-                  int>::type = 0>
+    template<typename CharT,
+             typename std::enable_if<
+                 std::is_pointer<CharT>::value and
+                 std::is_integral<
+                     typename std::remove_pointer<CharT>::type>::value and
+                 sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                 int>::type = 0>
     input_adapter(CharT b, std::size_t l)
         : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
 
     // derived support
 
     /// input adapter for string literal
-    template <typename CharT,
-              typename std::enable_if<
-                  std::is_pointer<CharT>::value and
-                  std::is_integral<
-                      typename std::remove_pointer<CharT>::type>::value and
-                  sizeof(typename std::remove_pointer<CharT>::type) == 1,
-                  int>::type = 0>
+    template<typename CharT,
+             typename std::enable_if<
+                 std::is_pointer<CharT>::value and
+                 std::is_integral<
+                     typename std::remove_pointer<CharT>::type>::value and
+                 sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                 int>::type = 0>
     input_adapter(CharT b)
         : input_adapter(reinterpret_cast<const char*>(b),
                         std::strlen(reinterpret_cast<const char*>(b))) {}
 
     /// input adapter for iterator range with contiguous storage
-    template <class IteratorType,
-              typename std::enable_if<
-                  std::is_same<typename std::iterator_traits<
-                                   IteratorType>::iterator_category,
-                               std::random_access_iterator_tag>::value,
-                  int>::type = 0>
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename std::iterator_traits<
+                                  IteratorType>::iterator_category,
+                              std::random_access_iterator_tag>::value,
+                 int>::type = 0>
     input_adapter(IteratorType first, IteratorType last)
     {
         // assertion to check that the iterator range is indeed contiguous,
@@ -1505,7 +1491,7 @@ class input_adapter
     }
 
     /// input adapter for array
-    template <class T, std::size_t N>
+    template<class T, std::size_t N>
     input_adapter(T (&array)[N])
         : input_adapter(std::begin(array), std::end(array)) {}
 
@@ -1541,7 +1527,7 @@ class input_adapter
 
 This class organizes the lexical analysis during JSON deserialization.
 */
-template <typename BasicJsonType>
+template<typename BasicJsonType>
 class lexer
 {
     using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -1552,27 +1538,23 @@ class lexer
     /// token types for the parser
     enum class token_type
     {
-        uninitialized,  ///< indicating the scanner is uninitialized
-        literal_true,   ///< the `true` literal
-        literal_false,  ///< the `false` literal
-        literal_null,   ///< the `null` literal
-        value_string,   ///< a string -- use get_string() for actual value
-        value_unsigned, ///< an unsigned integer -- use get_number_unsigned() for
-        ///actual value
-        value_integer,  ///< a signed integer -- use get_number_integer() for actual
-        ///value
-        value_float,    ///< an floating point number -- use get_number_float() for
-        ///actual value
-        begin_array,    ///< the character for array begin `[`
-        begin_object,   ///< the character for object begin `{`
-        end_array,      ///< the character for array end `]`
-        end_object,     ///< the character for object end `}`
-        name_separator, ///< the name separator `:`
-        value_separator, ///< the value separator `,`
-        parse_error,     ///< indicating a parse error
-        end_of_input,    ///< indicating the end of the input buffer
-        literal_or_value ///< a literal or the begin of a value (only for
-        ///diagnostics)
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
     };
 
     /// return name of values of type token_type (only used for errors)
@@ -1647,8 +1629,7 @@ class lexer
     /*!
     @brief get codepoint from 4 hex characters following `\u`
 
-    @return codepoint or -1 in case of an error (e.g. EOF or non-hex
-            character)
+    @return codepoint or -1 in case of an error (e.g. EOF or non-hex character)
     */
     int get_codepoint()
     {
@@ -1903,9 +1884,9 @@ class lexer
     @brief scan a string literal
 
     This function scans a string according to Sect. 7 of RFC 7159. While
-    scanning, bytes are escaped and copied into buffer yytext. Then the function
-    returns successfully, yytext is null-terminated and yylen contains the
-    number of bytes in the string.
+    scanning, bytes are escaped and copied into buffer yytext. Then the
+    function returns successfully, yytext is null-terminated and yylen
+    contains the number of bytes in the string.
 
     @return token_type::value_string if string could be successfully scanned,
             token_type::parse_error otherwise
@@ -1988,8 +1969,7 @@ class lexer
 
                             if (JSON_UNLIKELY(codepoint1 == -1))
                             {
-                                error_message =
-                                    "invalid string: '\\u' must be followed by 4 hex digits";
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
                                 return token_type::parse_error;
                             }
 
@@ -2457,27 +2437,17 @@ class lexer
     errors. In the table below, "anything" means any character but the ones
     listed before.
 
-    state    | 0        | 1-9      | e E      | +       | -       | .        |
-    anything
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
     ---------|----------|----------|----------|---------|---------|----------|-----------
-    init     | zero     | any1     | [error]  | [error] | minus   | [error]  |
-    [error]
-    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  |
-    [error]
-    zero     | done     | done     | exponent | done    | done    | decimal1 |
-    done
-    any1     | any1     | any1     | exponent | done    | done    | decimal1 |
-    done
-    decimal1 | decimal2 | [error]  | [error]  | [error] | [error] | [error]  |
-    [error]
-    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     |
-    done
-    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  |
-    [error]
-    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  |
-    [error]
-    any2     | any2     | any2     | done     | done    | done    | done     |
-    done
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | [error]  | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
 
     The state machine is realized with one label per state (prefixed with
     "scan_number_") and `goto` statements between them. The state machine
@@ -2780,8 +2750,8 @@ scan_number_any2:
         }
 
 scan_number_done:
-        // unget the character after the number (we only read it to know
-        // that we are done scanning a number)
+        // unget the character after the number (we only read it to know that we
+        // are done scanning a number)
         --chars_read;
         next_unget = true;
 
@@ -2827,8 +2797,8 @@ scan_number_done:
             }
         }
 
-        // this code is reached if we parse a floating-point number or if
-        // an integer conversion above failed
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
         strtof(value_float, yytext.data(), nullptr);
         return token_type::value_float;
     }
@@ -2911,8 +2881,8 @@ scan_number_done:
     /// return string value
     const std::string get_string()
     {
-        // yytext cannot be returned as char*, because it may contain a
-        // null byte (parsed as "\u0000")
+        // yytext cannot be returned as char*, because it may contain a null
+        // byte (parsed as "\u0000")
         return std::string(yytext.data(), yylen);
     }
 
@@ -2976,8 +2946,7 @@ scan_number_done:
         {
             get();
         }
-        while (current == ' ' or current == '\t' or current == '\n' or
-                current == '\r');
+        while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
 
         switch (current)
         {
@@ -3071,13 +3040,12 @@ scan_number_done:
 
 This class implements a recursive decent parser.
 */
-template <typename BasicJsonType>
+template<typename BasicJsonType>
 class parser
 {
     using number_integer_t = typename BasicJsonType::number_integer_t;
     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
     using number_float_t = typename BasicJsonType::number_float_t;
-
     using lexer_t = lexer<BasicJsonType>;
     using token_type = typename lexer_t::token_type;
 
@@ -3367,8 +3335,7 @@ class parser
                 if (JSON_UNLIKELY(not std::isfinite(result.m_value.number_float)))
                 {
                     JSON_THROW(out_of_range::create(406, "number overflow parsing '" +
-                                                    m_lexer.get_token_string() +
-                                                    "'"));
+                                                    m_lexer.get_token_string() + "'"));
                 }
                 break;
             }
@@ -3397,9 +3364,8 @@ class parser
     /*!
     @brief the acutal acceptor
 
-    @invariant 1. The last token is not yet processed. Therefore, the
-                  caller of this function must make sure a token has
-                  been read.
+    @invariant 1. The last token is not yet processed. Therefore, the caller
+                  of this function must make sure a token has been read.
                2. When this function returns, the last token is processed.
                   That is, the last read character was already considered.
 
@@ -3581,10 +3547,11 @@ class primitive_iterator_t
   public:
     using difference_type = std::ptrdiff_t;
 
-    difference_type get_value() const noexcept
+    constexpr difference_type get_value() const noexcept
     {
         return m_it;
     }
+
     /// set iterator to a defined beginning
     void set_begin() noexcept
     {
@@ -3609,38 +3576,32 @@ class primitive_iterator_t
         return (m_it == end_value);
     }
 
-    friend constexpr bool operator==(primitive_iterator_t lhs,
-                                     primitive_iterator_t rhs) noexcept
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
-        return lhs.m_it == rhs.m_it;
+        return (lhs.m_it == rhs.m_it);
     }
 
-    friend constexpr bool operator!=(primitive_iterator_t lhs,
-                                     primitive_iterator_t rhs) noexcept
+    friend constexpr bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
-        return !(lhs == rhs);
+        return not(lhs == rhs);
     }
 
-    friend constexpr bool operator<(primitive_iterator_t lhs,
-                                    primitive_iterator_t rhs) noexcept
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
         return lhs.m_it < rhs.m_it;
     }
 
-    friend constexpr bool operator<=(primitive_iterator_t lhs,
-                                     primitive_iterator_t rhs) noexcept
+    friend constexpr bool operator<=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
         return lhs.m_it <= rhs.m_it;
     }
 
-    friend constexpr bool operator>(primitive_iterator_t lhs,
-                                    primitive_iterator_t rhs) noexcept
+    friend constexpr bool operator>(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
         return lhs.m_it > rhs.m_it;
     }
 
-    friend constexpr bool operator>=(primitive_iterator_t lhs,
-                                     primitive_iterator_t rhs) noexcept
+    friend constexpr bool operator>=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
         return lhs.m_it >= rhs.m_it;
     }
@@ -3652,13 +3613,12 @@ class primitive_iterator_t
         return result;
     }
 
-    friend constexpr difference_type
-    operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
         return lhs.m_it - rhs.m_it;
     }
 
-    friend std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)
+    friend constexpr std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)
     {
         return os << it.m_it;
     }
@@ -3712,11 +3672,10 @@ class primitive_iterator_t
 /*!
 @brief an iterator value
 
-@note This structure could easily be a union, but MSVC currently does not
-allow unions members with complex constructors, see
-https://github.com/nlohmann/json/pull/105.
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
 */
-template <typename BasicJsonType> struct internal_iterator
+template<typename BasicJsonType> struct internal_iterator
 {
     /// iterator for JSON objects
     typename BasicJsonType::object_t::iterator object_iterator {};
@@ -3726,7 +3685,7 @@ template <typename BasicJsonType> struct internal_iterator
     primitive_iterator_t primitive_iterator {};
 };
 
-template <typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy;
 
 /*!
 @brief a template for a random access iterator for the @ref basic_json class
@@ -3747,7 +3706,7 @@ This class implements a both iterators (iterator and const_iterator) for the
 
 @since version 1.0.0, simplified in version 2.0.9
 */
-template <typename BasicJsonType>
+template<typename BasicJsonType>
 class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJsonType>
 {
     /// allow basic_json to access private members
@@ -3814,13 +3773,12 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
     }
 
     /*!
-    @note The conventional copy constructor and copy assignment are
-          implicitly defined.
-          Combined with the following converting constructor and assignment,
-          they support: copy from iterator to iterator,
-                        copy from const iterator to const iterator,
-                        and conversion from iterator to const iterator.
-          However conversion from const iterator to iterator is not defined.
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
     */
 
     /*!
@@ -3829,8 +3787,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
     @note It is not checked whether @a other is initialized.
     */
     iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
-        : m_object(other.m_object),
-          m_it(other.m_it) {}
+        : m_object(other.m_object), m_it(other.m_it) {}
 
     /*!
     @brief converting assignment
@@ -3943,7 +3900,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
 
             default:
             {
-                if (m_it.primitive_iterator.is_begin())
+                if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
                 {
                     return *m_object;
                 }
@@ -3977,7 +3934,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
 
             default:
             {
-                if (m_it.primitive_iterator.is_begin())
+                if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
                 {
                     return m_object;
                 }
@@ -4080,10 +4037,9 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
     bool operator==(const iter_impl& other) const
     {
         // if objects are not the same, the comparison is undefined
-        if (m_object != other.m_object)
+        if (JSON_UNLIKELY(m_object != other.m_object))
         {
-            JSON_THROW(invalid_iterator::create(
-                           212, "cannot compare iterators of different containers"));
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
         }
 
         assert(m_object != nullptr);
@@ -4123,10 +4079,9 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
     bool operator<(const iter_impl& other) const
     {
         // if objects are not the same, the comparison is undefined
-        if (m_object != other.m_object)
+        if (JSON_UNLIKELY(m_object != other.m_object))
         {
-            JSON_THROW(invalid_iterator::create(
-                           212, "cannot compare iterators of different containers"));
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
         }
 
         assert(m_object != nullptr);
@@ -4135,8 +4090,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
         {
             case value_t::object:
             {
-                JSON_THROW(invalid_iterator::create(
-                               213, "cannot compare order of object iterators"));
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
             }
 
             case value_t::array:
@@ -4190,8 +4144,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
         {
             case value_t::object:
             {
-                JSON_THROW(invalid_iterator::create(
-                               209, "cannot use offsets with object iterators"));
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
             }
 
             case value_t::array:
@@ -4264,8 +4217,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
         {
             case value_t::object:
             {
-                JSON_THROW(invalid_iterator::create(
-                               209, "cannot use offsets with object iterators"));
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
             }
 
             case value_t::array:
@@ -4292,8 +4244,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
         {
             case value_t::object:
             {
-                JSON_THROW(invalid_iterator::create(
-                               208, "cannot use operator[] for object iterators"));
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
             }
 
             case value_t::array:
@@ -4308,7 +4259,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
 
             default:
             {
-                if (m_it.primitive_iterator.get_value() == -n)
+                if (JSON_LIKELY(m_it.primitive_iterator.get_value() == -n))
                 {
                     return *m_object;
                 }
@@ -4326,13 +4277,12 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
     {
         assert(m_object != nullptr);
 
-        if (m_object->is_object())
+        if (JSON_LIKELY(m_object->is_object()))
         {
             return m_it.object_iterator->first;
         }
 
-        JSON_THROW(invalid_iterator::create(
-                       207, "cannot use key() for non-object iterators"));
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
     }
 
     /*!
@@ -4352,7 +4302,7 @@ class iter_impl : public std::iterator<std::random_access_iterator_tag, BasicJso
 };
 
 /// proxy class for the iterator_wrapper functions
-template <typename IteratorType> class iteration_proxy
+template<typename IteratorType> class iteration_proxy
 {
   private:
     /// helper class for iteration
@@ -4383,7 +4333,7 @@ template <typename IteratorType> class iteration_proxy
         }
 
         /// inequality operator (needed for range-based for)
-        bool operator!=(const iteration_proxy_internal& o) const
+        constexpr bool operator!=(const iteration_proxy_internal& o) const
         {
             return anchor != o.anchor;
         }
@@ -4461,7 +4411,7 @@ create @ref const_reverse_iterator).
 
 @since version 1.0.0
 */
-template <typename Base>
+template<typename Base>
 class json_reverse_iterator : public std::reverse_iterator<Base>
 {
   public:
@@ -4472,8 +4422,7 @@ class json_reverse_iterator : public std::reverse_iterator<Base>
     using reference = typename Base::reference;
 
     /// create reverse iterator from iterator
-    json_reverse_iterator(
-        const typename base_iterator::iterator_type& it) noexcept
+    json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
         : base_iterator(it) {}
 
     /// create reverse iterator from base class
@@ -4553,7 +4502,7 @@ class json_reverse_iterator : public std::reverse_iterator<Base>
 /////////////////////
 
 /// abstract output adapter interface
-template <typename CharType> struct output_adapter_protocol
+template<typename CharType> struct output_adapter_protocol
 {
     virtual void write_character(CharType c) = 0;
     virtual void write_characters(const CharType* s, std::size_t length) = 0;
@@ -4561,11 +4510,11 @@ template <typename CharType> struct output_adapter_protocol
 };
 
 /// a type to simplify interfaces
-template <typename CharType>
+template<typename CharType>
 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
 
 /// output adapter for byte vectors
-template <typename CharType>
+template<typename CharType>
 class output_vector_adapter : public output_adapter_protocol<CharType>
 {
   public:
@@ -4586,7 +4535,7 @@ class output_vector_adapter : public output_adapter_protocol<CharType>
 };
 
 /// output adapter for output streams
-template <typename CharType>
+template<typename CharType>
 class output_stream_adapter : public output_adapter_protocol<CharType>
 {
   public:
@@ -4607,7 +4556,7 @@ class output_stream_adapter : public output_adapter_protocol<CharType>
 };
 
 /// output adapter for basic_string
-template <typename CharType>
+template<typename CharType>
 class output_string_adapter : public output_adapter_protocol<CharType>
 {
   public:
@@ -4627,7 +4576,7 @@ class output_string_adapter : public output_adapter_protocol<CharType>
     std::basic_string<CharType>& str;
 };
 
-template <typename CharType>
+template<typename CharType>
 class output_adapter
 {
   public:
@@ -4656,7 +4605,7 @@ class output_adapter
 /*!
 @brief deserialization of CBOR and MessagePack values
 */
-template <typename BasicJsonType>
+template<typename BasicJsonType>
 class binary_reader
 {
     using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -5493,9 +5442,8 @@ class binary_reader
             {
                 std::stringstream ss;
                 ss << std::setw(2) << std::setfill('0') << std::hex << current;
-                JSON_THROW(parse_error::create(
-                               112, chars_read,
-                               "error reading MessagePack; last byte: 0x" + ss.str()));
+                JSON_THROW(parse_error::create(112, chars_read,
+                                               "error reading MessagePack; last byte: 0x" + ss.str()));
             }
         }
     }
@@ -5539,10 +5487,9 @@ class binary_reader
           bytes in CBOR and MessagePack are stored in network order (big
           endian) and therefore need reordering on little endian systems.
 
-    @throw parse_error.110 if input has less than `sizeof(NumberType)`
-                           bytes
+    @throw parse_error.110 if input has less than `sizeof(NumberType)` bytes
     */
-    template <typename NumberType> NumberType get_number()
+    template<typename NumberType> NumberType get_number()
     {
         // step 1: read input into array with system's byte order
         std::array<uint8_t, sizeof(NumberType)> vec;
@@ -5680,8 +5627,7 @@ class binary_reader
             {
                 std::stringstream ss;
                 ss << std::setw(2) << std::setfill('0') << std::hex << current;
-                JSON_THROW(parse_error::create(
-                               113, chars_read, "expected a CBOR string; last byte: 0x" + ss.str()));
+                JSON_THROW(parse_error::create(113, chars_read, "expected a CBOR string; last byte: 0x" + ss.str()));
             }
         }
     }
@@ -5763,9 +5709,8 @@ class binary_reader
             {
                 std::stringstream ss;
                 ss << std::setw(2) << std::setfill('0') << std::hex << current;
-                JSON_THROW(parse_error::create(
-                               113, chars_read,
-                               "expected a MessagePack string; last byte: 0x" + ss.str()));
+                JSON_THROW(parse_error::create(113, chars_read,
+                                               "expected a MessagePack string; last byte: 0x" + ss.str()));
             }
         }
     }
@@ -5799,7 +5744,7 @@ class binary_reader
 /*!
 @brief serialization to CBOR and MessagePack values
 */
-template <typename BasicJsonType>
+template<typename BasicJsonType>
 class binary_writer
 {
   public:
@@ -6085,9 +6030,8 @@ class binary_writer
                 if (j.m_value.number_integer >= 0)
                 {
                     // MessagePack does not differentiate between positive
-                    // signed integers and unsigned integers. Therefore, we
-                    // used the code from the value_t::number_unsigned case
-                    // here.
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
                     if (j.m_value.number_unsigned < 128)
                     {
                         // positive fixnum
@@ -6309,11 +6253,11 @@ class binary_writer
     @param[in] n number of type @a NumberType
     @tparam NumberType the type of the number
 
-    @note This function needs to respect the system's endianess, because
-          bytes in CBOR and MessagePack are stored in network order (big
-          endian) and therefore need reordering on little endian systems.
+    @note This function needs to respect the system's endianess, because bytes
+          in CBOR and MessagePack are stored in network order (big endian) and
+          therefore need reordering on little endian systems.
     */
-    template <typename NumberType> void write_number(NumberType n)
+    template<typename NumberType> void write_number(NumberType n)
     {
         // step 1: write number to array of length NumberType
         std::array<uint8_t, sizeof(NumberType)> vec;
@@ -6341,7 +6285,7 @@ class binary_writer
 // serialization //
 ///////////////////
 
-template <typename BasicJsonType>
+template<typename BasicJsonType>
 class serializer
 {
     using string_t = typename BasicJsonType::string_t;
@@ -6366,10 +6310,10 @@ class serializer
     /*!
     @brief internal implementation of the serialization function
 
-    This function is called by the public member function dump and
-    organizes the serialization internally. The indentation level is
-    propagated as additional parameter. In case of arrays and objects, the
-    function is called recursively.
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
 
     - strings and object keys are escaped using `escape_string()`
     - integer numbers are converted implicitly via `operator<<`
@@ -6472,9 +6416,9 @@ class serializer
 
                     // variable to hold indentation for recursive calls
                     const auto new_indent = current_indent + indent_step;
-                    if (indent_string.size() < new_indent)
+                    if (JSON_UNLIKELY(indent_string.size() < new_indent))
                     {
-                        indent_string.resize(new_indent, ' ');
+                        indent_string.resize(indent_string.size() * 2, ' ');
                     }
 
                     // first n-1 elements
@@ -6666,10 +6610,10 @@ class serializer
 
                         if (bytes == 3)
                         {
-                            // codepoints that need 4 bytes (i.e., 3
-                            // additional bytes) in UTF-8 needs a surrogate
-                            // pair when \u escaping is used:
-                            // from 4 bytes to \uxxxx\uxxxx (12 bytes)
+                            // codepoints that need 4 bytes (i.e., 3 additional
+                            // bytes) in UTF-8 needs a surrogate pair when \u
+                            // escaping is used: from 4 bytes to \uxxxx\uxxxx
+                            // (12 bytes)
                             res += (12 - bytes - 1);
                         }
                         else
@@ -6743,13 +6687,14 @@ class serializer
     /*!
     @brief dump escaped string
 
-    Escape a string by replacing certain special characters by a sequence
-    of an escape character (backslash) and another character and other
-    control characters by a sequence of "\u" followed by a four-digit hex
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
     representation. The escaped string is written to output stream @a o.
 
     @param[in] s  the string to escape
-    @param[in] ensure_ascii  whether to escape non-ASCII characters with \uXXXX sequences
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
 
     @complexity Linear in the length of string @a s.
     */
@@ -6950,8 +6895,8 @@ class serializer
     /*!
     @brief dump a floating-point number
 
-    Dump a given floating-point number to output stream @a o. Works
-    internally with @a number_buffer.
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
 
     @param[in] x  floating-point number to dump
     */
@@ -7019,7 +6964,7 @@ class serializer
             std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
                          [](char c)
         {
-            return c == '.' or c == 'e';
+            return (c == '.' or c == 'e');
         });
 
         if (value_is_int_like)
@@ -7180,7 +7125,7 @@ class json_pointer
     */
     std::string pop_back()
     {
-        if (is_root())
+        if (JSON_UNLIKELY(is_root()))
         {
             JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
         }
@@ -7198,7 +7143,7 @@ class json_pointer
 
     json_pointer top() const
     {
-        if (is_root())
+        if (JSON_UNLIKELY(is_root()))
         {
             JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
         }
@@ -7296,12 +7241,11 @@ class json_pointer
         }
 
         // check if nonempty reference string begins with slash
-        if (reference_string[0] != '/')
+        if (JSON_UNLIKELY(reference_string[0] != '/'))
         {
-            JSON_THROW(detail::parse_error::create(
-                           107, 1,
-                           "JSON pointer must be empty or begin with '/' - was: '" +
-                           reference_string + "'"));
+            JSON_THROW(detail::parse_error::create(107, 1,
+                                                   "JSON pointer must be empty or begin with '/' - was: '" +
+                                                   reference_string + "'"));
         }
 
         // extract the reference tokens:
@@ -7332,12 +7276,11 @@ class json_pointer
                 assert(reference_token[pos] == '~');
 
                 // ~ must be followed by 0 or 1
-                if (pos == reference_token.size() - 1 or
-                        (reference_token[pos + 1] != '0' and
-                         reference_token[pos + 1] != '1'))
+                if (JSON_UNLIKELY(pos == reference_token.size() - 1 or
+                                  (reference_token[pos + 1] != '0' and
+                                   reference_token[pos + 1] != '1')))
                 {
-                    JSON_THROW(detail::parse_error::create(
-                                   108, 0, "escape character '~' must be followed with '0' or '1'"));
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
                 }
             }
 
@@ -7373,21 +7316,18 @@ class json_pointer
         {}
     }
 
-    /// escape tilde and slash
+    /// escape "~"" to "~0" and "/" to "~1"
     static std::string escape(std::string s)
     {
-        // escape "~"" to "~0" and "/" to "~1"
         replace_substring(s, "~", "~0");
         replace_substring(s, "/", "~1");
         return s;
     }
 
-    /// unescape tilde and slash
+    /// unescape "~1" to tilde and "~0" to slash (order is important!)
     static void unescape(std::string& s)
     {
-        // first transform any occurrence of the sequence '~1' to '/'
         replace_substring(s, "~1", "/");
-        // then transform any occurrence of the sequence '~0' to '~'
         replace_substring(s, "~0", "~");
     }
 
@@ -7516,7 +7456,7 @@ class basic_json
     friend ::nlohmann::json_pointer;
     friend ::nlohmann::detail::parser<basic_json>;
     friend ::nlohmann::detail::serializer<basic_json>;
-    template <typename BasicJsonType>
+    template<typename BasicJsonType>
     friend class ::nlohmann::detail::iter_impl;
     friend ::nlohmann::detail::binary_writer<basic_json>;
     /// workaround type for MSVC
@@ -7527,15 +7467,15 @@ class basic_json
     using parser = ::nlohmann::detail::parser<basic_json>;
 
     using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
-    template <typename BasicJsonType>
+    template<typename BasicJsonType>
     using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
-    template <typename BasicJsonType>
+    template<typename BasicJsonType>
     using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
-    template <typename Iterator>
+    template<typename Iterator>
     using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
     template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
 
-    template <typename CharType>
+    template<typename CharType>
     using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
 
     using binary_reader = ::nlohmann::detail::binary_reader<basic_json>;
@@ -8614,7 +8554,7 @@ class basic_json
         bool is_an_object = std::all_of(init.begin(), init.end(),
                                         [](const basic_json & element)
         {
-            return element.is_array() and element.size() == 2 and element[0].is_string();
+            return (element.is_array() and element.size() == 2 and element[0].is_string());
         });
 
         // adjust type if type deduction is not wanted
@@ -8627,7 +8567,7 @@ class basic_json
             }
 
             // if object is wanted but impossible, throw an exception
-            if (manual_type == value_t::object and not is_an_object)
+            if (JSON_UNLIKELY(manual_type == value_t::object and not is_an_object))
             {
                 JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
             }
@@ -8811,7 +8751,7 @@ class basic_json
         assert(last.m_object != nullptr);
 
         // make sure iterator fits the current value
-        if (first.m_object != last.m_object)
+        if (JSON_UNLIKELY(first.m_object != last.m_object))
         {
             JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
         }
@@ -8828,7 +8768,8 @@ class basic_json
             case value_t::number_unsigned:
             case value_t::string:
             {
-                if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
+                if (JSON_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
+                                  or not last.m_it.primitive_iterator.is_end()))
                 {
                     JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
                 }
@@ -8890,7 +8831,7 @@ class basic_json
             default:
             {
                 JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
-                                                    first.m_object->type_name()));
+                                                    std::string(first.m_object->type_name())));
             }
         }
 
@@ -9231,7 +9172,7 @@ class basic_json
     */
     constexpr bool is_null() const noexcept
     {
-        return m_type == value_t::null;
+        return (m_type == value_t::null);
     }
 
     /*!
@@ -9253,7 +9194,7 @@ class basic_json
     */
     constexpr bool is_boolean() const noexcept
     {
-        return m_type == value_t::boolean;
+        return (m_type == value_t::boolean);
     }
 
     /*!
@@ -9312,7 +9253,7 @@ class basic_json
     */
     constexpr bool is_number_integer() const noexcept
     {
-        return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
+        return (m_type == value_t::number_integer or m_type == value_t::number_unsigned);
     }
 
     /*!
@@ -9340,7 +9281,7 @@ class basic_json
     */
     constexpr bool is_number_unsigned() const noexcept
     {
-        return m_type == value_t::number_unsigned;
+        return (m_type == value_t::number_unsigned);
     }
 
     /*!
@@ -9368,7 +9309,7 @@ class basic_json
     */
     constexpr bool is_number_float() const noexcept
     {
-        return m_type == value_t::number_float;
+        return (m_type == value_t::number_float);
     }
 
     /*!
@@ -9390,7 +9331,7 @@ class basic_json
     */
     constexpr bool is_object() const noexcept
     {
-        return m_type == value_t::object;
+        return (m_type == value_t::object);
     }
 
     /*!
@@ -9412,7 +9353,7 @@ class basic_json
     */
     constexpr bool is_array() const noexcept
     {
-        return m_type == value_t::array;
+        return (m_type == value_t::array);
     }
 
     /*!
@@ -9434,7 +9375,7 @@ class basic_json
     */
     constexpr bool is_string() const noexcept
     {
-        return m_type == value_t::string;
+        return (m_type == value_t::string);
     }
 
     /*!
@@ -9461,7 +9402,7 @@ class basic_json
     */
     constexpr bool is_discarded() const noexcept
     {
-        return m_type == value_t::discarded;
+        return (m_type == value_t::discarded);
     }
 
     /*!
@@ -9497,12 +9438,12 @@ class basic_json
     /// get a boolean (explicit)
     boolean_t get_impl(boolean_t* /*unused*/) const
     {
-        if (is_boolean())
+        if (JSON_LIKELY(is_boolean()))
         {
             return m_value.boolean;
         }
 
-        JSON_THROW(type_error::create(302, "type must be boolean, but is " + type_name()));
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
     }
 
     /// get a pointer to the value (object)
@@ -9603,18 +9544,15 @@ class basic_json
     template<typename ReferenceType, typename ThisType>
     static ReferenceType get_ref_impl(ThisType& obj)
     {
-        // helper type
-        using PointerType = typename std::add_pointer<ReferenceType>::type;
-
         // delegate the call to get_ptr<>()
-        auto ptr = obj.template get_ptr<PointerType>();
+        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
 
-        if (ptr != nullptr)
+        if (JSON_LIKELY(ptr != nullptr))
         {
             return *ptr;
         }
 
-        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + obj.type_name()));
+        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
     }
 
   public:
@@ -10010,7 +9948,7 @@ class basic_json
     reference at(size_type idx)
     {
         // at only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
             JSON_TRY
             {
@@ -10024,7 +9962,7 @@ class basic_json
         }
         else
         {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + type_name()));
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
         }
     }
 
@@ -10057,7 +9995,7 @@ class basic_json
     const_reference at(size_type idx) const
     {
         // at only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
             JSON_TRY
             {
@@ -10071,7 +10009,7 @@ class basic_json
         }
         else
         {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + type_name()));
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
         }
     }
 
@@ -10108,7 +10046,7 @@ class basic_json
     reference at(const typename object_t::key_type& key)
     {
         // at only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             JSON_TRY
             {
@@ -10122,7 +10060,7 @@ class basic_json
         }
         else
         {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + type_name()));
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
         }
     }
 
@@ -10159,7 +10097,7 @@ class basic_json
     const_reference at(const typename object_t::key_type& key) const
     {
         // at only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             JSON_TRY
             {
@@ -10173,7 +10111,7 @@ class basic_json
         }
         else
         {
-            JSON_THROW(type_error::create(304, "cannot use at() with " + type_name()));
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
         }
     }
 
@@ -10213,7 +10151,7 @@ class basic_json
         }
 
         // operator[] only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
             // fill up array with null values if given idx is outside range
             if (idx >= m_value.array->size())
@@ -10226,7 +10164,7 @@ class basic_json
             return m_value.array->operator[](idx);
         }
 
-        JSON_THROW(type_error::create(305, "cannot use operator[] with " + type_name()));
+        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
     }
 
     /*!
@@ -10251,12 +10189,12 @@ class basic_json
     const_reference operator[](size_type idx) const
     {
         // const operator[] only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
             return m_value.array->operator[](idx);
         }
 
-        JSON_THROW(type_error::create(305, "cannot use operator[] with " + type_name()));
+        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
     }
 
     /*!
@@ -10297,12 +10235,12 @@ class basic_json
         }
 
         // operator[] only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             return m_value.object->operator[](key);
         }
 
-        JSON_THROW(type_error::create(305, "cannot use operator[] with " + type_name()));
+        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
     }
 
     /*!
@@ -10338,13 +10276,13 @@ class basic_json
     const_reference operator[](const typename object_t::key_type& key) const
     {
         // const operator[] only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             assert(m_value.object->find(key) != m_value.object->end());
             return m_value.object->find(key)->second;
         }
 
-        JSON_THROW(type_error::create(305, "cannot use operator[] with " + type_name()));
+        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
     }
 
     /*!
@@ -10386,12 +10324,12 @@ class basic_json
         }
 
         // at only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             return m_value.object->operator[](key);
         }
 
-        JSON_THROW(type_error::create(305, "cannot use operator[] with " + type_name()));
+        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
     }
 
     /*!
@@ -10428,13 +10366,13 @@ class basic_json
     const_reference operator[](T* key) const
     {
         // at only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             assert(m_value.object->find(key) != m_value.object->end());
             return m_value.object->find(key)->second;
         }
 
-        JSON_THROW(type_error::create(305, "cannot use operator[] with " + type_name()));
+        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
     }
 
     /*!
@@ -10490,7 +10428,7 @@ class basic_json
     ValueType value(const typename object_t::key_type& key, ValueType default_value) const
     {
         // at only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             // if key is found, return value and given default value otherwise
             const auto it = find(key);
@@ -10503,7 +10441,7 @@ class basic_json
         }
         else
         {
-            JSON_THROW(type_error::create(306, "cannot use value() with " + type_name()));
+            JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
         }
     }
 
@@ -10562,7 +10500,7 @@ class basic_json
     ValueType value(const json_pointer& ptr, ValueType default_value) const
     {
         // at only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             // if pointer resolves a value, return it or use default value
             JSON_TRY
@@ -10575,7 +10513,7 @@ class basic_json
             }
         }
 
-        JSON_THROW(type_error::create(306, "cannot use value() with " + type_name()));
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
     }
 
     /*!
@@ -10726,7 +10664,7 @@ class basic_json
     IteratorType erase(IteratorType pos)
     {
         // make sure iterator fits the current value
-        if (this != pos.m_object)
+        if (JSON_UNLIKELY(this != pos.m_object))
         {
             JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
         }
@@ -10741,7 +10679,7 @@ class basic_json
             case value_t::number_unsigned:
             case value_t::string:
             {
-                if (not pos.m_it.primitive_iterator.is_begin())
+                if (JSON_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
                 {
                     JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
                 }
@@ -10773,7 +10711,7 @@ class basic_json
 
             default:
             {
-                JSON_THROW(type_error::create(307, "cannot use erase() with " + type_name()));
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
             }
         }
 
@@ -10833,7 +10771,7 @@ class basic_json
     IteratorType erase(IteratorType first, IteratorType last)
     {
         // make sure iterator fits the current value
-        if (this != first.m_object or this != last.m_object)
+        if (JSON_UNLIKELY(this != first.m_object or this != last.m_object))
         {
             JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
         }
@@ -10848,7 +10786,8 @@ class basic_json
             case value_t::number_unsigned:
             case value_t::string:
             {
-                if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
+                if (JSON_LIKELY(not first.m_it.primitive_iterator.is_begin()
+                                or not last.m_it.primitive_iterator.is_end()))
                 {
                     JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
                 }
@@ -10882,7 +10821,7 @@ class basic_json
 
             default:
             {
-                JSON_THROW(type_error::create(307, "cannot use erase() with " + type_name()));
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
             }
         }
 
@@ -10921,12 +10860,12 @@ class basic_json
     size_type erase(const typename object_t::key_type& key)
     {
         // this erase only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             return m_value.object->erase(key);
         }
 
-        JSON_THROW(type_error::create(307, "cannot use erase() with " + type_name()));
+        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
     }
 
     /*!
@@ -10956,9 +10895,9 @@ class basic_json
     void erase(const size_type idx)
     {
         // this erase only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
-            if (idx >= size())
+            if (JSON_UNLIKELY(idx >= size()))
             {
                 JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
             }
@@ -10967,7 +10906,7 @@ class basic_json
         }
         else
         {
-            JSON_THROW(type_error::create(307, "cannot use erase() with " + type_name()));
+            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
         }
     }
 
@@ -11681,9 +11620,9 @@ class basic_json
     void push_back(basic_json&& val)
     {
         // push_back only works for null objects or arrays
-        if (not(is_null() or is_array()))
+        if (JSON_UNLIKELY(not(is_null() or is_array())))
         {
-            JSON_THROW(type_error::create(308, "cannot use push_back() with " + type_name()));
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
         }
 
         // transform null object into an array
@@ -11717,9 +11656,9 @@ class basic_json
     void push_back(const basic_json& val)
     {
         // push_back only works for null objects or arrays
-        if (not(is_null() or is_array()))
+        if (JSON_UNLIKELY(not(is_null() or is_array())))
         {
-            JSON_THROW(type_error::create(308, "cannot use push_back() with " + type_name()));
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
         }
 
         // transform null object into an array
@@ -11767,9 +11706,9 @@ class basic_json
     void push_back(const typename object_t::value_type& val)
     {
         // push_back only works for null objects or objects
-        if (not(is_null() or is_object()))
+        if (JSON_UNLIKELY(not(is_null() or is_object())))
         {
-            JSON_THROW(type_error::create(308, "cannot use push_back() with " + type_name()));
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
         }
 
         // transform null object into an object
@@ -11867,9 +11806,9 @@ class basic_json
     void emplace_back(Args&& ... args)
     {
         // emplace_back only works for null objects or arrays
-        if (not(is_null() or is_array()))
+        if (JSON_UNLIKELY(not(is_null() or is_array())))
         {
-            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + type_name()));
+            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
         }
 
         // transform null object into an array
@@ -11915,9 +11854,9 @@ class basic_json
     std::pair<iterator, bool> emplace(Args&& ... args)
     {
         // emplace only works for null objects or arrays
-        if (not(is_null() or is_object()))
+        if (JSON_UNLIKELY(not(is_null() or is_object())))
         {
-            JSON_THROW(type_error::create(311, "cannot use emplace() with " + type_name()));
+            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
         }
 
         // transform null object into an object
@@ -11963,10 +11902,10 @@ class basic_json
     iterator insert(const_iterator pos, const basic_json& val)
     {
         // insert only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
             // check if iterator pos fits to this JSON value
-            if (pos.m_object != this)
+            if (JSON_UNLIKELY(pos.m_object != this))
             {
                 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
             }
@@ -11977,7 +11916,7 @@ class basic_json
             return result;
         }
 
-        JSON_THROW(type_error::create(309, "cannot use insert() with " + type_name()));
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
     }
 
     /*!
@@ -12016,10 +11955,10 @@ class basic_json
     iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
     {
         // insert only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
             // check if iterator pos fits to this JSON value
-            if (pos.m_object != this)
+            if (JSON_UNLIKELY(pos.m_object != this))
             {
                 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
             }
@@ -12030,7 +11969,7 @@ class basic_json
             return result;
         }
 
-        JSON_THROW(type_error::create(309, "cannot use insert() with " + type_name()));
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
     }
 
     /*!
@@ -12066,24 +12005,24 @@ class basic_json
     iterator insert(const_iterator pos, const_iterator first, const_iterator last)
     {
         // insert only works for arrays
-        if (not is_array())
+        if (JSON_UNLIKELY(not is_array()))
         {
-            JSON_THROW(type_error::create(309, "cannot use insert() with " + type_name()));
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
         }
 
         // check if iterator pos fits to this JSON value
-        if (pos.m_object != this)
+        if (JSON_UNLIKELY(pos.m_object != this))
         {
             JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
         }
 
         // check if range iterators belong to the same JSON object
-        if (first.m_object != last.m_object)
+        if (JSON_UNLIKELY(first.m_object != last.m_object))
         {
             JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
         }
 
-        if (first.m_object == this or last.m_object == this)
+        if (JSON_UNLIKELY(first.m_object == this or last.m_object == this))
         {
             JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
         }
@@ -12124,13 +12063,13 @@ class basic_json
     iterator insert(const_iterator pos, std::initializer_list<basic_json> ilist)
     {
         // insert only works for arrays
-        if (not is_array())
+        if (JSON_UNLIKELY(not is_array()))
         {
-            JSON_THROW(type_error::create(309, "cannot use insert() with " + type_name()));
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
         }
 
         // check if iterator pos fits to this JSON value
-        if (pos.m_object != this)
+        if (JSON_UNLIKELY(pos.m_object != this))
         {
             JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
         }
@@ -12167,19 +12106,20 @@ class basic_json
     void insert(const_iterator first, const_iterator last)
     {
         // insert only works for objects
-        if (not is_object())
+        if (JSON_UNLIKELY(not is_object()))
         {
-            JSON_THROW(type_error::create(309, "cannot use insert() with " + type_name()));
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
         }
 
         // check if range iterators belong to the same JSON object
-        if (first.m_object != last.m_object)
+        if (JSON_UNLIKELY(first.m_object != last.m_object))
         {
             JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
         }
 
         // passed iterators must belong to objects
-        if (not first.m_object->is_object() or not first.m_object->is_object())
+        if (JSON_UNLIKELY(not first.m_object->is_object()
+                          or not first.m_object->is_object()))
         {
             JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
         }
@@ -12239,13 +12179,13 @@ class basic_json
     void swap(array_t& other)
     {
         // swap only works for arrays
-        if (is_array())
+        if (JSON_LIKELY(is_array()))
         {
             std::swap(*(m_value.array), other);
         }
         else
         {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + type_name()));
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
         }
     }
 
@@ -12272,13 +12212,13 @@ class basic_json
     void swap(object_t& other)
     {
         // swap only works for objects
-        if (is_object())
+        if (JSON_LIKELY(is_object()))
         {
             std::swap(*(m_value.object), other);
         }
         else
         {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + type_name()));
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
         }
     }
 
@@ -12305,13 +12245,13 @@ class basic_json
     void swap(string_t& other)
     {
         // swap only works for strings
-        if (is_string())
+        if (JSON_LIKELY(is_string()))
         {
             std::swap(*(m_value.string), other);
         }
         else
         {
-            JSON_THROW(type_error::create(310, "cannot use swap() with " + type_name()));
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
         }
     }
 
@@ -12360,11 +12300,11 @@ class basic_json
             {
                 case value_t::array:
                 {
-                    return *lhs.m_value.array == *rhs.m_value.array;
+                    return (*lhs.m_value.array == *rhs.m_value.array);
                 }
                 case value_t::object:
                 {
-                    return *lhs.m_value.object == *rhs.m_value.object;
+                    return (*lhs.m_value.object == *rhs.m_value.object);
                 }
                 case value_t::null:
                 {
@@ -12372,23 +12312,23 @@ class basic_json
                 }
                 case value_t::string:
                 {
-                    return *lhs.m_value.string == *rhs.m_value.string;
+                    return (*lhs.m_value.string == *rhs.m_value.string);
                 }
                 case value_t::boolean:
                 {
-                    return lhs.m_value.boolean == rhs.m_value.boolean;
+                    return (lhs.m_value.boolean == rhs.m_value.boolean);
                 }
                 case value_t::number_integer:
                 {
-                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
+                    return (lhs.m_value.number_integer == rhs.m_value.number_integer);
                 }
                 case value_t::number_unsigned:
                 {
-                    return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
+                    return (lhs.m_value.number_unsigned == rhs.m_value.number_unsigned);
                 }
                 case value_t::number_float:
                 {
-                    return lhs.m_value.number_float == rhs.m_value.number_float;
+                    return (lhs.m_value.number_float == rhs.m_value.number_float);
                 }
                 default:
                 {
@@ -12398,27 +12338,27 @@ class basic_json
         }
         else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
         {
-            return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
+            return (static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float);
         }
         else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
         {
-            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
+            return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer));
         }
         else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
         {
-            return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
+            return (static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float);
         }
         else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
         {
-            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
+            return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned));
         }
         else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
         {
-            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
+            return (static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer);
         }
         else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
         {
-            return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+            return (lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned));
         }
 
         return false;
@@ -13041,9 +12981,9 @@ class basic_json
     @liveexample{The following code exemplifies `type_name()` for all JSON
     types.,type_name}
 
-    @since version 1.0.0, public since 2.1.0
+    @since version 1.0.0, public since 2.1.0, const char* since 3.0.0
     */
-    std::string type_name() const
+    const char* type_name() const
     {
         {
             switch (m_type)
@@ -13804,7 +13744,7 @@ class basic_json
                         else
                         {
                             const auto idx = std::stoi(last_path);
-                            if (static_cast<size_type>(idx) > parent.size())
+                            if (JSON_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
                             {
                                 // avoid undefined behavior
                                 JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
@@ -13839,7 +13779,7 @@ class basic_json
             {
                 // perform range check
                 auto it = parent.find(last_path);
-                if (it != parent.end())
+                if (JSON_LIKELY(it != parent.end()))
                 {
                     parent.erase(it);
                 }
@@ -13856,7 +13796,7 @@ class basic_json
         };
 
         // type check: top level value must be an array
-        if (not json_patch.is_array())
+        if (JSON_UNLIKELY(not json_patch.is_array()))
         {
             JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
         }
@@ -13876,13 +13816,13 @@ class basic_json
                 const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
 
                 // check if desired value is present
-                if (it == val.m_value.object->end())
+                if (JSON_UNLIKELY(it == val.m_value.object->end()))
                 {
                     JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
                 }
 
                 // check if result is of type string
-                if (string_type and not it->second.is_string())
+                if (JSON_UNLIKELY(string_type and not it->second.is_string()))
                 {
                     JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
                 }
@@ -13892,7 +13832,7 @@ class basic_json
             };
 
             // type check: every element of the array must be an object
-            if (not val.is_object())
+            if (JSON_UNLIKELY(not val.is_object()))
             {
                 JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
             }
@@ -13965,7 +13905,7 @@ class basic_json
                     }
 
                     // throw an exception if test fails
-                    if (not success)
+                    if (JSON_UNLIKELY(not success))
                     {
                         JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
                     }
@@ -14017,8 +13957,7 @@ class basic_json
 
     @since version 2.0.0
     */
-    static basic_json diff(const basic_json& source,
-                           const basic_json& target,
+    static basic_json diff(const basic_json& source, const basic_json& target,
                            const std::string& path = "")
     {
         // the patch
@@ -14035,9 +13974,7 @@ class basic_json
             // different types: replace value
             result.push_back(
             {
-                {"op", "replace"},
-                {"path", path},
-                {"value", target}
+                {"op", "replace"}, {"path", path}, {"value", target}
             });
         }
         else
@@ -14107,8 +14044,7 @@ class basic_json
                             // found a key that is not in o -> remove it
                             result.push_back(object(
                             {
-                                {"op", "remove"},
-                                {"path", path + "/" + key}
+                                {"op", "remove"}, {"path", path + "/" + key}
                             }));
                         }
                     }
@@ -14122,8 +14058,7 @@ class basic_json
                             const auto key = json_pointer::escape(it.key());
                             result.push_back(
                             {
-                                {"op", "add"},
-                                {"path", path + "/" + key},
+                                {"op", "add"}, {"path", path + "/" + key},
                                 {"value", it.value()}
                             });
                         }
@@ -14137,9 +14072,7 @@ class basic_json
                     // both primitive type: replace value
                     result.push_back(
                     {
-                        {"op", "replace"},
-                        {"path", path},
-                        {"value", target}
+                        {"op", "replace"}, {"path", path}, {"value", target}
                     });
                     break;
                 }
@@ -14177,8 +14110,8 @@ json_pointer::get_and_create(NLOHMANN_BASIC_JSON_TPL& j) const
     using size_type = typename NLOHMANN_BASIC_JSON_TPL::size_type;
     auto result = &j;
 
-    // in case no reference tokens exist, return a reference to the
-    // JSON value j which will be overwritten by a primitive value
+    // in case no reference tokens exist, return a reference to the JSON value
+    // j which will be overwritten by a primitive value
     for (const auto& reference_token : reference_tokens)
     {
         switch (result->m_type)
@@ -14210,23 +14143,20 @@ json_pointer::get_and_create(NLOHMANN_BASIC_JSON_TPL& j) const
                 // create an entry in the array
                 JSON_TRY
                 {
-                    result = &result->operator[](
-                        static_cast<size_type>(std::stoi(reference_token)));
+                    result = &result->operator[](static_cast<size_type>(std::stoi(reference_token)));
                 }
                 JSON_CATCH(std::invalid_argument&)
                 {
-                    JSON_THROW(detail::parse_error::create(
-                                   109, 0, "array index '" + reference_token + "' is not a number"));
+                    JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                 }
                 break;
             }
 
             /*
-            The following code is only reached if there exists a
-            reference token _and_ the current value is primitive. In
-            this case, we have an error situation, because primitive
-            values may only occur as single value; that is, with an
-            empty list of reference tokens.
+            The following code is only reached if there exists a reference
+            token _and_ the current value is primitive. In this case, we have
+            an error situation, because primitive values may only occur as
+            single value; that is, with an empty list of reference tokens.
             */
             default:
             {
@@ -14256,16 +14186,10 @@ json_pointer::get_unchecked(NLOHMANN_BASIC_JSON_TPL* ptr) const
                 return (x >= '0' and x <= '9');
             });
 
-            // change value to array for numbers or "-" or to object
-            // otherwise
-            if (nums or reference_token == "-")
-            {
-                *ptr = detail::value_t::array;
-            }
-            else
-            {
-                *ptr = detail::value_t::object;
-            }
+            // change value to array for numbers or "-" or to object otherwise
+            *ptr = (nums or reference_token == "-")
+                   ? detail::value_t::array
+                   : detail::value_t::object;
         }
 
         switch (ptr->m_type)
@@ -14280,7 +14204,7 @@ json_pointer::get_unchecked(NLOHMANN_BASIC_JSON_TPL* ptr) const
             case detail::value_t::array:
             {
                 // error condition (cf. RFC 6901, Sect. 4)
-                if (reference_token.size() > 1 and reference_token[0] == '0')
+                if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                 {
                     JSON_THROW(detail::parse_error::create(106, 0,
                                                            "array index '" + reference_token +
@@ -14302,8 +14226,7 @@ json_pointer::get_unchecked(NLOHMANN_BASIC_JSON_TPL* ptr) const
                     }
                     JSON_CATCH(std::invalid_argument&)
                     {
-                        JSON_THROW(detail::parse_error::create(
-                                       109, 0, "array index '" + reference_token + "' is not a number"));
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                     }
                 }
                 break;
@@ -14311,8 +14234,7 @@ json_pointer::get_unchecked(NLOHMANN_BASIC_JSON_TPL* ptr) const
 
             default:
             {
-                JSON_THROW(detail::out_of_range::create(
-                               404, "unresolved reference token '" + reference_token + "'"));
+                JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
             }
         }
     }
@@ -14338,17 +14260,16 @@ json_pointer::get_checked(NLOHMANN_BASIC_JSON_TPL* ptr) const
 
             case detail::value_t::array:
             {
-                if (reference_token == "-")
+                if (JSON_UNLIKELY(reference_token == "-"))
                 {
                     // "-" always fails the range check
-                    JSON_THROW(detail::out_of_range::create(
-                                   402,
-                                   "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                   ") is out of range"));
+                    JSON_THROW(detail::out_of_range::create(402,
+                                                            "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                            ") is out of range"));
                 }
 
                 // error condition (cf. RFC 6901, Sect. 4)
-                if (reference_token.size() > 1 and reference_token[0] == '0')
+                if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                 {
                     JSON_THROW(detail::parse_error::create(106, 0,
                                                            "array index '" + reference_token +
@@ -14362,16 +14283,14 @@ json_pointer::get_checked(NLOHMANN_BASIC_JSON_TPL* ptr) const
                 }
                 JSON_CATCH(std::invalid_argument&)
                 {
-                    JSON_THROW(detail::parse_error::create(
-                                   109, 0, "array index '" + reference_token + "' is not a number"));
+                    JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                 }
                 break;
             }
 
             default:
             {
-                JSON_THROW(detail::out_of_range::create(
-                               404, "unresolved reference token '" + reference_token + "'"));
+                JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
             }
         }
     }
@@ -14397,17 +14316,16 @@ json_pointer::get_unchecked(const NLOHMANN_BASIC_JSON_TPL* ptr) const
 
             case detail::value_t::array:
             {
-                if (reference_token == "-")
+                if (JSON_UNLIKELY(reference_token == "-"))
                 {
                     // "-" cannot be used for const access
-                    JSON_THROW(detail::out_of_range::create(
-                                   402,
-                                   "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                   ") is out of range"));
+                    JSON_THROW(detail::out_of_range::create(402,
+                                                            "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                            ") is out of range"));
                 }
 
                 // error condition (cf. RFC 6901, Sect. 4)
-                if (reference_token.size() > 1 and reference_token[0] == '0')
+                if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                 {
                     JSON_THROW(detail::parse_error::create(106, 0,
                                                            "array index '" + reference_token +
@@ -14422,16 +14340,14 @@ json_pointer::get_unchecked(const NLOHMANN_BASIC_JSON_TPL* ptr) const
                 }
                 JSON_CATCH(std::invalid_argument&)
                 {
-                    JSON_THROW(detail::parse_error::create(
-                                   109, 0, "array index '" + reference_token + "' is not a number"));
+                    JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                 }
                 break;
             }
 
             default:
             {
-                JSON_THROW(detail::out_of_range::create(
-                               404, "unresolved reference token '" + reference_token + "'"));
+                JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
             }
         }
     }
@@ -14457,17 +14373,16 @@ json_pointer::get_checked(const NLOHMANN_BASIC_JSON_TPL* ptr) const
 
             case detail::value_t::array:
             {
-                if (reference_token == "-")
+                if (JSON_UNLIKELY(reference_token == "-"))
                 {
                     // "-" always fails the range check
-                    JSON_THROW(detail::out_of_range::create(
-                                   402,
-                                   "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                   ") is out of range"));
+                    JSON_THROW(detail::out_of_range::create(402,
+                                                            "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                            ") is out of range"));
                 }
 
                 // error condition (cf. RFC 6901, Sect. 4)
-                if (reference_token.size() > 1 and reference_token[0] == '0')
+                if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                 {
                     JSON_THROW(detail::parse_error::create(106, 0,
                                                            "array index '" + reference_token +
@@ -14481,16 +14396,14 @@ json_pointer::get_checked(const NLOHMANN_BASIC_JSON_TPL* ptr) const
                 }
                 JSON_CATCH(std::invalid_argument&)
                 {
-                    JSON_THROW(detail::parse_error::create(
-                                   109, 0, "array index '" + reference_token + "' is not a number"));
+                    JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                 }
                 break;
             }
 
             default:
             {
-                JSON_THROW(detail::out_of_range::create(
-                               404, "unresolved reference token '" + reference_token + "'"));
+                JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
             }
         }
     }
@@ -14536,8 +14449,7 @@ void json_pointer::flatten(const std::string& reference_string,
                 // iterate object and use keys as reference string
                 for (const auto& element : *value.m_value.object)
                 {
-                    flatten(reference_string + "/" + escape(element.first), element.second,
-                            result);
+                    flatten(reference_string + "/" + escape(element.first), element.second, result);
                 }
             }
             break;
@@ -14556,7 +14468,7 @@ NLOHMANN_BASIC_JSON_TPL_DECLARATION
 NLOHMANN_BASIC_JSON_TPL
 json_pointer::unflatten(const NLOHMANN_BASIC_JSON_TPL& value)
 {
-    if (not value.is_object())
+    if (JSON_UNLIKELY(not value.is_object()))
     {
         JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
     }
@@ -14566,16 +14478,15 @@ json_pointer::unflatten(const NLOHMANN_BASIC_JSON_TPL& value)
     // iterate the JSON object values
     for (const auto& element : *value.m_value.object)
     {
-        if (not element.second.is_primitive())
+        if (JSON_UNLIKELY(not element.second.is_primitive()))
         {
             JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
         }
 
-        // assign value to reference pointed to by JSON pointer; Note
-        // that if the JSON pointer is "" (i.e., points to the whole
-        // value), function get_and_create returns a reference to
-        // result itself. An assignment will then create a primitive
-        // value.
+        // assign value to reference pointed to by JSON pointer; Note that if
+        // the JSON pointer is "" (i.e., points to the whole value), function
+        // get_and_create returns a reference to result itself. An assignment
+        // will then create a primitive value.
         json_pointer(element.first).get_and_create(result) = element.second;
     }
 
@@ -14584,12 +14495,12 @@ json_pointer::unflatten(const NLOHMANN_BASIC_JSON_TPL& value)
 
 inline bool operator==(json_pointer const& lhs, json_pointer const& rhs) noexcept
 {
-    return lhs.reference_tokens == rhs.reference_tokens;
+    return (lhs.reference_tokens == rhs.reference_tokens);
 }
 
 inline bool operator!=(json_pointer const& lhs, json_pointer const& rhs) noexcept
 {
-    return !(lhs == rhs);
+    return not (lhs == rhs);
 }
 } // namespace nlohmann
 
@@ -14634,7 +14545,7 @@ struct hash<nlohmann::json>
 };
 
 /// specialization for std::less<value_t>
-template <>
+template<>
 struct less<::nlohmann::detail::value_t>
 {
     /*!