Modernize integer comparison (#4577)

codenut · web-flow · commit 4f64d8d0b4f3 · 2025-01-01T17:01:38.000+01:00
Replace static_cast&lt;size_t&gt;(-1) with std::numeric_limits&lt;std::size_t&gt;::max()
via the detail::unknown_size() function
diff --git a/include/nlohmann/detail/input/binary_reader.hpp b/include/nlohmann/detail/input/binary_reader.hpp
@@ -172,7 +172,7 @@ class binary_reader
         std::int32_t document_size{};
         get_number<std::int32_t, true>(input_format_t::bson, document_size);
 
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
         {
             return false;
         }
@@ -394,7 +394,7 @@ class binary_reader
         std::int32_t document_size{};
         get_number<std::int32_t, true>(input_format_t::bson, document_size);
 
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
         {
             return false;
         }
@@ -654,7 +654,7 @@ class binary_reader
             }
 
             case 0x9F: // array (indefinite length)
-                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
+                return get_cbor_array(detail::unknown_size(), tag_handler);
 
             // map (0x00..0x17 pairs of data items follow)
             case 0xA0:
@@ -708,7 +708,7 @@ class binary_reader
             }
 
             case 0xBF: // map (indefinite length)
-                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
+                return get_cbor_object(detail::unknown_size(), tag_handler);
 
             case 0xC6: // tagged item
             case 0xC7:
@@ -1096,7 +1096,7 @@ class binary_reader
     }
 
     /*!
-    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
+    @param[in] len  the length of the array or detail::unknown_size() for an
                     array of indefinite size
     @param[in] tag_handler how CBOR tags should be treated
     @return whether array creation completed
@@ -1109,7 +1109,7 @@ class binary_reader
             return false;
         }
 
-        if (len != static_cast<std::size_t>(-1))
+        if (len != detail::unknown_size())
         {
             for (std::size_t i = 0; i < len; ++i)
             {
@@ -1134,7 +1134,7 @@ class binary_reader
     }
 
     /*!
-    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
+    @param[in] len  the length of the object or detail::unknown_size() for an
                     object of indefinite size
     @param[in] tag_handler how CBOR tags should be treated
     @return whether object creation completed
@@ -1150,7 +1150,7 @@ class binary_reader
         if (len != 0)
         {
             string_t key;
-            if (len != static_cast<std::size_t>(-1))
+            if (len != detail::unknown_size())
             {
                 for (std::size_t i = 0; i < len; ++i)
                 {
@@ -2568,7 +2568,7 @@ class binary_reader
         }
         else
         {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
             {
                 return false;
             }
@@ -2646,7 +2646,7 @@ class binary_reader
         }
         else
         {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
             {
                 return false;
             }
@@ -2982,7 +2982,7 @@ class binary_reader
     }
 
   private:
-    static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);
+    static JSON_INLINE_VARIABLE constexpr std::size_t npos = detail::unknown_size();
 
     /// input adapter
     InputAdapterType ia;
diff --git a/include/nlohmann/detail/input/json_sax.hpp b/include/nlohmann/detail/input/json_sax.hpp
@@ -145,6 +145,11 @@ struct json_sax
 
 namespace detail
 {
+constexpr std::size_t unknown_size()
+{
+    return (std::numeric_limits<std::size_t>::max)();
+}
+
 /*!
 @brief SAX implementation to create a JSON value from SAX events
 
@@ -242,7 +247,7 @@ class json_sax_dom_parser
         }
 #endif
 
-        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
         {
             JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
         }
@@ -291,7 +296,7 @@ class json_sax_dom_parser
         }
 #endif
 
-        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
         {
             JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
         }
@@ -559,7 +564,7 @@ class json_sax_dom_callback_parser
 #endif
 
             // check object limit
-            if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
             {
                 JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
             }
@@ -657,7 +662,7 @@ class json_sax_dom_callback_parser
 #endif
 
             // check array limit
-            if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
             {
                 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
             }
@@ -946,7 +951,7 @@ class json_sax_acceptor
         return true;
     }
 
-    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    bool start_object(std::size_t /*unused*/ = detail::unknown_size())
     {
         return true;
     }
