Look up the key only once in the callback parser's key()

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

include/nlohmann/detail/conversions/zmij.hpp

@@ -184,10 +184,7 @@ JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexc
     const uint128_parts p10 = pow10(-dec_exp - 1);
     const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast<unsigned>(shift));
     std::uint64_t integral = p.high >> static_cast<unsigned>(extra_shift);
-    // (no casts in the shifts: MSVC 2015 warns C4554 on them despite the parentheses)
-    constexpr unsigned fractional_low_shift = static_cast<unsigned>(extra_shift);
-    constexpr unsigned fractional_high_shift = 64u - fractional_low_shift;
-    const std::uint64_t fractional = (p.high << fractional_high_shift) | (p.low >> fractional_low_shift);
+    const std::uint64_t fractional = (p.high << static_cast<unsigned>(64 - extra_shift)) | (p.low >> static_cast<unsigned>(extra_shift));
     std::uint64_t digit = 0;
     bool round_up = false;
     bool round_down = false;

include/nlohmann/detail/input/json_sax.hpp

@@ -674,16 +674,19 @@ class json_sax_dom_callback_parser
         if (keep && ref_stack.back())
         {
             auto& obj = *ref_stack.back()->m_data.m_value.object;
-            const auto it = obj.find(val);
-            if (it != obj.end())
+            // a single lookup: insert the placeholder, or find the existing member
+            const auto inserted = obj.emplace(val, discarded);
+            const auto it = inserted.first;
+            if (!inserted.second)
             {
                 // this is a duplicate key (legal in JSON); remember its
                 // current value so it can be restored later if the new
                 // value is rejected by the callback, instead of being
                 // erased together with the discarded placeholder
                 duplicate_key_stash.emplace_back(&(it->second), it->second);
+                it->second = discarded;
             }
-            object_element = &(obj[val] = discarded);
+            object_element = &(it->second);
         }
 
         return true;

single_include/nlohmann/json.hpp

@@ -13850,16 +13850,19 @@ class json_sax_dom_callback_parser
         if (keep && ref_stack.back())
         {
             auto& obj = *ref_stack.back()->m_data.m_value.object;
-            const auto it = obj.find(val);
-            if (it != obj.end())
+            // a single lookup: insert the placeholder, or find the existing member
+            const auto inserted = obj.emplace(val, discarded);
+            const auto it = inserted.first;
+            if (!inserted.second)
             {
                 // this is a duplicate key (legal in JSON); remember its
                 // current value so it can be restored later if the new
                 // value is rejected by the callback, instead of being
                 // erased together with the discarded placeholder
                 duplicate_key_stash.emplace_back(&(it->second), it->second);
+                it->second = discarded;
             }
-            object_element = &(obj[val] = discarded);
+            object_element = &(it->second);
         }
 
         return true;
@@ -25874,10 +25877,7 @@ JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexc
     const uint128_parts p10 = pow10(-dec_exp - 1);
     const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast<unsigned>(shift));
     std::uint64_t integral = p.high >> static_cast<unsigned>(extra_shift);
-    // (no casts in the shifts: MSVC 2015 warns C4554 on them despite the parentheses)
-    constexpr unsigned fractional_low_shift = static_cast<unsigned>(extra_shift);
-    constexpr unsigned fractional_high_shift = 64u - fractional_low_shift;
-    const std::uint64_t fractional = (p.high << fractional_high_shift) | (p.low >> fractional_low_shift);
+    const std::uint64_t fractional = (p.high << static_cast<unsigned>(64 - extra_shift)) | (p.low >> static_cast<unsigned>(extra_shift));
     std::uint64_t digit = 0;
     bool round_up = false;
     bool round_down = false;

tests/src/unit-to_chars.cpp

@@ -21,8 +21,11 @@ using nlohmann::detail::dtoa_impl::reinterpret_bits;
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <iomanip>
 #include <limits>
+#include <locale>
 #include <random>
+#include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -686,13 +689,20 @@ void check_shortest(double v)
     const std::string& digits = de.first;
     if (digits.size() > 1)
     {
-        // the decimals of one digit fewer next to the value: v lies within
-        // half a unit of the last digit of text, so the closest ones are the
-        // truncated digits and their successor
-        // (not a stream with std::setprecision(digits.size() - 2): the
-        // standard library of MSVC 2017 ignores a precision of 0)
-        const std::string m = digits.substr(0, digits.size() - 1);
-        const int e = de.second + 1;
+        // the decimals of one digit fewer next to the value
+        // (a stream rather than snprintf("%.*e"), whose output GCC cannot bound)
+        std::ostringstream shorter;
+        shorter.imbue(std::locale::classic());
+        shorter << std::scientific << std::setprecision(static_cast<int>(digits.size()) - 2) << v;
+        const auto near = digits_and_exponent(shorter.str());
+        // as an integer with digits.size() - 1 digits
+        std::string m = near.first;
+        int e = near.second;
+        while (m.size() < digits.size() - 1)
+        {
+            m += '0';
+            --e;
+        }
         const std::uint64_t mid = std::stoull(m);
         for (const std::uint64_t candidate :
                 {