@@ -961,7 +966,7 @@ class json_sax_acceptor
         return true;
     }
 
-    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    bool start_array(std::size_t /*unused*/ = detail::unknown_size())
     {
         return true;
     }
diff --git a/include/nlohmann/detail/input/parser.hpp b/include/nlohmann/detail/input/parser.hpp
@@ -194,7 +194,7 @@ class parser
                 {
                     case token_type::begin_object:
                     {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
                         {
                             return false;
                         }
@@ -239,7 +239,7 @@ class parser
 
                     case token_type::begin_array:
                     {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
                         {
                             return false;
                         }
diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp
@@ -751,10 +751,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return it;
     }
 
-    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
+    reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())
     {
 #if JSON_DIAGNOSTICS
-        if (old_capacity != static_cast<std::size_t>(-1))
+        if (old_capacity != detail::unknown_size())
         {
             // see https://github.com/nlohmann/json/issues/2838
             JSON_ASSERT(type() == value_t::array);
diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp
@@ -8677,6 +8677,11 @@ struct json_sax
 
 namespace detail
 {
+constexpr std::size_t unknown_size()
+{
+    return (std::numeric_limits<std::size_t>::max)();
+}
+
 /*!
 @brief SAX implementation to create a JSON value from SAX events
 
@@ -8774,7 +8779,7 @@ class json_sax_dom_parser
         }
 #endif
 
-        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
         {
             JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
         }
@@ -8823,7 +8828,7 @@ class json_sax_dom_parser
         }
 #endif
 
-        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
         {
             JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
         }
@@ -9091,7 +9096,7 @@ class json_sax_dom_callback_parser
 #endif
 
             // check object limit
-            if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
             {
                 JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
             }
@@ -9189,7 +9194,7 @@ class json_sax_dom_callback_parser
 #endif
 
             // check array limit
-            if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
             {
                 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
             }
@@ -9478,7 +9483,7 @@ class json_sax_acceptor
         return true;
     }
 
-    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    bool start_object(std::size_t /*unused*/ = detail::unknown_size())
     {
         return true;
     }
@@ -9493,7 +9498,7 @@ class json_sax_acceptor
         return true;
     }
 
-    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    bool start_array(std::size_t /*unused*/ = detail::unknown_size())
     {
         return true;
     }
@@ -9825,7 +9830,7 @@ class binary_reader
         std::int32_t document_size{};
         get_number<std::int32_t, true>(input_format_t::bson, document_size);
 
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
         {
             return false;
         }
@@ -10047,7 +10052,7 @@ class binary_reader
         std::int32_t document_size{};
         get_number<std::int32_t, true>(input_format_t::bson, document_size);
 
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
         {
             return false;
         }
@@ -10307,7 +10312,7 @@ class binary_reader
             }
 
             case 0x9F: // array (indefinite length)
-                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
+                return get_cbor_array(detail::unknown_size(), tag_handler);
 
             // map (0x00..0x17 pairs of data items follow)
             case 0xA0:
@@ -10361,7 +10366,7 @@ class binary_reader
             }
 
             case 0xBF: // map (indefinite length)
-                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
+                return get_cbor_object(detail::unknown_size(), tag_handler);
 
             case 0xC6: // tagged item
             case 0xC7:
@@ -10749,7 +10754,7 @@ class binary_reader
     }
 
     /*!
-    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
+    @param[in] len  the length of the array or detail::unknown_size() for an
                     array of indefinite size
     @param[in] tag_handler how CBOR tags should be treated
     @return whether array creation completed
@@ -10762,7 +10767,7 @@ class binary_reader
             return false;
         }
 
-        if (len != static_cast<std::size_t>(-1))
+        if (len != detail::unknown_size())
         {
             for (std::size_t i = 0; i < len; ++i)
             {
@@ -10787,7 +10792,7 @@ class binary_reader
     }
 
     /*!
-    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
+    @param[in] len  the length of the object or detail::unknown_size() for an
                     object of indefinite size
     @param[in] tag_handler how CBOR tags should be treated
     @return whether object creation completed
@@ -10803,7 +10808,7 @@ class binary_reader
         if (len != 0)
         {
             string_t key;
-            if (len != static_cast<std::size_t>(-1))
+            if (len != detail::unknown_size())
             {
                 for (std::size_t i = 0; i < len; ++i)
                 {
@@ -12221,7 +12226,7 @@ class binary_reader
         }
         else
         {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
             {
                 return false;
             }
@@ -12299,7 +12304,7 @@ class binary_reader
         }
         else
         {
-            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
             {
                 return false;
             }
@@ -12635,7 +12640,7 @@ class binary_reader
     }
 
   private:
-    static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);
+    static JSON_INLINE_VARIABLE constexpr std::size_t npos = detail::unknown_size();
 
     /// input adapter
     InputAdapterType ia;
@@ -12905,7 +12910,7 @@ class parser
                 {
                     case token_type::begin_object:
                     {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
                         {
                             return false;
                         }
@@ -12950,7 +12955,7 @@ class parser
 
                     case token_type::begin_array:
                     {
-                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
                         {
                             return false;
                         }
@@ -20606,10 +20611,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         return it;
     }
 
-    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
+    reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())
     {
 #if JSON_DIAGNOSTICS
-        if (old_capacity != static_cast<std::size_t>(-1))
+        if (old_capacity != detail::unknown_size())
         {
             // see https://github.com/nlohmann/json/issues/2838
             JSON_ASSERT(type() == value_t::array);

Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ class binary_reader`
`172`	`172`	`std::int32_t document_size{};`
`173`	`173`	`get_number<std::int32_t, true>(input_format_t::bson, document_size);`
`174`	`174`
`175`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))`
	`175`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))`
`176`	`176`	`{`
`177`	`177`	`return false;`
`178`	`178`	`}`
`@@ -394,7 +394,7 @@ class binary_reader`
`394`	`394`	`std::int32_t document_size{};`
`395`	`395`	`get_number<std::int32_t, true>(input_format_t::bson, document_size);`
`396`	`396`
`397`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))`
	`397`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))`
`398`	`398`	`{`
`399`	`399`	`return false;`
`400`	`400`	`}`
`@@ -654,7 +654,7 @@ class binary_reader`
`654`	`654`	`}`
`655`	`655`
`656`	`656`	`case 0x9F: // array (indefinite length)`
`657`		`- return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);`
	`657`	`+ return get_cbor_array(detail::unknown_size(), tag_handler);`
`658`	`658`
`659`	`659`	`// map (0x00..0x17 pairs of data items follow)`
`660`	`660`	`case 0xA0:`
`@@ -708,7 +708,7 @@ class binary_reader`
`708`	`708`	`}`
`709`	`709`
`710`	`710`	`case 0xBF: // map (indefinite length)`
`711`		`- return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);`
	`711`	`+ return get_cbor_object(detail::unknown_size(), tag_handler);`
`712`	`712`
`713`	`713`	`case 0xC6: // tagged item`
`714`	`714`	`case 0xC7:`
`@@ -1096,7 +1096,7 @@ class binary_reader`
`1096`	`1096`	`}`
`1097`	`1097`
`1098`	`1098`	`/*!`
`1099`		`- @param[in] len the length of the array or static_cast<std::size_t>(-1) for an`
	`1099`	`+ @param[in] len the length of the array or detail::unknown_size() for an`
`1100`	`1100`	`array of indefinite size`
`1101`	`1101`	`@param[in] tag_handler how CBOR tags should be treated`
`1102`	`1102`	`@return whether array creation completed`
`@@ -1109,7 +1109,7 @@ class binary_reader`
`1109`	`1109`	`return false;`
`1110`	`1110`	`}`
`1111`	`1111`
`1112`		`- if (len != static_cast<std::size_t>(-1))`
	`1112`	`+ if (len != detail::unknown_size())`
`1113`	`1113`	`{`
`1114`	`1114`	`for (std::size_t i = 0; i < len; ++i)`
`1115`	`1115`	`{`
`@@ -1134,7 +1134,7 @@ class binary_reader`
`1134`	`1134`	`}`
`1135`	`1135`
`1136`	`1136`	`/*!`
`1137`		`- @param[in] len the length of the object or static_cast<std::size_t>(-1) for an`
	`1137`	`+ @param[in] len the length of the object or detail::unknown_size() for an`
`1138`	`1138`	`object of indefinite size`
`1139`	`1139`	`@param[in] tag_handler how CBOR tags should be treated`
`1140`	`1140`	`@return whether object creation completed`
`@@ -1150,7 +1150,7 @@ class binary_reader`
`1150`	`1150`	`if (len != 0)`
`1151`	`1151`	`{`
`1152`	`1152`	`string_t key;`
`1153`		`- if (len != static_cast<std::size_t>(-1))`
	`1153`	`+ if (len != detail::unknown_size())`
`1154`	`1154`	`{`
`1155`	`1155`	`for (std::size_t i = 0; i < len; ++i)`
`1156`	`1156`	`{`
`@@ -2568,7 +2568,7 @@ class binary_reader`
`2568`	`2568`	`}`
`2569`	`2569`	`else`
`2570`	`2570`	`{`
`2571`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))`
	`2571`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))`
`2572`	`2572`	`{`
`2573`	`2573`	`return false;`
`2574`	`2574`	`}`
`@@ -2646,7 +2646,7 @@ class binary_reader`
`2646`	`2646`	`}`
`2647`	`2647`	`else`
`2648`	`2648`	`{`
`2649`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))`
	`2649`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))`
`2650`	`2650`	`{`
`2651`	`2651`	`return false;`
`2652`	`2652`	`}`
`@@ -2982,7 +2982,7 @@ class binary_reader`
`2982`	`2982`	`}`
`2983`	`2983`
`2984`	`2984`	`private:`
`2985`		`- static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);`
	`2985`	`+ static JSON_INLINE_VARIABLE constexpr std::size_t npos = detail::unknown_size();`
`2986`	`2986`
`2987`	`2987`	`/// input adapter`
`2988`	`2988`	`InputAdapterType ia;`
Original file line number	Diff line number	Diff line change
`@@ -145,6 +145,11 @@ struct json_sax`
`145`	`145`
`146`	`146`	`namespace detail`
`147`	`147`	`{`
	`148`	`+constexpr std::size_t unknown_size()`
	`149`	`+{`
	`150`	`+ return (std::numeric_limits<std::size_t>::max)();`
	`151`	`+}`
	`152`	`+`
`148`	`153`	`/*!`
`149`	`154`	`@brief SAX implementation to create a JSON value from SAX events`
`150`	`155`
`@@ -242,7 +247,7 @@ class json_sax_dom_parser`
`242`	`247`	`}`
`243`	`248`	`#endif`
`244`	`249`
`245`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`250`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`246`	`251`	`{`
`247`	`252`	`JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));`
`248`	`253`	`}`
`@@ -291,7 +296,7 @@ class json_sax_dom_parser`
`291`	`296`	`}`
`292`	`297`	`#endif`
`293`	`298`
`294`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`299`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`295`	`300`	`{`
`296`	`301`	`JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));`
`297`	`302`	`}`
`@@ -559,7 +564,7 @@ class json_sax_dom_callback_parser`
`559`	`564`	`#endif`
`560`	`565`
`561`	`566`	`// check object limit`
`562`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`567`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`563`	`568`	`{`
`564`	`569`	`JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));`
`565`	`570`	`}`
`@@ -657,7 +662,7 @@ class json_sax_dom_callback_parser`
`657`	`662`	`#endif`
`658`	`663`
`659`	`664`	`// check array limit`
`660`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`665`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`661`	`666`	`{`
`662`	`667`	`JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));`
`663`	`668`	`}`
`@@ -946,7 +951,7 @@ class json_sax_acceptor`
`946`	`951`	`return true;`
`947`	`952`	`}`
`948`	`953`
`949`		`- bool start_object(std::size_t /unused/ = static_cast<std::size_t>(-1))`
	`954`	`+ bool start_object(std::size_t /unused/ = detail::unknown_size())`
`950`	`955`	`{`
`951`	`956`	`return true;`
`952`	`957`	`}`
`@@ -961,7 +966,7 @@ class json_sax_acceptor`
`961`	`966`	`return true;`
`962`	`967`	`}`
`963`	`968`
`964`		`- bool start_array(std::size_t /unused/ = static_cast<std::size_t>(-1))`
	`969`	`+ bool start_array(std::size_t /unused/ = detail::unknown_size())`
`965`	`970`	`{`
`966`	`971`	`return true;`
`967`	`972`	`}`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ class parser`
`194`	`194`	`{`
`195`	`195`	`case token_type::begin_object:`
`196`	`196`	`{`
`197`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))`
	`197`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))`
`198`	`198`	`{`
`199`	`199`	`return false;`
`200`	`200`	`}`
`@@ -239,7 +239,7 @@ class parser`
`239`	`239`
`240`	`240`	`case token_type::begin_array:`
`241`	`241`	`{`
`242`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))`
	`242`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))`
`243`	`243`	`{`
`244`	`244`	`return false;`
`245`	`245`	`}`
Original file line number	Diff line number	Diff line change
`@@ -751,10 +751,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec`
`751`	`751`	`return it;`
`752`	`752`	`}`
`753`	`753`
`754`		`- reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))`
	`754`	`+ reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())`
`755`	`755`	`{`
`756`	`756`	`#if JSON_DIAGNOSTICS`
`757`		`- if (old_capacity != static_cast<std::size_t>(-1))`
	`757`	`+ if (old_capacity != detail::unknown_size())`
`758`	`758`	`{`
`759`	`759`	`// see https://github.com/nlohmann/json/issues/2838`
`760`	`760`	`JSON_ASSERT(type() == value_t::array);`
Original file line number	Diff line number	Diff line change
`@@ -8677,6 +8677,11 @@ struct json_sax`
`8677`	`8677`
`8678`	`8678`	`namespace detail`
`8679`	`8679`	`{`
	`8680`	`+constexpr std::size_t unknown_size()`
	`8681`	`+{`
	`8682`	`+ return (std::numeric_limits<std::size_t>::max)();`
	`8683`	`+}`
	`8684`	`+`
`8680`	`8685`	`/*!`
`8681`	`8686`	`@brief SAX implementation to create a JSON value from SAX events`
`8682`	`8687`
`@@ -8774,7 +8779,7 @@ class json_sax_dom_parser`
`8774`	`8779`	`}`
`8775`	`8780`	`#endif`
`8776`	`8781`
`8777`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`8782`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`8778`	`8783`	`{`
`8779`	`8784`	`JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));`
`8780`	`8785`	`}`
`@@ -8823,7 +8828,7 @@ class json_sax_dom_parser`
`8823`	`8828`	`}`
`8824`	`8829`	`#endif`
`8825`	`8830`
`8826`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`8831`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`8827`	`8832`	`{`
`8828`	`8833`	`JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));`
`8829`	`8834`	`}`
`@@ -9091,7 +9096,7 @@ class json_sax_dom_callback_parser`
`9091`	`9096`	`#endif`
`9092`	`9097`
`9093`	`9098`	`// check object limit`
`9094`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`9099`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`9095`	`9100`	`{`
`9096`	`9101`	`JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));`
`9097`	`9102`	`}`
`@@ -9189,7 +9194,7 @@ class json_sax_dom_callback_parser`
`9189`	`9194`	`#endif`
`9190`	`9195`
`9191`	`9196`	`// check array limit`
`9192`		`- if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))`
	`9197`	`+ if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))`
`9193`	`9198`	`{`
`9194`	`9199`	`JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));`
`9195`	`9200`	`}`
`@@ -9478,7 +9483,7 @@ class json_sax_acceptor`
`9478`	`9483`	`return true;`
`9479`	`9484`	`}`
`9480`	`9485`
`9481`		`- bool start_object(std::size_t /unused/ = static_cast<std::size_t>(-1))`
	`9486`	`+ bool start_object(std::size_t /unused/ = detail::unknown_size())`
`9482`	`9487`	`{`
`9483`	`9488`	`return true;`
`9484`	`9489`	`}`
`@@ -9493,7 +9498,7 @@ class json_sax_acceptor`
`9493`	`9498`	`return true;`
`9494`	`9499`	`}`
`9495`	`9500`
`9496`		`- bool start_array(std::size_t /unused/ = static_cast<std::size_t>(-1))`
	`9501`	`+ bool start_array(std::size_t /unused/ = detail::unknown_size())`
`9497`	`9502`	`{`
`9498`	`9503`	`return true;`
`9499`	`9504`	`}`
`@@ -9825,7 +9830,7 @@ class binary_reader`
`9825`	`9830`	`std::int32_t document_size{};`
`9826`	`9831`	`get_number<std::int32_t, true>(input_format_t::bson, document_size);`
`9827`	`9832`
`9828`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))`
	`9833`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))`
`9829`	`9834`	`{`
`9830`	`9835`	`return false;`
`9831`	`9836`	`}`
`@@ -10047,7 +10052,7 @@ class binary_reader`
`10047`	`10052`	`std::int32_t document_size{};`
`10048`	`10053`	`get_number<std::int32_t, true>(input_format_t::bson, document_size);`
`10049`	`10054`
`10050`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))`
	`10055`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))`
`10051`	`10056`	`{`
`10052`	`10057`	`return false;`
`10053`	`10058`	`}`
`@@ -10307,7 +10312,7 @@ class binary_reader`
`10307`	`10312`	`}`
`10308`	`10313`
`10309`	`10314`	`case 0x9F: // array (indefinite length)`
`10310`		`- return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);`
	`10315`	`+ return get_cbor_array(detail::unknown_size(), tag_handler);`
`10311`	`10316`
`10312`	`10317`	`// map (0x00..0x17 pairs of data items follow)`
`10313`	`10318`	`case 0xA0:`
`@@ -10361,7 +10366,7 @@ class binary_reader`
`10361`	`10366`	`}`
`10362`	`10367`
`10363`	`10368`	`case 0xBF: // map (indefinite length)`
`10364`		`- return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);`
	`10369`	`+ return get_cbor_object(detail::unknown_size(), tag_handler);`
`10365`	`10370`
`10366`	`10371`	`case 0xC6: // tagged item`
`10367`	`10372`	`case 0xC7:`
`@@ -10749,7 +10754,7 @@ class binary_reader`
`10749`	`10754`	`}`
`10750`	`10755`
`10751`	`10756`	`/*!`
`10752`		`- @param[in] len the length of the array or static_cast<std::size_t>(-1) for an`
	`10757`	`+ @param[in] len the length of the array or detail::unknown_size() for an`
`10753`	`10758`	`array of indefinite size`
`10754`	`10759`	`@param[in] tag_handler how CBOR tags should be treated`
`10755`	`10760`	`@return whether array creation completed`
`@@ -10762,7 +10767,7 @@ class binary_reader`
`10762`	`10767`	`return false;`
`10763`	`10768`	`}`
`10764`	`10769`
`10765`		`- if (len != static_cast<std::size_t>(-1))`
	`10770`	`+ if (len != detail::unknown_size())`
`10766`	`10771`	`{`
`10767`	`10772`	`for (std::size_t i = 0; i < len; ++i)`
`10768`	`10773`	`{`
`@@ -10787,7 +10792,7 @@ class binary_reader`
`10787`	`10792`	`}`
`10788`	`10793`
`10789`	`10794`	`/*!`
`10790`		`- @param[in] len the length of the object or static_cast<std::size_t>(-1) for an`
	`10795`	`+ @param[in] len the length of the object or detail::unknown_size() for an`
`10791`	`10796`	`object of indefinite size`
`10792`	`10797`	`@param[in] tag_handler how CBOR tags should be treated`
`10793`	`10798`	`@return whether object creation completed`
`@@ -10803,7 +10808,7 @@ class binary_reader`
`10803`	`10808`	`if (len != 0)`
`10804`	`10809`	`{`
`10805`	`10810`	`string_t key;`
`10806`		`- if (len != static_cast<std::size_t>(-1))`
	`10811`	`+ if (len != detail::unknown_size())`
`10807`	`10812`	`{`
`10808`	`10813`	`for (std::size_t i = 0; i < len; ++i)`
`10809`	`10814`	`{`
`@@ -12221,7 +12226,7 @@ class binary_reader`
`12221`	`12226`	`}`
`12222`	`12227`	`else`
`12223`	`12228`	`{`
`12224`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))`
	`12229`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))`
`12225`	`12230`	`{`
`12226`	`12231`	`return false;`
`12227`	`12232`	`}`
`@@ -12299,7 +12304,7 @@ class binary_reader`
`12299`	`12304`	`}`
`12300`	`12305`	`else`
`12301`	`12306`	`{`
`12302`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))`
	`12307`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))`
`12303`	`12308`	`{`
`12304`	`12309`	`return false;`
`12305`	`12310`	`}`
`@@ -12635,7 +12640,7 @@ class binary_reader`
`12635`	`12640`	`}`
`12636`	`12641`
`12637`	`12642`	`private:`
`12638`		`- static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);`
	`12643`	`+ static JSON_INLINE_VARIABLE constexpr std::size_t npos = detail::unknown_size();`
`12639`	`12644`
`12640`	`12645`	`/// input adapter`
`12641`	`12646`	`InputAdapterType ia;`
`@@ -12905,7 +12910,7 @@ class parser`
`12905`	`12910`	`{`
`12906`	`12911`	`case token_type::begin_object:`
`12907`	`12912`	`{`
`12908`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))`
	`12913`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))`
`12909`	`12914`	`{`
`12910`	`12915`	`return false;`
`12911`	`12916`	`}`
`@@ -12950,7 +12955,7 @@ class parser`
`12950`	`12955`
`12951`	`12956`	`case token_type::begin_array:`
`12952`	`12957`	`{`
`12953`		`- if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))`
	`12958`	`+ if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))`
`12954`	`12959`	`{`
`12955`	`12960`	`return false;`
`12956`	`12961`	`}`
`@@ -20606,10 +20611,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec`
`20606`	`20611`	`return it;`
`20607`	`20612`	`}`
`20608`	`20613`
`20609`		`- reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))`
	`20614`	`+ reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())`
`20610`	`20615`	`{`
`20611`	`20616`	`#if JSON_DIAGNOSTICS`
`20612`		`- if (old_capacity != static_cast<std::size_t>(-1))`
	`20617`	`+ if (old_capacity != detail::unknown_size())`
`20613`	`20618`	`{`
`20614`	`20619`	`// see https://github.com/nlohmann/json/issues/2838`
`20615`	`20620`	`JSON_ASSERT(type() == value_t::array);`