diff --git a/include/nlohmann/detail/conversions/to_chars.hpp b/include/nlohmann/detail/conversions/to_chars.hpp
index b6cb22ae..198e422e 100644
--- a/include/nlohmann/detail/conversions/to_chars.hpp
+++ b/include/nlohmann/detail/conversions/to_chars.hpp
@@ -1,5 +1,6 @@
#pragma once
+#include <array> // array
#include <cassert> // assert
#include <ciso646> // or, and, not
#include <cmath> // signbit, isfinite
@@ -49,10 +50,10 @@ struct diyfp // f * 2^e
{
static constexpr int kPrecision = 64; // = q
- uint64_t f = 0;
+ std::uint64_t f = 0;
int e = 0;
- constexpr diyfp(uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+ constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
/*!
@brief returns x - y
@@ -97,23 +98,23 @@ struct diyfp // f * 2^e
//
// = p_lo + 2^64 p_hi
- const uint64_t u_lo = x.f & 0xFFFFFFFF;
- const uint64_t u_hi = x.f >> 32;
- const uint64_t v_lo = y.f & 0xFFFFFFFF;
- const uint64_t v_hi = y.f >> 32;
+ const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+ const std::uint64_t u_hi = x.f >> 32u;
+ const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+ const std::uint64_t v_hi = y.f >> 32u;
- const uint64_t p0 = u_lo * v_lo;
- const uint64_t p1 = u_lo * v_hi;
- const uint64_t p2 = u_hi * v_lo;
- const uint64_t p3 = u_hi * v_hi;
+ const std::uint64_t p0 = u_lo * v_lo;
+ const std::uint64_t p1 = u_lo * v_hi;
+ const std::uint64_t p2 = u_hi * v_lo;
+ const std::uint64_t p3 = u_hi * v_hi;
- const uint64_t p0_hi = p0 >> 32;
- const uint64_t p1_lo = p1 & 0xFFFFFFFF;
- const uint64_t p1_hi = p1 >> 32;
- const uint64_t p2_lo = p2 & 0xFFFFFFFF;
- const uint64_t p2_hi = p2 >> 32;
+ const std::uint64_t p0_hi = p0 >> 32u;
+ const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+ const std::uint64_t p1_hi = p1 >> 32u;
+ const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+ const std::uint64_t p2_hi = p2 >> 32u;
- uint64_t Q = p0_hi + p1_lo + p2_lo;
+ std::uint64_t Q = p0_hi + p1_lo + p2_lo;
// The full product might now be computed as
//
@@ -124,9 +125,9 @@ struct diyfp // f * 2^e
// Effectively we only need to add the highest bit in p_lo to p_hi (and
// Q_hi + 1 does not overflow).
- Q += uint64_t{1} << (64 - 32 - 1); // round, ties up
+ Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
- const uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32);
+ const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
return {h, x.e + y.e + 64};
}
@@ -139,9 +140,9 @@ struct diyfp // f * 2^e
{
assert(x.f != 0);
- while ((x.f >> 63) == 0)
+ while ((x.f >> 63u) == 0)
{
- x.f <<= 1;
+ x.f <<= 1u;
x.e--;
}
@@ -195,13 +196,13 @@ boundaries compute_boundaries(FloatType value)
constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
constexpr int kMinExp = 1 - kBias;
- constexpr uint64_t kHiddenBit = uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+ constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
- using bits_type = typename std::conditional< kPrecision == 24, uint32_t, uint64_t >::type;
+ using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
- const uint64_t bits = reinterpret_bits<bits_type>(value);
- const uint64_t E = bits >> (kPrecision - 1);
- const uint64_t F = bits & (kHiddenBit - 1);
+ const std::uint64_t bits = reinterpret_bits<bits_type>(value);
+ const std::uint64_t E = bits >> (kPrecision - 1);
+ const std::uint64_t F = bits & (kHiddenBit - 1);
const bool is_denormal = (E == 0);
const diyfp v = is_denormal
@@ -304,7 +305,7 @@ constexpr int kGamma = -32;
struct cached_power // c = f * 2^e ~= 10^k
{
- uint64_t f;
+ std::uint64_t f;
int e;
int k;
};
@@ -368,91 +369,92 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
// NB:
// Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
- constexpr int kCachedPowersSize = 79;
constexpr int kCachedPowersMinDecExp = -300;
constexpr int kCachedPowersDecStep = 8;
- static constexpr cached_power kCachedPowers[] =
+ static constexpr std::array<cached_power, 79> kCachedPowers =
{
- { 0xAB70FE17C79AC6CA, -1060, -300 },
- { 0xFF77B1FCBEBCDC4F, -1034, -292 },
- { 0xBE5691EF416BD60C, -1007, -284 },
- { 0x8DD01FAD907FFC3C, -980, -276 },
- { 0xD3515C2831559A83, -954, -268 },
- { 0x9D71AC8FADA6C9B5, -927, -260 },
- { 0xEA9C227723EE8BCB, -901, -252 },
- { 0xAECC49914078536D, -874, -244 },
- { 0x823C12795DB6CE57, -847, -236 },
- { 0xC21094364DFB5637, -821, -228 },
- { 0x9096EA6F3848984F, -794, -220 },
- { 0xD77485CB25823AC7, -768, -212 },
- { 0xA086CFCD97BF97F4, -741, -204 },
- { 0xEF340A98172AACE5, -715, -196 },
- { 0xB23867FB2A35B28E, -688, -188 },
- { 0x84C8D4DFD2C63F3B, -661, -180 },
- { 0xC5DD44271AD3CDBA, -635, -172 },
- { 0x936B9FCEBB25C996, -608, -164 },
- { 0xDBAC6C247D62A584, -582, -156 },
- { 0xA3AB66580D5FDAF6, -555, -148 },
- { 0xF3E2F893DEC3F126, -529, -140 },
- { 0xB5B5ADA8AAFF80B8, -502, -132 },
- { 0x87625F056C7C4A8B, -475, -124 },
- { 0xC9BCFF6034C13053, -449, -116 },
- { 0x964E858C91BA2655, -422, -108 },
- { 0xDFF9772470297EBD, -396, -100 },
- { 0xA6DFBD9FB8E5B88F, -369, -92 },
- { 0xF8A95FCF88747D94, -343, -84 },
- { 0xB94470938FA89BCF, -316, -76 },
- { 0x8A08F0F8BF0F156B, -289, -68 },
- { 0xCDB02555653131B6, -263, -60 },
- { 0x993FE2C6D07B7FAC, -236, -52 },
- { 0xE45C10C42A2B3B06, -210, -44 },
- { 0xAA242499697392D3, -183, -36 },
- { 0xFD87B5F28300CA0E, -157, -28 },
- { 0xBCE5086492111AEB, -130, -20 },
- { 0x8CBCCC096F5088CC, -103, -12 },
- { 0xD1B71758E219652C, -77, -4 },
- { 0x9C40000000000000, -50, 4 },
- { 0xE8D4A51000000000, -24, 12 },
- { 0xAD78EBC5AC620000, 3, 20 },
- { 0x813F3978F8940984, 30, 28 },
- { 0xC097CE7BC90715B3, 56, 36 },
- { 0x8F7E32CE7BEA5C70, 83, 44 },
- { 0xD5D238A4ABE98068, 109, 52 },
- { 0x9F4F2726179A2245, 136, 60 },
- { 0xED63A231D4C4FB27, 162, 68 },
- { 0xB0DE65388CC8ADA8, 189, 76 },
- { 0x83C7088E1AAB65DB, 216, 84 },
- { 0xC45D1DF942711D9A, 242, 92 },
- { 0x924D692CA61BE758, 269, 100 },
- { 0xDA01EE641A708DEA, 295, 108 },
- { 0xA26DA3999AEF774A, 322, 116 },
- { 0xF209787BB47D6B85, 348, 124 },
- { 0xB454E4A179DD1877, 375, 132 },
- { 0x865B86925B9BC5C2, 402, 140 },
- { 0xC83553C5C8965D3D, 428, 148 },
- { 0x952AB45CFA97A0B3, 455, 156 },
- { 0xDE469FBD99A05FE3, 481, 164 },
- { 0xA59BC234DB398C25, 508, 172 },
- { 0xF6C69A72A3989F5C, 534, 180 },
- { 0xB7DCBF5354E9BECE, 561, 188 },
- { 0x88FCF317F22241E2, 588, 196 },
- { 0xCC20CE9BD35C78A5, 614, 204 },
- { 0x98165AF37B2153DF, 641, 212 },
- { 0xE2A0B5DC971F303A, 667, 220 },
- { 0xA8D9D1535CE3B396, 694, 228 },
- { 0xFB9B7CD9A4A7443C, 720, 236 },
- { 0xBB764C4CA7A44410, 747, 244 },
- { 0x8BAB8EEFB6409C1A, 774, 252 },
- { 0xD01FEF10A657842C, 800, 260 },
- { 0x9B10A4E5E9913129, 827, 268 },
- { 0xE7109BFBA19C0C9D, 853, 276 },
- { 0xAC2820D9623BF429, 880, 284 },
- { 0x80444B5E7AA7CF85, 907, 292 },
- { 0xBF21E44003ACDD2D, 933, 300 },
- { 0x8E679C2F5E44FF8F, 960, 308 },
- { 0xD433179D9C8CB841, 986, 316 },
- { 0x9E19DB92B4E31BA9, 1013, 324 },
+ {
+ { 0xAB70FE17C79AC6CA, -1060, -300 },
+ { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+ { 0xBE5691EF416BD60C, -1007, -284 },
+ { 0x8DD01FAD907FFC3C, -980, -276 },
+ { 0xD3515C2831559A83, -954, -268 },
+ { 0x9D71AC8FADA6C9B5, -927, -260 },
+ { 0xEA9C227723EE8BCB, -901, -252 },
+ { 0xAECC49914078536D, -874, -244 },
+ { 0x823C12795DB6CE57, -847, -236 },
+ { 0xC21094364DFB5637, -821, -228 },
+ { 0x9096EA6F3848984F, -794, -220 },
+ { 0xD77485CB25823AC7, -768, -212 },
+ { 0xA086CFCD97BF97F4, -741, -204 },
+ { 0xEF340A98172AACE5, -715, -196 },
+ { 0xB23867FB2A35B28E, -688, -188 },
+ { 0x84C8D4DFD2C63F3B, -661, -180 },
+ { 0xC5DD44271AD3CDBA, -635, -172 },
+ { 0x936B9FCEBB25C996, -608, -164 },
+ { 0xDBAC6C247D62A584, -582, -156 },
+ { 0xA3AB66580D5FDAF6, -555, -148 },
+ { 0xF3E2F893DEC3F126, -529, -140 },
+ { 0xB5B5ADA8AAFF80B8, -502, -132 },
+ { 0x87625F056C7C4A8B, -475, -124 },
+ { 0xC9BCFF6034C13053, -449, -116 },
+ { 0x964E858C91BA2655, -422, -108 },
+ { 0xDFF9772470297EBD, -396, -100 },
+ { 0xA6DFBD9FB8E5B88F, -369, -92 },
+ { 0xF8A95FCF88747D94, -343, -84 },
+ { 0xB94470938FA89BCF, -316, -76 },
+ { 0x8A08F0F8BF0F156B, -289, -68 },
+ { 0xCDB02555653131B6, -263, -60 },
+ { 0x993FE2C6D07B7FAC, -236, -52 },
+ { 0xE45C10C42A2B3B06, -210, -44 },
+ { 0xAA242499697392D3, -183, -36 },
+ { 0xFD87B5F28300CA0E, -157, -28 },
+ { 0xBCE5086492111AEB, -130, -20 },
+ { 0x8CBCCC096F5088CC, -103, -12 },
+ { 0xD1B71758E219652C, -77, -4 },
+ { 0x9C40000000000000, -50, 4 },
+ { 0xE8D4A51000000000, -24, 12 },
+ { 0xAD78EBC5AC620000, 3, 20 },
+ { 0x813F3978F8940984, 30, 28 },
+ { 0xC097CE7BC90715B3, 56, 36 },
+ { 0x8F7E32CE7BEA5C70, 83, 44 },
+ { 0xD5D238A4ABE98068, 109, 52 },
+ { 0x9F4F2726179A2245, 136, 60 },
+ { 0xED63A231D4C4FB27, 162, 68 },
+ { 0xB0DE65388CC8ADA8, 189, 76 },
+ { 0x83C7088E1AAB65DB, 216, 84 },
+ { 0xC45D1DF942711D9A, 242, 92 },
+ { 0x924D692CA61BE758, 269, 100 },
+ { 0xDA01EE641A708DEA, 295, 108 },
+ { 0xA26DA3999AEF774A, 322, 116 },
+ { 0xF209787BB47D6B85, 348, 124 },
+ { 0xB454E4A179DD1877, 375, 132 },
+ { 0x865B86925B9BC5C2, 402, 140 },
+ { 0xC83553C5C8965D3D, 428, 148 },
+ { 0x952AB45CFA97A0B3, 455, 156 },
+ { 0xDE469FBD99A05FE3, 481, 164 },
+ { 0xA59BC234DB398C25, 508, 172 },
+ { 0xF6C69A72A3989F5C, 534, 180 },
+ { 0xB7DCBF5354E9BECE, 561, 188 },
+ { 0x88FCF317F22241E2, 588, 196 },
+ { 0xCC20CE9BD35C78A5, 614, 204 },
+ { 0x98165AF37B2153DF, 641, 212 },
+ { 0xE2A0B5DC971F303A, 667, 220 },
+ { 0xA8D9D1535CE3B396, 694, 228 },
+ { 0xFB9B7CD9A4A7443C, 720, 236 },
+ { 0xBB764C4CA7A44410, 747, 244 },
+ { 0x8BAB8EEFB6409C1A, 774, 252 },
+ { 0xD01FEF10A657842C, 800, 260 },
+ { 0x9B10A4E5E9913129, 827, 268 },
+ { 0xE7109BFBA19C0C9D, 853, 276 },
+ { 0xAC2820D9623BF429, 880, 284 },
+ { 0x80444B5E7AA7CF85, 907, 292 },
+ { 0xBF21E44003ACDD2D, 933, 300 },
+ { 0x8E679C2F5E44FF8F, 960, 308 },
+ { 0xD433179D9C8CB841, 986, 316 },
+ { 0x9E19DB92B4E31BA9, 1013, 324 },
+ }
};
// This computation gives exactly the same results for k as
@@ -466,10 +468,9 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
assert(index >= 0);
- assert(index < kCachedPowersSize);
- static_cast<void>(kCachedPowersSize); // Fix warning.
+ assert(static_cast<std::size_t>(index) < kCachedPowers.size());
- const cached_power cached = kCachedPowers[index];
+ const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
assert(kAlpha <= cached.e + e + 64);
assert(kGamma >= cached.e + e + 64);
@@ -480,7 +481,7 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
For n == 0, returns 1 and sets pow10 := 1.
*/
-inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
{
// LCOV_EXCL_START
if (n >= 1000000000)
@@ -536,8 +537,8 @@ inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)
}
}
-inline void grisu2_round(char* buf, int len, uint64_t dist, uint64_t delta,
- uint64_t rest, uint64_t ten_k)
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+ std::uint64_t rest, std::uint64_t ten_k)
{
assert(len >= 1);
assert(dist <= delta);
@@ -598,8 +599,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
assert(M_plus.e >= kAlpha);
assert(M_plus.e <= kGamma);
- uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
- uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
+ std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+ std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
@@ -608,10 +609,10 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
- const diyfp one(uint64_t{1} << -M_plus.e, M_plus.e);
+ const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
- auto p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
- uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
+ auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+ std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
@@ -619,7 +620,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
assert(p1 > 0);
- uint32_t pow10;
+ std::uint32_t pow10;
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
@@ -647,8 +648,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
- const uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
- const uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
+ const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
+ const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
@@ -673,7 +674,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
- const uint64_t rest = (uint64_t{p1} << -one.e) + p2;
+ const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
@@ -689,7 +690,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
- const uint64_t ten_n = uint64_t{pow10} << -one.e;
+ const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
@@ -753,8 +754,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
assert(p2 <= std::numeric_limits<std::uint64_t>::max() / 10);
p2 *= 10;
- const uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
- const uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+ const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
+ const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
@@ -794,7 +795,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
- const uint64_t ten_m = one.f;
+ const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
@@ -929,7 +930,7 @@ inline char* append_exponent(char* buf, int e)
*buf++ = '+';
}
- auto k = static_cast<uint32_t>(e);
+ auto k = static_cast<std::uint32_t>(e);
if (k < 10)
{
// Always print at least two digits in the exponent.
diff --git a/include/nlohmann/detail/input/binary_reader.hpp b/include/nlohmann/detail/input/binary_reader.hpp
index 370a9520..ff6b1ab6 100644
--- a/include/nlohmann/detail/input/binary_reader.hpp
+++ b/include/nlohmann/detail/input/binary_reader.hpp
@@ -263,9 +263,9 @@ class binary_reader
default: // anything else not supported (yet)
{
- char cr[3];
- (std::snprintf)(cr, sizeof(cr), "%.2hhX", static_cast<unsigned char>(element_type));
- return sax->parse_error(element_type_parse_position, std::string(cr), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr)));
+ std::array<char, 3> cr{};
+ (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
+ return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
}
}
}
@@ -388,25 +388,25 @@ class binary_reader
case 0x18: // Unsigned integer (one-byte uint8_t follows)
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
case 0x19: // Unsigned integer (two-byte uint16_t follows)
{
- uint16_t number;
+ std::uint16_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
case 0x1A: // Unsigned integer (four-byte uint32_t follows)
{
- uint32_t number;
+ std::uint32_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
{
- uint64_t number;
+ std::uint64_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
@@ -435,29 +435,29 @@ class binary_reader
case 0x35:
case 0x36:
case 0x37:
- return sax->number_integer(static_cast<int8_t>(0x20 - 1 - current));
+ return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
case 0x38: // Negative integer (one-byte uint8_t follows)
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
{
- uint16_t number;
+ std::uint16_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
{
- uint32_t number;
+ std::uint32_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
{
- uint64_t number;
+ std::uint64_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1)
- static_cast<number_integer_t>(number));
}
@@ -526,25 +526,25 @@ class binary_reader
case 0x98: // array (one-byte uint8_t for n follows)
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
case 0x99: // array (two-byte uint16_t for n follow)
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
case 0x9A: // array (four-byte uint32_t for n follow)
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
case 0x9B: // array (eight-byte uint64_t for n follow)
{
- uint64_t len;
+ std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
@@ -580,25 +580,25 @@ class binary_reader
case 0xB8: // map (one-byte uint8_t for n follows)
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
case 0xB9: // map (two-byte uint16_t for n follow)
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
case 0xBA: // map (four-byte uint32_t for n follow)
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
case 0xBB: // map (eight-byte uint64_t for n follow)
{
- uint64_t len;
+ std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
@@ -638,10 +638,10 @@ class binary_reader
// without such support. An example of a small decoder for
// half-precision floating-point numbers in the C language
// is shown in Fig. 3.
- const unsigned int half = (byte1 << 8u) + byte2;
+ const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
const double val = [&half]
{
- const unsigned int exp = (half >> 10u) & 0x1Fu;
+ const int exp = (half >> 10u) & 0x1Fu;
const unsigned int mant = half & 0x3FFu;
assert(0 <= exp and exp <= 32);
assert(0 <= mant and mant <= 1024);
@@ -733,25 +733,25 @@ class binary_reader
case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
{
- uint64_t len;
+ std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
@@ -1108,49 +1108,49 @@ class binary_reader
case 0xCC: // uint 8
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xCD: // uint 16
{
- uint16_t number;
+ std::uint16_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xCE: // uint 32
{
- uint32_t number;
+ std::uint32_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xCF: // uint 64
{
- uint64_t number;
+ std::uint64_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xD0: // int 8
{
- int8_t number;
+ std::int8_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
case 0xD1: // int 16
{
- int16_t number;
+ std::int16_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
case 0xD2: // int 32
{
- int32_t number;
+ std::int32_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
case 0xD3: // int 64
{
- int64_t number;
+ std::int64_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
@@ -1164,25 +1164,25 @@ class binary_reader
case 0xDC: // array 16
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
}
case 0xDD: // array 32
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
}
case 0xDE: // map 16
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
}
case 0xDF: // map 32
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
}
@@ -1219,7 +1219,7 @@ class binary_reader
case 0xFD:
case 0xFE:
case 0xFF:
- return sax->number_integer(static_cast<int8_t>(current));
+ return sax->number_integer(static_cast<std::int8_t>(current));
default: // anything else
{
@@ -1287,19 +1287,19 @@ class binary_reader
case 0xD9: // str 8
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
}
case 0xDA: // str 16
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
}
case 0xDB: // str 32
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
}
@@ -1397,7 +1397,7 @@ class binary_reader
{
if (get_char)
{
- get(); // TODO: may we ignore N here?
+ get(); // TODO(niels): may we ignore N here?
}
if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
@@ -1409,31 +1409,31 @@ class binary_reader
{
case 'U':
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'i':
{
- int8_t len;
+ std::int8_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'I':
{
- int16_t len;
+ std::int16_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'l':
{
- int32_t len;
+ std::int32_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'L':
{
- int64_t len;
+ std::int64_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
@@ -1453,7 +1453,7 @@ class binary_reader
{
case 'U':
{
- uint8_t number;
+ std::uint8_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -1464,7 +1464,7 @@ class binary_reader
case 'i':
{
- int8_t number;
+ std::int8_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -1475,7 +1475,7 @@ class binary_reader
case 'I':
{
- int16_t number;
+ std::int16_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -1486,7 +1486,7 @@ class binary_reader
case 'l':
{
- int32_t number;
+ std::int32_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -1497,7 +1497,7 @@ class binary_reader
case 'L':
{
- int64_t number;
+ std::int64_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -1552,10 +1552,12 @@ class binary_reader
return get_ubjson_size_value(result.first);
}
- else if (current == '#')
+
+ if (current == '#')
{
return get_ubjson_size_value(result.first);
}
+
return true;
}
@@ -1580,31 +1582,31 @@ class binary_reader
case 'U':
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number);
}
case 'i':
{
- int8_t number;
+ std::int8_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
case 'I':
{
- int16_t number;
+ std::int16_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
case 'l':
{
- int32_t number;
+ std::int32_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
case 'L':
{
- int64_t number;
+ std::int64_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
@@ -1843,7 +1845,7 @@ class binary_reader
bool get_number(const input_format_t format, NumberType& result)
{
// step 1: read input into array with system's byte order
- std::array<uint8_t, sizeof(NumberType)> vec;
+ std::array<std::uint8_t, sizeof(NumberType)> vec;
for (std::size_t i = 0; i < sizeof(NumberType); ++i)
{
get();
@@ -1855,11 +1857,11 @@ class binary_reader
// reverse byte order prior to conversion if necessary
if (is_little_endian != InputIsLittleEndian)
{
- vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);
+ vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
}
else
{
- vec[i] = static_cast<uint8_t>(current); // LCOV_EXCL_LINE
+ vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
}
}
@@ -1920,9 +1922,9 @@ class binary_reader
*/
std::string get_token_string() const
{
- char cr[3];
- (std::snprintf)(cr, 3, "%.2hhX", static_cast<unsigned char>(current));
- return std::string{cr};
+ std::array<char, 3> cr{};
+ (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
+ return std::string{cr.data()};
}
/*!
diff --git a/include/nlohmann/detail/input/input_adapters.hpp b/include/nlohmann/detail/input/input_adapters.hpp
index 322e72db..c3d33391 100644
--- a/include/nlohmann/detail/input/input_adapters.hpp
+++ b/include/nlohmann/detail/input/input_adapters.hpp
@@ -1,5 +1,6 @@
#pragma once
+#include <array> // array
#include <cassert> // assert
#include <cstddef> // size_t
#include <cstring> // strlen
@@ -153,7 +154,11 @@ template<typename WideStringType, size_t T>
struct wide_string_input_helper
{
// UTF-32
- static void fill_buffer(const WideStringType& str, size_t& current_wchar, std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, size_t& utf8_bytes_index, size_t& utf8_bytes_filled)
+ static void fill_buffer(const WideStringType& str,
+ size_t& current_wchar,
+ std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+ size_t& utf8_bytes_index,
+ size_t& utf8_bytes_filled)
{
utf8_bytes_index = 0;
@@ -170,34 +175,34 @@ struct wide_string_input_helper
// UTF-32 to UTF-8 encoding
if (wc < 0x80)
{
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
else if (wc <= 0x7FF)
{
- utf8_bytes[0] = 0xC0u | ((wc >> 6u) & 0x1Fu);
- utf8_bytes[1] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u) & 0x1Fu));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 2;
}
else if (wc <= 0xFFFF)
{
- utf8_bytes[0] = 0xE0u | ((wc >> 12u) & 0x0Fu);
- utf8_bytes[1] = 0x80u | ((wc >> 6u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u) & 0x0Fu));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 3;
}
else if (wc <= 0x10FFFF)
{
- utf8_bytes[0] = 0xF0u | ((wc >> 18u) & 0x07u);
- utf8_bytes[1] = 0x80u | ((wc >> 12u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | ((wc >> 6u) & 0x3Fu);
- utf8_bytes[3] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((wc >> 18u) & 0x07u));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 12u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+ utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 4;
}
else
{
// unknown character
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
}
@@ -208,7 +213,11 @@ template<typename WideStringType>
struct wide_string_input_helper<WideStringType, 2>
{
// UTF-16
- static void fill_buffer(const WideStringType& str, size_t& current_wchar, std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, size_t& utf8_bytes_index, size_t& utf8_bytes_filled)
+ static void fill_buffer(const WideStringType& str,
+ size_t& current_wchar,
+ std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+ size_t& utf8_bytes_index,
+ size_t& utf8_bytes_filled)
{
utf8_bytes_index = 0;
@@ -225,20 +234,20 @@ struct wide_string_input_helper<WideStringType, 2>
// UTF-16 to UTF-8 encoding
if (wc < 0x80)
{
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
else if (wc <= 0x7FF)
{
- utf8_bytes[0] = 0xC0u | ((wc >> 6u));
- utf8_bytes[1] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u)));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 2;
}
else if (0xD800 > wc or wc >= 0xE000)
{
- utf8_bytes[0] = 0xE0u | ((wc >> 12u));
- utf8_bytes[1] = 0x80u | ((wc >> 6u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u)));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 3;
}
else
@@ -247,17 +256,17 @@ struct wide_string_input_helper<WideStringType, 2>
{
const auto wc2 = static_cast<unsigned int>(str[current_wchar++]);
const auto charcode = 0x10000u + (((wc & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
- utf8_bytes[0] = 0xF0u | (charcode >> 18u);
- utf8_bytes[1] = 0x80u | ((charcode >> 12u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | ((charcode >> 6u) & 0x3Fu);
- utf8_bytes[3] = 0x80u | (charcode & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+ utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
utf8_bytes_filled = 4;
}
else
{
// unknown character
++current_wchar;
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
}
diff --git a/include/nlohmann/detail/input/lexer.hpp b/include/nlohmann/detail/input/lexer.hpp
index 446ad23f..a6bde97e 100644
--- a/include/nlohmann/detail/input/lexer.hpp
+++ b/include/nlohmann/detail/input/lexer.hpp
@@ -1,5 +1,6 @@
#pragma once
+#include <array> // array
#include <clocale> // localeconv
#include <cstddef> // size_t
#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
@@ -156,15 +157,15 @@ class lexer
if (current >= '0' and current <= '9')
{
- codepoint += ((static_cast<unsigned int>(current) - 0x30u) << factor);
+ codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' and current <= 'F')
{
- codepoint += ((static_cast<unsigned int>(current) - 0x37u) << factor);
+ codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' and current <= 'f')
{
- codepoint += ((static_cast<unsigned int>(current) - 0x57u) << factor);
+ codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
@@ -322,15 +323,15 @@ class lexer
if (JSON_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
{
// overwrite codepoint
- codepoint =
- // high surrogate occupies the most significant 22 bits
- (static_cast<unsigned int>(codepoint1) << 10u)
- // low surrogate occupies the least significant 15 bits
- + static_cast<unsigned int>(codepoint2)
- // there is still the 0xD800, 0xDC00 and 0x10000 noise
- // in the result so we have to subtract with:
- // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- - 0x35FDC00u;
+ codepoint = static_cast<int>(
+ // high surrogate occupies the most significant 22 bits
+ (static_cast<unsigned int>(codepoint1) << 10u)
+ // low surrogate occupies the least significant 15 bits
+ + static_cast<unsigned int>(codepoint2)
+ // there is still the 0xD800, 0xDC00 and 0x10000 noise
+ // in the result so we have to subtract with:
+ // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+ - 0x35FDC00u);
}
else
{
@@ -365,23 +366,23 @@ class lexer
else if (codepoint <= 0x7FF)
{
// 2-byte characters: 110xxxxx 10xxxxxx
- add(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u));
- add(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu));
+ add(static_cast<int>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+ add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else if (codepoint <= 0xFFFF)
{
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
- add(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u));
- add(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu));
- add(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu));
+ add(static_cast<int>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+ add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+ add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else
{
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- add(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u));
- add(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu));
- add(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu));
- add(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu));
+ add(static_cast<int>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+ add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+ add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+ add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
break;
@@ -1360,9 +1361,9 @@ scan_number_done:
if ('\x00' <= c and c <= '\x1F')
{
// escape control characters
- char cs[9];
- (std::snprintf)(cs, 9, "<U+%.4X>", static_cast<unsigned char>(c));
- result += cs;
+ std::array<char, 9> cs{};
+ (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
+ result += cs.data();
}
else
{
diff --git a/include/nlohmann/detail/output/binary_writer.hpp b/include/nlohmann/detail/output/binary_writer.hpp
index 4d6f1577..a8fddfee 100644
--- a/include/nlohmann/detail/output/binary_writer.hpp
+++ b/include/nlohmann/detail/output/binary_writer.hpp
@@ -88,27 +88,27 @@ class binary_writer
// code from the value_t::number_unsigned case here.
if (j.m_value.number_integer <= 0x17)
{
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x18));
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x19));
- write_number(static_cast<uint16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x1A));
- write_number(static_cast<uint32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
else
{
oa->write_character(to_char_type(0x1B));
- write_number(static_cast<uint64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
}
else
@@ -118,27 +118,27 @@ class binary_writer
const auto positive_number = -1 - j.m_value.number_integer;
if (j.m_value.number_integer >= -24)
{
- write_number(static_cast<uint8_t>(0x20 + positive_number));
+ write_number(static_cast<std::uint8_t>(0x20 + positive_number));
}
- else if (positive_number <= (std::numeric_limits<uint8_t>::max)())
+ else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x38));
- write_number(static_cast<uint8_t>(positive_number));
+ write_number(static_cast<std::uint8_t>(positive_number));
}
- else if (positive_number <= (std::numeric_limits<uint16_t>::max)())
+ else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x39));
- write_number(static_cast<uint16_t>(positive_number));
+ write_number(static_cast<std::uint16_t>(positive_number));
}
- else if (positive_number <= (std::numeric_limits<uint32_t>::max)())
+ else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x3A));
- write_number(static_cast<uint32_t>(positive_number));
+ write_number(static_cast<std::uint32_t>(positive_number));
}
else
{
oa->write_character(to_char_type(0x3B));
- write_number(static_cast<uint64_t>(positive_number));
+ write_number(static_cast<std::uint64_t>(positive_number));
}
}
break;
@@ -148,27 +148,27 @@ class binary_writer
{
if (j.m_value.number_unsigned <= 0x17)
{
- write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x18));
- write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x19));
- write_number(static_cast<uint16_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x1A));
- write_number(static_cast<uint32_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
}
else
{
oa->write_character(to_char_type(0x1B));
- write_number(static_cast<uint64_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
}
break;
}
@@ -186,28 +186,28 @@ class binary_writer
const auto N = j.m_value.string->size();
if (N <= 0x17)
{
- write_number(static_cast<uint8_t>(0x60 + N));
+ write_number(static_cast<std::uint8_t>(0x60 + N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x78));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x79));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x7A));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
- else if (N <= (std::numeric_limits<uint64_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0x7B));
- write_number(static_cast<uint64_t>(N));
+ write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
@@ -224,28 +224,28 @@ class binary_writer
const auto N = j.m_value.array->size();
if (N <= 0x17)
{
- write_number(static_cast<uint8_t>(0x80 + N));
+ write_number(static_cast<std::uint8_t>(0x80 + N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x98));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x99));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x9A));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
- else if (N <= (std::numeric_limits<uint64_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0x9B));
- write_number(static_cast<uint64_t>(N));
+ write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
@@ -263,28 +263,28 @@ class binary_writer
const auto N = j.m_value.object->size();
if (N <= 0x17)
{
- write_number(static_cast<uint8_t>(0xA0 + N));
+ write_number(static_cast<std::uint8_t>(0xA0 + N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0xB8));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0xB9));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0xBA));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
- else if (N <= (std::numeric_limits<uint64_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0xBB));
- write_number(static_cast<uint64_t>(N));
+ write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
@@ -333,31 +333,31 @@ class binary_writer
if (j.m_value.number_unsigned < 128)
{
// positive fixnum
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
// uint 8
oa->write_character(to_char_type(0xCC));
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
// uint 16
oa->write_character(to_char_type(0xCD));
- write_number(static_cast<uint16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
// uint 32
oa->write_character(to_char_type(0xCE));
- write_number(static_cast<uint32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
{
// uint 64
oa->write_character(to_char_type(0xCF));
- write_number(static_cast<uint64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
}
else
@@ -365,35 +365,35 @@ class binary_writer
if (j.m_value.number_integer >= -32)
{
// negative fixnum
- write_number(static_cast<int8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int8_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
// int 8
oa->write_character(to_char_type(0xD0));
- write_number(static_cast<int8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int16_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
// int 16
oa->write_character(to_char_type(0xD1));
- write_number(static_cast<int16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int32_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
// int 32
oa->write_character(to_char_type(0xD2));
- write_number(static_cast<int32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int64_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int64_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
{
// int 64
oa->write_character(to_char_type(0xD3));
- write_number(static_cast<int64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int64_t>(j.m_value.number_integer));
}
}
break;
@@ -404,31 +404,31 @@ class binary_writer
if (j.m_value.number_unsigned < 128)
{
// positive fixnum
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
// uint 8
oa->write_character(to_char_type(0xCC));
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
// uint 16
oa->write_character(to_char_type(0xCD));
- write_number(static_cast<uint16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
// uint 32
oa->write_character(to_char_type(0xCE));
- write_number(static_cast<uint32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
{
// uint 64
oa->write_character(to_char_type(0xCF));
- write_number(static_cast<uint64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
break;
}
@@ -447,25 +447,25 @@ class binary_writer
if (N <= 31)
{
// fixstr
- write_number(static_cast<uint8_t>(0xA0 | N));
+ write_number(static_cast<std::uint8_t>(0xA0 | N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
// str 8
oa->write_character(to_char_type(0xD9));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// str 16
oa->write_character(to_char_type(0xDA));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// str 32
oa->write_character(to_char_type(0xDB));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// step 2: write the string
@@ -482,19 +482,19 @@ class binary_writer
if (N <= 15)
{
// fixarray
- write_number(static_cast<uint8_t>(0x90 | N));
+ write_number(static_cast<std::uint8_t>(0x90 | N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// array 16
oa->write_character(to_char_type(0xDC));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// array 32
oa->write_character(to_char_type(0xDD));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// step 2: write each element
@@ -512,19 +512,19 @@ class binary_writer
if (N <= 15)
{
// fixmap
- write_number(static_cast<uint8_t>(0x80 | (N & 0xF)));
+ write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// map 16
oa->write_character(to_char_type(0xDE));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// map 32
oa->write_character(to_char_type(0xDF));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// step 2: write each element
@@ -790,14 +790,9 @@ class binary_writer
*/
static std::size_t calc_bson_integer_size(const std::int64_t value)
{
- if ((std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)())
- {
- return sizeof(std::int32_t);
- }
- else
- {
- return sizeof(std::int64_t);
- }
+ return (std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)()
+ ? sizeof(std::int32_t)
+ : sizeof(std::int64_t);
}
/*!
@@ -1065,45 +1060,45 @@ class binary_writer
void write_number_with_ubjson_prefix(const NumberType n,
const bool add_prefix)
{
- if (n <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)()))
+ if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('i')); // int8
}
- write_number(static_cast<uint8_t>(n));
+ write_number(static_cast<std::uint8_t>(n));
}
- else if (n <= (std::numeric_limits<uint8_t>::max)())
+ else if (n <= (std::numeric_limits<std::uint8_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('U')); // uint8
}
- write_number(static_cast<uint8_t>(n));
+ write_number(static_cast<std::uint8_t>(n));
}
- else if (n <= static_cast<uint64_t>((std::numeric_limits<int16_t>::max)()))
+ else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('I')); // int16
}
- write_number(static_cast<int16_t>(n));
+ write_number(static_cast<std::int16_t>(n));
}
- else if (n <= static_cast<uint64_t>((std::numeric_limits<int32_t>::max)()))
+ else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('l')); // int32
}
- write_number(static_cast<int32_t>(n));
+ write_number(static_cast<std::int32_t>(n));
}
- else if (n <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
+ else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('L')); // int64
}
- write_number(static_cast<int64_t>(n));
+ write_number(static_cast<std::int64_t>(n));
}
else
{
@@ -1118,45 +1113,45 @@ class binary_writer
void write_number_with_ubjson_prefix(const NumberType n,
const bool add_prefix)
{
- if ((std::numeric_limits<int8_t>::min)() <= n and n <= (std::numeric_limits<int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= n and n <= (std::numeric_limits<std::int8_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('i')); // int8
}
- write_number(static_cast<int8_t>(n));
+ write_number(static_cast<std::int8_t>(n));
}
- else if (static_cast<int64_t>((std::numeric_limits<uint8_t>::min)()) <= n and n <= static_cast<int64_t>((std::numeric_limits<uint8_t>::max)()))
+ else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n and n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('U')); // uint8
}
- write_number(static_cast<uint8_t>(n));
+ write_number(static_cast<std::uint8_t>(n));
}
- else if ((std::numeric_limits<int16_t>::min)() <= n and n <= (std::numeric_limits<int16_t>::max)())
+ else if ((std::numeric_limits<std::int16_t>::min)() <= n and n <= (std::numeric_limits<std::int16_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('I')); // int16
}
- write_number(static_cast<int16_t>(n));
+ write_number(static_cast<std::int16_t>(n));
}
- else if ((std::numeric_limits<int32_t>::min)() <= n and n <= (std::numeric_limits<int32_t>::max)())
+ else if ((std::numeric_limits<std::int32_t>::min)() <= n and n <= (std::numeric_limits<std::int32_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('l')); // int32
}
- write_number(static_cast<int32_t>(n));
+ write_number(static_cast<std::int32_t>(n));
}
- else if ((std::numeric_limits<int64_t>::min)() <= n and n <= (std::numeric_limits<int64_t>::max)())
+ else if ((std::numeric_limits<std::int64_t>::min)() <= n and n <= (std::numeric_limits<std::int64_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('L')); // int64
}
- write_number(static_cast<int64_t>(n));
+ write_number(static_cast<std::int64_t>(n));
}
// LCOV_EXCL_START
else
@@ -1187,19 +1182,19 @@ class binary_writer
case value_t::number_integer:
{
- if ((std::numeric_limits<int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
- if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
+ if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
- if ((std::numeric_limits<int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
+ if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
- if ((std::numeric_limits<int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
+ if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
@@ -1209,19 +1204,19 @@ class binary_writer
case value_t::number_unsigned:
{
- if (j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
- if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
- if (j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
- if (j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
diff --git a/include/nlohmann/detail/output/serializer.hpp b/include/nlohmann/detail/output/serializer.hpp
index f51afeea..5e85355a 100644
--- a/include/nlohmann/detail/output/serializer.hpp
+++ b/include/nlohmann/detail/output/serializer.hpp
@@ -45,8 +45,8 @@ class serializer
using number_float_t = typename BasicJsonType::number_float_t;
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
- static constexpr uint8_t UTF8_ACCEPT = 0;
- static constexpr uint8_t UTF8_REJECT = 1;
+ static constexpr std::uint8_t UTF8_ACCEPT = 0;
+ static constexpr std::uint8_t UTF8_REJECT = 1;
public:
/*!
@@ -298,8 +298,8 @@ class serializer
*/
void dump_escaped(const string_t& s, const bool ensure_ascii)
{
- uint32_t codepoint;
- uint8_t state = UTF8_ACCEPT;
+ std::uint32_t codepoint;
+ std::uint8_t state = UTF8_ACCEPT;
std::size_t bytes = 0; // number of bytes written to string_buffer
// number of bytes written at the point of the last valid byte
@@ -374,14 +374,14 @@ class serializer
if (codepoint <= 0xFFFF)
{
(std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
- static_cast<uint16_t>(codepoint));
+ static_cast<std::uint16_t>(codepoint));
bytes += 6;
}
else
{
(std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
- static_cast<uint16_t>(0xD7C0 + (codepoint >> 10)),
- static_cast<uint16_t>(0xDC00 + (codepoint & 0x3FF)));
+ static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+ static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
bytes += 12;
}
}
@@ -508,7 +508,7 @@ class serializer
case error_handler_t::strict:
{
std::string sn(3, '\0');
- (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<uint8_t>(s.back()));
+ (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
}
@@ -590,16 +590,16 @@ class serializer
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
- {'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'}, {'0', '5'}, {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'},
- {'1', '0'}, {'1', '1'}, {'1', '2'}, {'1', '3'}, {'1', '4'}, {'1', '5'}, {'1', '6'}, {'1', '7'}, {'1', '8'}, {'1', '9'},
- {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'}, {'2', '4'}, {'2', '5'}, {'2', '6'}, {'2', '7'}, {'2', '8'}, {'2', '9'},
- {'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'}, {'3', '5'}, {'3', '6'}, {'3', '7'}, {'3', '8'}, {'3', '9'},
- {'4', '0'}, {'4', '1'}, {'4', '2'}, {'4', '3'}, {'4', '4'}, {'4', '5'}, {'4', '6'}, {'4', '7'}, {'4', '8'}, {'4', '9'},
- {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'}, {'5', '4'}, {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'},
- {'6', '0'}, {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'}, {'6', '5'}, {'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'},
- {'7', '0'}, {'7', '1'}, {'7', '2'}, {'7', '3'}, {'7', '4'}, {'7', '5'}, {'7', '6'}, {'7', '7'}, {'7', '8'}, {'7', '9'},
- {'8', '0'}, {'8', '1'}, {'8', '2'}, {'8', '3'}, {'8', '4'}, {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'},
- {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'}, {'9', '5'}, {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'},
+ {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+ {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+ {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+ {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+ {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+ {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+ {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+ {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+ {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+ {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
@@ -770,9 +770,9 @@ class serializer
@copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
@sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
*/
- static uint8_t decode(uint8_t& state, uint32_t& codep, const uint8_t byte) noexcept
+ static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
{
- static const std::array<uint8_t, 400> utf8d =
+ static const std::array<std::uint8_t, 400> utf8d =
{
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
@@ -792,11 +792,11 @@ class serializer
}
};
- const uint8_t type = utf8d[byte];
+ const std::uint8_t type = utf8d[byte];
codep = (state != UTF8_ACCEPT)
- ? (byte & 0x3fu) | (codep << 6)
- : static_cast<uint32_t>(0xff >> type) & (byte);
+ ? (byte & 0x3fu) | (codep << 6u)
+ : (0xFFu >> type) & (byte);
state = utf8d[256u + state * 16u + type];
return state;
diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp
index 60f453d8..3228f9a2 100644
--- a/include/nlohmann/json.hpp
+++ b/include/nlohmann/json.hpp
@@ -6153,13 +6153,9 @@ class basic_json
const bool strict = true)
{
assert(sax);
- switch (format)
- {
- case input_format_t::json:
- return parser(std::move(i)).sax_parse(sax, strict);
- default:
- return detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
- }
+ return format == input_format_t::json
+ ? parser(std::move(i)).sax_parse(sax, strict)
+ : detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
}
/*!
diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp
index 301f4ed3..897c22d0 100644
--- a/single_include/nlohmann/json.hpp
+++ b/single_include/nlohmann/json.hpp
@@ -2170,6 +2170,7 @@ constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
// #include <nlohmann/detail/input/input_adapters.hpp>
+#include <array> // array
#include <cassert> // assert
#include <cstddef> // size_t
#include <cstring> // strlen
@@ -2325,7 +2326,11 @@ template<typename WideStringType, size_t T>
struct wide_string_input_helper
{
// UTF-32
- static void fill_buffer(const WideStringType& str, size_t& current_wchar, std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, size_t& utf8_bytes_index, size_t& utf8_bytes_filled)
+ static void fill_buffer(const WideStringType& str,
+ size_t& current_wchar,
+ std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+ size_t& utf8_bytes_index,
+ size_t& utf8_bytes_filled)
{
utf8_bytes_index = 0;
@@ -2342,34 +2347,34 @@ struct wide_string_input_helper
// UTF-32 to UTF-8 encoding
if (wc < 0x80)
{
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
else if (wc <= 0x7FF)
{
- utf8_bytes[0] = 0xC0u | ((wc >> 6u) & 0x1Fu);
- utf8_bytes[1] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u) & 0x1Fu));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 2;
}
else if (wc <= 0xFFFF)
{
- utf8_bytes[0] = 0xE0u | ((wc >> 12u) & 0x0Fu);
- utf8_bytes[1] = 0x80u | ((wc >> 6u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u) & 0x0Fu));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 3;
}
else if (wc <= 0x10FFFF)
{
- utf8_bytes[0] = 0xF0u | ((wc >> 18u) & 0x07u);
- utf8_bytes[1] = 0x80u | ((wc >> 12u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | ((wc >> 6u) & 0x3Fu);
- utf8_bytes[3] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((wc >> 18u) & 0x07u));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 12u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+ utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 4;
}
else
{
// unknown character
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
}
@@ -2380,7 +2385,11 @@ template<typename WideStringType>
struct wide_string_input_helper<WideStringType, 2>
{
// UTF-16
- static void fill_buffer(const WideStringType& str, size_t& current_wchar, std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, size_t& utf8_bytes_index, size_t& utf8_bytes_filled)
+ static void fill_buffer(const WideStringType& str,
+ size_t& current_wchar,
+ std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+ size_t& utf8_bytes_index,
+ size_t& utf8_bytes_filled)
{
utf8_bytes_index = 0;
@@ -2397,20 +2406,20 @@ struct wide_string_input_helper<WideStringType, 2>
// UTF-16 to UTF-8 encoding
if (wc < 0x80)
{
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
else if (wc <= 0x7FF)
{
- utf8_bytes[0] = 0xC0u | ((wc >> 6u));
- utf8_bytes[1] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u)));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 2;
}
else if (0xD800 > wc or wc >= 0xE000)
{
- utf8_bytes[0] = 0xE0u | ((wc >> 12u));
- utf8_bytes[1] = 0x80u | ((wc >> 6u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | (wc & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u)));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
utf8_bytes_filled = 3;
}
else
@@ -2419,17 +2428,17 @@ struct wide_string_input_helper<WideStringType, 2>
{
const auto wc2 = static_cast<unsigned int>(str[current_wchar++]);
const auto charcode = 0x10000u + (((wc & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
- utf8_bytes[0] = 0xF0u | (charcode >> 18u);
- utf8_bytes[1] = 0x80u | ((charcode >> 12u) & 0x3Fu);
- utf8_bytes[2] = 0x80u | ((charcode >> 6u) & 0x3Fu);
- utf8_bytes[3] = 0x80u | (charcode & 0x3Fu);
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+ utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+ utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+ utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
utf8_bytes_filled = 4;
}
else
{
// unknown character
++current_wchar;
- utf8_bytes[0] = wc;
+ utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
utf8_bytes_filled = 1;
}
}
@@ -2596,6 +2605,7 @@ class input_adapter
// #include <nlohmann/detail/input/lexer.hpp>
+#include <array> // array
#include <clocale> // localeconv
#include <cstddef> // size_t
#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
@@ -2755,15 +2765,15 @@ class lexer
if (current >= '0' and current <= '9')
{
- codepoint += ((static_cast<unsigned int>(current) - 0x30u) << factor);
+ codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' and current <= 'F')
{
- codepoint += ((static_cast<unsigned int>(current) - 0x37u) << factor);
+ codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' and current <= 'f')
{
- codepoint += ((static_cast<unsigned int>(current) - 0x57u) << factor);
+ codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
@@ -2921,15 +2931,15 @@ class lexer
if (JSON_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
{
// overwrite codepoint
- codepoint =
- // high surrogate occupies the most significant 22 bits
- (static_cast<unsigned int>(codepoint1) << 10u)
- // low surrogate occupies the least significant 15 bits
- + static_cast<unsigned int>(codepoint2)
- // there is still the 0xD800, 0xDC00 and 0x10000 noise
- // in the result so we have to subtract with:
- // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- - 0x35FDC00u;
+ codepoint = static_cast<int>(
+ // high surrogate occupies the most significant 22 bits
+ (static_cast<unsigned int>(codepoint1) << 10u)
+ // low surrogate occupies the least significant 15 bits
+ + static_cast<unsigned int>(codepoint2)
+ // there is still the 0xD800, 0xDC00 and 0x10000 noise
+ // in the result so we have to subtract with:
+ // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+ - 0x35FDC00u);
}
else
{
@@ -2964,23 +2974,23 @@ class lexer
else if (codepoint <= 0x7FF)
{
// 2-byte characters: 110xxxxx 10xxxxxx
- add(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u));
- add(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu));
+ add(static_cast<int>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+ add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else if (codepoint <= 0xFFFF)
{
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
- add(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u));
- add(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu));
- add(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu));
+ add(static_cast<int>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+ add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+ add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else
{
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- add(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u));
- add(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu));
- add(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu));
- add(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu));
+ add(static_cast<int>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+ add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+ add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+ add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
break;
@@ -3959,9 +3969,9 @@ scan_number_done:
if ('\x00' <= c and c <= '\x1F')
{
// escape control characters
- char cs[9];
- (std::snprintf)(cs, 9, "<U+%.4X>", static_cast<unsigned char>(c));
- result += cs;
+ std::array<char, 9> cs{};
+ (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
+ result += cs.data();
}
else
{
@@ -6755,9 +6765,9 @@ class binary_reader
default: // anything else not supported (yet)
{
- char cr[3];
- (std::snprintf)(cr, sizeof(cr), "%.2hhX", static_cast<unsigned char>(element_type));
- return sax->parse_error(element_type_parse_position, std::string(cr), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr)));
+ std::array<char, 3> cr{};
+ (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
+ return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
}
}
}
@@ -6880,25 +6890,25 @@ class binary_reader
case 0x18: // Unsigned integer (one-byte uint8_t follows)
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
case 0x19: // Unsigned integer (two-byte uint16_t follows)
{
- uint16_t number;
+ std::uint16_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
case 0x1A: // Unsigned integer (four-byte uint32_t follows)
{
- uint32_t number;
+ std::uint32_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
{
- uint64_t number;
+ std::uint64_t number;
return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
}
@@ -6927,29 +6937,29 @@ class binary_reader
case 0x35:
case 0x36:
case 0x37:
- return sax->number_integer(static_cast<int8_t>(0x20 - 1 - current));
+ return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
case 0x38: // Negative integer (one-byte uint8_t follows)
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
{
- uint16_t number;
+ std::uint16_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
{
- uint32_t number;
+ std::uint32_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
}
case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
{
- uint64_t number;
+ std::uint64_t number;
return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1)
- static_cast<number_integer_t>(number));
}
@@ -7018,25 +7028,25 @@ class binary_reader
case 0x98: // array (one-byte uint8_t for n follows)
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
case 0x99: // array (two-byte uint16_t for n follow)
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
case 0x9A: // array (four-byte uint32_t for n follow)
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
case 0x9B: // array (eight-byte uint64_t for n follow)
{
- uint64_t len;
+ std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
}
@@ -7072,25 +7082,25 @@ class binary_reader
case 0xB8: // map (one-byte uint8_t for n follows)
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
case 0xB9: // map (two-byte uint16_t for n follow)
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
case 0xBA: // map (four-byte uint32_t for n follow)
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
case 0xBB: // map (eight-byte uint64_t for n follow)
{
- uint64_t len;
+ std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
}
@@ -7130,10 +7140,10 @@ class binary_reader
// without such support. An example of a small decoder for
// half-precision floating-point numbers in the C language
// is shown in Fig. 3.
- const unsigned int half = (byte1 << 8u) + byte2;
+ const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
const double val = [&half]
{
- const unsigned int exp = (half >> 10u) & 0x1Fu;
+ const int exp = (half >> 10u) & 0x1Fu;
const unsigned int mant = half & 0x3FFu;
assert(0 <= exp and exp <= 32);
assert(0 <= mant and mant <= 1024);
@@ -7225,25 +7235,25 @@ class binary_reader
case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
{
- uint64_t len;
+ std::uint64_t len;
return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
}
@@ -7600,49 +7610,49 @@ class binary_reader
case 0xCC: // uint 8
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xCD: // uint 16
{
- uint16_t number;
+ std::uint16_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xCE: // uint 32
{
- uint32_t number;
+ std::uint32_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xCF: // uint 64
{
- uint64_t number;
+ std::uint64_t number;
return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
}
case 0xD0: // int 8
{
- int8_t number;
+ std::int8_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
case 0xD1: // int 16
{
- int16_t number;
+ std::int16_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
case 0xD2: // int 32
{
- int32_t number;
+ std::int32_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
case 0xD3: // int 64
{
- int64_t number;
+ std::int64_t number;
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
@@ -7656,25 +7666,25 @@ class binary_reader
case 0xDC: // array 16
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
}
case 0xDD: // array 32
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
}
case 0xDE: // map 16
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
}
case 0xDF: // map 32
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
}
@@ -7711,7 +7721,7 @@ class binary_reader
case 0xFD:
case 0xFE:
case 0xFF:
- return sax->number_integer(static_cast<int8_t>(current));
+ return sax->number_integer(static_cast<std::int8_t>(current));
default: // anything else
{
@@ -7779,19 +7789,19 @@ class binary_reader
case 0xD9: // str 8
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
}
case 0xDA: // str 16
{
- uint16_t len;
+ std::uint16_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
}
case 0xDB: // str 32
{
- uint32_t len;
+ std::uint32_t len;
return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
}
@@ -7889,7 +7899,7 @@ class binary_reader
{
if (get_char)
{
- get(); // TODO: may we ignore N here?
+ get(); // TODO(niels): may we ignore N here?
}
if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
@@ -7901,31 +7911,31 @@ class binary_reader
{
case 'U':
{
- uint8_t len;
+ std::uint8_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'i':
{
- int8_t len;
+ std::int8_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'I':
{
- int16_t len;
+ std::int16_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'l':
{
- int32_t len;
+ std::int32_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
case 'L':
{
- int64_t len;
+ std::int64_t len;
return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
}
@@ -7945,7 +7955,7 @@ class binary_reader
{
case 'U':
{
- uint8_t number;
+ std::uint8_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -7956,7 +7966,7 @@ class binary_reader
case 'i':
{
- int8_t number;
+ std::int8_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -7967,7 +7977,7 @@ class binary_reader
case 'I':
{
- int16_t number;
+ std::int16_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -7978,7 +7988,7 @@ class binary_reader
case 'l':
{
- int32_t number;
+ std::int32_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -7989,7 +7999,7 @@ class binary_reader
case 'L':
{
- int64_t number;
+ std::int64_t number;
if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
@@ -8044,10 +8054,12 @@ class binary_reader
return get_ubjson_size_value(result.first);
}
- else if (current == '#')
+
+ if (current == '#')
{
return get_ubjson_size_value(result.first);
}
+
return true;
}
@@ -8072,31 +8084,31 @@ class binary_reader
case 'U':
{
- uint8_t number;
+ std::uint8_t number;
return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number);
}
case 'i':
{
- int8_t number;
+ std::int8_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
case 'I':
{
- int16_t number;
+ std::int16_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
case 'l':
{
- int32_t number;
+ std::int32_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
case 'L':
{
- int64_t number;
+ std::int64_t number;
return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
}
@@ -8335,7 +8347,7 @@ class binary_reader
bool get_number(const input_format_t format, NumberType& result)
{
// step 1: read input into array with system's byte order
- std::array<uint8_t, sizeof(NumberType)> vec;
+ std::array<std::uint8_t, sizeof(NumberType)> vec;
for (std::size_t i = 0; i < sizeof(NumberType); ++i)
{
get();
@@ -8347,11 +8359,11 @@ class binary_reader
// reverse byte order prior to conversion if necessary
if (is_little_endian != InputIsLittleEndian)
{
- vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);
+ vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
}
else
{
- vec[i] = static_cast<uint8_t>(current); // LCOV_EXCL_LINE
+ vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
}
}
@@ -8412,9 +8424,9 @@ class binary_reader
*/
std::string get_token_string() const
{
- char cr[3];
- (std::snprintf)(cr, 3, "%.2hhX", static_cast<unsigned char>(current));
- return std::string{cr};
+ std::array<char, 3> cr{};
+ (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
+ return std::string{cr.data()};
}
/*!
@@ -8568,27 +8580,27 @@ class binary_writer
// code from the value_t::number_unsigned case here.
if (j.m_value.number_integer <= 0x17)
{
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x18));
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x19));
- write_number(static_cast<uint16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x1A));
- write_number(static_cast<uint32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
else
{
oa->write_character(to_char_type(0x1B));
- write_number(static_cast<uint64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
}
else
@@ -8598,27 +8610,27 @@ class binary_writer
const auto positive_number = -1 - j.m_value.number_integer;
if (j.m_value.number_integer >= -24)
{
- write_number(static_cast<uint8_t>(0x20 + positive_number));
+ write_number(static_cast<std::uint8_t>(0x20 + positive_number));
}
- else if (positive_number <= (std::numeric_limits<uint8_t>::max)())
+ else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x38));
- write_number(static_cast<uint8_t>(positive_number));
+ write_number(static_cast<std::uint8_t>(positive_number));
}
- else if (positive_number <= (std::numeric_limits<uint16_t>::max)())
+ else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x39));
- write_number(static_cast<uint16_t>(positive_number));
+ write_number(static_cast<std::uint16_t>(positive_number));
}
- else if (positive_number <= (std::numeric_limits<uint32_t>::max)())
+ else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x3A));
- write_number(static_cast<uint32_t>(positive_number));
+ write_number(static_cast<std::uint32_t>(positive_number));
}
else
{
oa->write_character(to_char_type(0x3B));
- write_number(static_cast<uint64_t>(positive_number));
+ write_number(static_cast<std::uint64_t>(positive_number));
}
}
break;
@@ -8628,27 +8640,27 @@ class binary_writer
{
if (j.m_value.number_unsigned <= 0x17)
{
- write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x18));
- write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x19));
- write_number(static_cast<uint16_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x1A));
- write_number(static_cast<uint32_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
}
else
{
oa->write_character(to_char_type(0x1B));
- write_number(static_cast<uint64_t>(j.m_value.number_unsigned));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
}
break;
}
@@ -8666,28 +8678,28 @@ class binary_writer
const auto N = j.m_value.string->size();
if (N <= 0x17)
{
- write_number(static_cast<uint8_t>(0x60 + N));
+ write_number(static_cast<std::uint8_t>(0x60 + N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x78));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x79));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x7A));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
- else if (N <= (std::numeric_limits<uint64_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0x7B));
- write_number(static_cast<uint64_t>(N));
+ write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
@@ -8704,28 +8716,28 @@ class binary_writer
const auto N = j.m_value.array->size();
if (N <= 0x17)
{
- write_number(static_cast<uint8_t>(0x80 + N));
+ write_number(static_cast<std::uint8_t>(0x80 + N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0x98));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0x99));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0x9A));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
- else if (N <= (std::numeric_limits<uint64_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0x9B));
- write_number(static_cast<uint64_t>(N));
+ write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
@@ -8743,28 +8755,28 @@ class binary_writer
const auto N = j.m_value.object->size();
if (N <= 0x17)
{
- write_number(static_cast<uint8_t>(0xA0 + N));
+ write_number(static_cast<std::uint8_t>(0xA0 + N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
oa->write_character(to_char_type(0xB8));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
oa->write_character(to_char_type(0xB9));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
oa->write_character(to_char_type(0xBA));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// LCOV_EXCL_START
- else if (N <= (std::numeric_limits<uint64_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint64_t>::max)())
{
oa->write_character(to_char_type(0xBB));
- write_number(static_cast<uint64_t>(N));
+ write_number(static_cast<std::uint64_t>(N));
}
// LCOV_EXCL_STOP
@@ -8813,31 +8825,31 @@ class binary_writer
if (j.m_value.number_unsigned < 128)
{
// positive fixnum
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
// uint 8
oa->write_character(to_char_type(0xCC));
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
// uint 16
oa->write_character(to_char_type(0xCD));
- write_number(static_cast<uint16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
// uint 32
oa->write_character(to_char_type(0xCE));
- write_number(static_cast<uint32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
{
// uint 64
oa->write_character(to_char_type(0xCF));
- write_number(static_cast<uint64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
}
else
@@ -8845,35 +8857,35 @@ class binary_writer
if (j.m_value.number_integer >= -32)
{
// negative fixnum
- write_number(static_cast<int8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int8_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
// int 8
oa->write_character(to_char_type(0xD0));
- write_number(static_cast<int8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int16_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
// int 16
oa->write_character(to_char_type(0xD1));
- write_number(static_cast<int16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int32_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
// int 32
oa->write_character(to_char_type(0xD2));
- write_number(static_cast<int32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_integer >= (std::numeric_limits<int64_t>::min)() and
- j.m_value.number_integer <= (std::numeric_limits<int64_t>::max)())
+ else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() and
+ j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
{
// int 64
oa->write_character(to_char_type(0xD3));
- write_number(static_cast<int64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::int64_t>(j.m_value.number_integer));
}
}
break;
@@ -8884,31 +8896,31 @@ class binary_writer
if (j.m_value.number_unsigned < 128)
{
// positive fixnum
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
// uint 8
oa->write_character(to_char_type(0xCC));
- write_number(static_cast<uint8_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
{
// uint 16
oa->write_character(to_char_type(0xCD));
- write_number(static_cast<uint16_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
{
// uint 32
oa->write_character(to_char_type(0xCE));
- write_number(static_cast<uint32_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
}
- else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())
+ else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
{
// uint 64
oa->write_character(to_char_type(0xCF));
- write_number(static_cast<uint64_t>(j.m_value.number_integer));
+ write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
}
break;
}
@@ -8927,25 +8939,25 @@ class binary_writer
if (N <= 31)
{
// fixstr
- write_number(static_cast<uint8_t>(0xA0 | N));
+ write_number(static_cast<std::uint8_t>(0xA0 | N));
}
- else if (N <= (std::numeric_limits<uint8_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint8_t>::max)())
{
// str 8
oa->write_character(to_char_type(0xD9));
- write_number(static_cast<uint8_t>(N));
+ write_number(static_cast<std::uint8_t>(N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// str 16
oa->write_character(to_char_type(0xDA));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// str 32
oa->write_character(to_char_type(0xDB));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// step 2: write the string
@@ -8962,19 +8974,19 @@ class binary_writer
if (N <= 15)
{
// fixarray
- write_number(static_cast<uint8_t>(0x90 | N));
+ write_number(static_cast<std::uint8_t>(0x90 | N));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// array 16
oa->write_character(to_char_type(0xDC));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// array 32
oa->write_character(to_char_type(0xDD));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// step 2: write each element
@@ -8992,19 +9004,19 @@ class binary_writer
if (N <= 15)
{
// fixmap
- write_number(static_cast<uint8_t>(0x80 | (N & 0xF)));
+ write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
}
- else if (N <= (std::numeric_limits<uint16_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint16_t>::max)())
{
// map 16
oa->write_character(to_char_type(0xDE));
- write_number(static_cast<uint16_t>(N));
+ write_number(static_cast<std::uint16_t>(N));
}
- else if (N <= (std::numeric_limits<uint32_t>::max)())
+ else if (N <= (std::numeric_limits<std::uint32_t>::max)())
{
// map 32
oa->write_character(to_char_type(0xDF));
- write_number(static_cast<uint32_t>(N));
+ write_number(static_cast<std::uint32_t>(N));
}
// step 2: write each element
@@ -9270,14 +9282,9 @@ class binary_writer
*/
static std::size_t calc_bson_integer_size(const std::int64_t value)
{
- if ((std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)())
- {
- return sizeof(std::int32_t);
- }
- else
- {
- return sizeof(std::int64_t);
- }
+ return (std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)()
+ ? sizeof(std::int32_t)
+ : sizeof(std::int64_t);
}
/*!
@@ -9545,45 +9552,45 @@ class binary_writer
void write_number_with_ubjson_prefix(const NumberType n,
const bool add_prefix)
{
- if (n <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)()))
+ if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('i')); // int8
}
- write_number(static_cast<uint8_t>(n));
+ write_number(static_cast<std::uint8_t>(n));
}
- else if (n <= (std::numeric_limits<uint8_t>::max)())
+ else if (n <= (std::numeric_limits<std::uint8_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('U')); // uint8
}
- write_number(static_cast<uint8_t>(n));
+ write_number(static_cast<std::uint8_t>(n));
}
- else if (n <= static_cast<uint64_t>((std::numeric_limits<int16_t>::max)()))
+ else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('I')); // int16
}
- write_number(static_cast<int16_t>(n));
+ write_number(static_cast<std::int16_t>(n));
}
- else if (n <= static_cast<uint64_t>((std::numeric_limits<int32_t>::max)()))
+ else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('l')); // int32
}
- write_number(static_cast<int32_t>(n));
+ write_number(static_cast<std::int32_t>(n));
}
- else if (n <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
+ else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('L')); // int64
}
- write_number(static_cast<int64_t>(n));
+ write_number(static_cast<std::int64_t>(n));
}
else
{
@@ -9598,45 +9605,45 @@ class binary_writer
void write_number_with_ubjson_prefix(const NumberType n,
const bool add_prefix)
{
- if ((std::numeric_limits<int8_t>::min)() <= n and n <= (std::numeric_limits<int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= n and n <= (std::numeric_limits<std::int8_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('i')); // int8
}
- write_number(static_cast<int8_t>(n));
+ write_number(static_cast<std::int8_t>(n));
}
- else if (static_cast<int64_t>((std::numeric_limits<uint8_t>::min)()) <= n and n <= static_cast<int64_t>((std::numeric_limits<uint8_t>::max)()))
+ else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n and n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
{
if (add_prefix)
{
oa->write_character(to_char_type('U')); // uint8
}
- write_number(static_cast<uint8_t>(n));
+ write_number(static_cast<std::uint8_t>(n));
}
- else if ((std::numeric_limits<int16_t>::min)() <= n and n <= (std::numeric_limits<int16_t>::max)())
+ else if ((std::numeric_limits<std::int16_t>::min)() <= n and n <= (std::numeric_limits<std::int16_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('I')); // int16
}
- write_number(static_cast<int16_t>(n));
+ write_number(static_cast<std::int16_t>(n));
}
- else if ((std::numeric_limits<int32_t>::min)() <= n and n <= (std::numeric_limits<int32_t>::max)())
+ else if ((std::numeric_limits<std::int32_t>::min)() <= n and n <= (std::numeric_limits<std::int32_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('l')); // int32
}
- write_number(static_cast<int32_t>(n));
+ write_number(static_cast<std::int32_t>(n));
}
- else if ((std::numeric_limits<int64_t>::min)() <= n and n <= (std::numeric_limits<int64_t>::max)())
+ else if ((std::numeric_limits<std::int64_t>::min)() <= n and n <= (std::numeric_limits<std::int64_t>::max)())
{
if (add_prefix)
{
oa->write_character(to_char_type('L')); // int64
}
- write_number(static_cast<int64_t>(n));
+ write_number(static_cast<std::int64_t>(n));
}
// LCOV_EXCL_START
else
@@ -9667,19 +9674,19 @@ class binary_writer
case value_t::number_integer:
{
- if ((std::numeric_limits<int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())
+ if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
- if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
+ if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
- if ((std::numeric_limits<int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())
+ if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
- if ((std::numeric_limits<int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())
+ if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
@@ -9689,19 +9696,19 @@ class binary_writer
case value_t::number_unsigned:
{
- if (j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
- if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
- if (j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
- if (j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)())
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
@@ -9841,6 +9848,7 @@ class binary_writer
// #include <nlohmann/detail/conversions/to_chars.hpp>
+#include <array> // array
#include <cassert> // assert
#include <ciso646> // or, and, not
#include <cmath> // signbit, isfinite
@@ -9890,10 +9898,10 @@ struct diyfp // f * 2^e
{
static constexpr int kPrecision = 64; // = q
- uint64_t f = 0;
+ std::uint64_t f = 0;
int e = 0;
- constexpr diyfp(uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+ constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
/*!
@brief returns x - y
@@ -9938,23 +9946,23 @@ struct diyfp // f * 2^e
//
// = p_lo + 2^64 p_hi
- const uint64_t u_lo = x.f & 0xFFFFFFFF;
- const uint64_t u_hi = x.f >> 32;
- const uint64_t v_lo = y.f & 0xFFFFFFFF;
- const uint64_t v_hi = y.f >> 32;
+ const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+ const std::uint64_t u_hi = x.f >> 32u;
+ const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+ const std::uint64_t v_hi = y.f >> 32u;
- const uint64_t p0 = u_lo * v_lo;
- const uint64_t p1 = u_lo * v_hi;
- const uint64_t p2 = u_hi * v_lo;
- const uint64_t p3 = u_hi * v_hi;
+ const std::uint64_t p0 = u_lo * v_lo;
+ const std::uint64_t p1 = u_lo * v_hi;
+ const std::uint64_t p2 = u_hi * v_lo;
+ const std::uint64_t p3 = u_hi * v_hi;
- const uint64_t p0_hi = p0 >> 32;
- const uint64_t p1_lo = p1 & 0xFFFFFFFF;
- const uint64_t p1_hi = p1 >> 32;
- const uint64_t p2_lo = p2 & 0xFFFFFFFF;
- const uint64_t p2_hi = p2 >> 32;
+ const std::uint64_t p0_hi = p0 >> 32u;
+ const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+ const std::uint64_t p1_hi = p1 >> 32u;
+ const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+ const std::uint64_t p2_hi = p2 >> 32u;
- uint64_t Q = p0_hi + p1_lo + p2_lo;
+ std::uint64_t Q = p0_hi + p1_lo + p2_lo;
// The full product might now be computed as
//
@@ -9965,9 +9973,9 @@ struct diyfp // f * 2^e
// Effectively we only need to add the highest bit in p_lo to p_hi (and
// Q_hi + 1 does not overflow).
- Q += uint64_t{1} << (64 - 32 - 1); // round, ties up
+ Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
- const uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32);
+ const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
return {h, x.e + y.e + 64};
}
@@ -9980,9 +9988,9 @@ struct diyfp // f * 2^e
{
assert(x.f != 0);
- while ((x.f >> 63) == 0)
+ while ((x.f >> 63u) == 0)
{
- x.f <<= 1;
+ x.f <<= 1u;
x.e--;
}
@@ -10036,13 +10044,13 @@ boundaries compute_boundaries(FloatType value)
constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
constexpr int kMinExp = 1 - kBias;
- constexpr uint64_t kHiddenBit = uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+ constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
- using bits_type = typename std::conditional< kPrecision == 24, uint32_t, uint64_t >::type;
+ using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
- const uint64_t bits = reinterpret_bits<bits_type>(value);
- const uint64_t E = bits >> (kPrecision - 1);
- const uint64_t F = bits & (kHiddenBit - 1);
+ const std::uint64_t bits = reinterpret_bits<bits_type>(value);
+ const std::uint64_t E = bits >> (kPrecision - 1);
+ const std::uint64_t F = bits & (kHiddenBit - 1);
const bool is_denormal = (E == 0);
const diyfp v = is_denormal
@@ -10145,7 +10153,7 @@ constexpr int kGamma = -32;
struct cached_power // c = f * 2^e ~= 10^k
{
- uint64_t f;
+ std::uint64_t f;
int e;
int k;
};
@@ -10209,91 +10217,92 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
// NB:
// Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
- constexpr int kCachedPowersSize = 79;
constexpr int kCachedPowersMinDecExp = -300;
constexpr int kCachedPowersDecStep = 8;
- static constexpr cached_power kCachedPowers[] =
+ static constexpr std::array<cached_power, 79> kCachedPowers =
{
- { 0xAB70FE17C79AC6CA, -1060, -300 },
- { 0xFF77B1FCBEBCDC4F, -1034, -292 },
- { 0xBE5691EF416BD60C, -1007, -284 },
- { 0x8DD01FAD907FFC3C, -980, -276 },
- { 0xD3515C2831559A83, -954, -268 },
- { 0x9D71AC8FADA6C9B5, -927, -260 },
- { 0xEA9C227723EE8BCB, -901, -252 },
- { 0xAECC49914078536D, -874, -244 },
- { 0x823C12795DB6CE57, -847, -236 },
- { 0xC21094364DFB5637, -821, -228 },
- { 0x9096EA6F3848984F, -794, -220 },
- { 0xD77485CB25823AC7, -768, -212 },
- { 0xA086CFCD97BF97F4, -741, -204 },
- { 0xEF340A98172AACE5, -715, -196 },
- { 0xB23867FB2A35B28E, -688, -188 },
- { 0x84C8D4DFD2C63F3B, -661, -180 },
- { 0xC5DD44271AD3CDBA, -635, -172 },
- { 0x936B9FCEBB25C996, -608, -164 },
- { 0xDBAC6C247D62A584, -582, -156 },
- { 0xA3AB66580D5FDAF6, -555, -148 },
- { 0xF3E2F893DEC3F126, -529, -140 },
- { 0xB5B5ADA8AAFF80B8, -502, -132 },
- { 0x87625F056C7C4A8B, -475, -124 },
- { 0xC9BCFF6034C13053, -449, -116 },
- { 0x964E858C91BA2655, -422, -108 },
- { 0xDFF9772470297EBD, -396, -100 },
- { 0xA6DFBD9FB8E5B88F, -369, -92 },
- { 0xF8A95FCF88747D94, -343, -84 },
- { 0xB94470938FA89BCF, -316, -76 },
- { 0x8A08F0F8BF0F156B, -289, -68 },
- { 0xCDB02555653131B6, -263, -60 },
- { 0x993FE2C6D07B7FAC, -236, -52 },
- { 0xE45C10C42A2B3B06, -210, -44 },
- { 0xAA242499697392D3, -183, -36 },
- { 0xFD87B5F28300CA0E, -157, -28 },
- { 0xBCE5086492111AEB, -130, -20 },
- { 0x8CBCCC096F5088CC, -103, -12 },
- { 0xD1B71758E219652C, -77, -4 },
- { 0x9C40000000000000, -50, 4 },
- { 0xE8D4A51000000000, -24, 12 },
- { 0xAD78EBC5AC620000, 3, 20 },
- { 0x813F3978F8940984, 30, 28 },
- { 0xC097CE7BC90715B3, 56, 36 },
- { 0x8F7E32CE7BEA5C70, 83, 44 },
- { 0xD5D238A4ABE98068, 109, 52 },
- { 0x9F4F2726179A2245, 136, 60 },
- { 0xED63A231D4C4FB27, 162, 68 },
- { 0xB0DE65388CC8ADA8, 189, 76 },
- { 0x83C7088E1AAB65DB, 216, 84 },
- { 0xC45D1DF942711D9A, 242, 92 },
- { 0x924D692CA61BE758, 269, 100 },
- { 0xDA01EE641A708DEA, 295, 108 },
- { 0xA26DA3999AEF774A, 322, 116 },
- { 0xF209787BB47D6B85, 348, 124 },
- { 0xB454E4A179DD1877, 375, 132 },
- { 0x865B86925B9BC5C2, 402, 140 },
- { 0xC83553C5C8965D3D, 428, 148 },
- { 0x952AB45CFA97A0B3, 455, 156 },
- { 0xDE469FBD99A05FE3, 481, 164 },
- { 0xA59BC234DB398C25, 508, 172 },
- { 0xF6C69A72A3989F5C, 534, 180 },
- { 0xB7DCBF5354E9BECE, 561, 188 },
- { 0x88FCF317F22241E2, 588, 196 },
- { 0xCC20CE9BD35C78A5, 614, 204 },
- { 0x98165AF37B2153DF, 641, 212 },
- { 0xE2A0B5DC971F303A, 667, 220 },
- { 0xA8D9D1535CE3B396, 694, 228 },
- { 0xFB9B7CD9A4A7443C, 720, 236 },
- { 0xBB764C4CA7A44410, 747, 244 },
- { 0x8BAB8EEFB6409C1A, 774, 252 },
- { 0xD01FEF10A657842C, 800, 260 },
- { 0x9B10A4E5E9913129, 827, 268 },
- { 0xE7109BFBA19C0C9D, 853, 276 },
- { 0xAC2820D9623BF429, 880, 284 },
- { 0x80444B5E7AA7CF85, 907, 292 },
- { 0xBF21E44003ACDD2D, 933, 300 },
- { 0x8E679C2F5E44FF8F, 960, 308 },
- { 0xD433179D9C8CB841, 986, 316 },
- { 0x9E19DB92B4E31BA9, 1013, 324 },
+ {
+ { 0xAB70FE17C79AC6CA, -1060, -300 },
+ { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+ { 0xBE5691EF416BD60C, -1007, -284 },
+ { 0x8DD01FAD907FFC3C, -980, -276 },
+ { 0xD3515C2831559A83, -954, -268 },
+ { 0x9D71AC8FADA6C9B5, -927, -260 },
+ { 0xEA9C227723EE8BCB, -901, -252 },
+ { 0xAECC49914078536D, -874, -244 },
+ { 0x823C12795DB6CE57, -847, -236 },
+ { 0xC21094364DFB5637, -821, -228 },
+ { 0x9096EA6F3848984F, -794, -220 },
+ { 0xD77485CB25823AC7, -768, -212 },
+ { 0xA086CFCD97BF97F4, -741, -204 },
+ { 0xEF340A98172AACE5, -715, -196 },
+ { 0xB23867FB2A35B28E, -688, -188 },
+ { 0x84C8D4DFD2C63F3B, -661, -180 },
+ { 0xC5DD44271AD3CDBA, -635, -172 },
+ { 0x936B9FCEBB25C996, -608, -164 },
+ { 0xDBAC6C247D62A584, -582, -156 },
+ { 0xA3AB66580D5FDAF6, -555, -148 },
+ { 0xF3E2F893DEC3F126, -529, -140 },
+ { 0xB5B5ADA8AAFF80B8, -502, -132 },
+ { 0x87625F056C7C4A8B, -475, -124 },
+ { 0xC9BCFF6034C13053, -449, -116 },
+ { 0x964E858C91BA2655, -422, -108 },
+ { 0xDFF9772470297EBD, -396, -100 },
+ { 0xA6DFBD9FB8E5B88F, -369, -92 },
+ { 0xF8A95FCF88747D94, -343, -84 },
+ { 0xB94470938FA89BCF, -316, -76 },
+ { 0x8A08F0F8BF0F156B, -289, -68 },
+ { 0xCDB02555653131B6, -263, -60 },
+ { 0x993FE2C6D07B7FAC, -236, -52 },
+ { 0xE45C10C42A2B3B06, -210, -44 },
+ { 0xAA242499697392D3, -183, -36 },
+ { 0xFD87B5F28300CA0E, -157, -28 },
+ { 0xBCE5086492111AEB, -130, -20 },
+ { 0x8CBCCC096F5088CC, -103, -12 },
+ { 0xD1B71758E219652C, -77, -4 },
+ { 0x9C40000000000000, -50, 4 },
+ { 0xE8D4A51000000000, -24, 12 },
+ { 0xAD78EBC5AC620000, 3, 20 },
+ { 0x813F3978F8940984, 30, 28 },
+ { 0xC097CE7BC90715B3, 56, 36 },
+ { 0x8F7E32CE7BEA5C70, 83, 44 },
+ { 0xD5D238A4ABE98068, 109, 52 },
+ { 0x9F4F2726179A2245, 136, 60 },
+ { 0xED63A231D4C4FB27, 162, 68 },
+ { 0xB0DE65388CC8ADA8, 189, 76 },
+ { 0x83C7088E1AAB65DB, 216, 84 },
+ { 0xC45D1DF942711D9A, 242, 92 },
+ { 0x924D692CA61BE758, 269, 100 },
+ { 0xDA01EE641A708DEA, 295, 108 },
+ { 0xA26DA3999AEF774A, 322, 116 },
+ { 0xF209787BB47D6B85, 348, 124 },
+ { 0xB454E4A179DD1877, 375, 132 },
+ { 0x865B86925B9BC5C2, 402, 140 },
+ { 0xC83553C5C8965D3D, 428, 148 },
+ { 0x952AB45CFA97A0B3, 455, 156 },
+ { 0xDE469FBD99A05FE3, 481, 164 },
+ { 0xA59BC234DB398C25, 508, 172 },
+ { 0xF6C69A72A3989F5C, 534, 180 },
+ { 0xB7DCBF5354E9BECE, 561, 188 },
+ { 0x88FCF317F22241E2, 588, 196 },
+ { 0xCC20CE9BD35C78A5, 614, 204 },
+ { 0x98165AF37B2153DF, 641, 212 },
+ { 0xE2A0B5DC971F303A, 667, 220 },
+ { 0xA8D9D1535CE3B396, 694, 228 },
+ { 0xFB9B7CD9A4A7443C, 720, 236 },
+ { 0xBB764C4CA7A44410, 747, 244 },
+ { 0x8BAB8EEFB6409C1A, 774, 252 },
+ { 0xD01FEF10A657842C, 800, 260 },
+ { 0x9B10A4E5E9913129, 827, 268 },
+ { 0xE7109BFBA19C0C9D, 853, 276 },
+ { 0xAC2820D9623BF429, 880, 284 },
+ { 0x80444B5E7AA7CF85, 907, 292 },
+ { 0xBF21E44003ACDD2D, 933, 300 },
+ { 0x8E679C2F5E44FF8F, 960, 308 },
+ { 0xD433179D9C8CB841, 986, 316 },
+ { 0x9E19DB92B4E31BA9, 1013, 324 },
+ }
};
// This computation gives exactly the same results for k as
@@ -10307,10 +10316,9 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
assert(index >= 0);
- assert(index < kCachedPowersSize);
- static_cast<void>(kCachedPowersSize); // Fix warning.
+ assert(static_cast<std::size_t>(index) < kCachedPowers.size());
- const cached_power cached = kCachedPowers[index];
+ const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
assert(kAlpha <= cached.e + e + 64);
assert(kGamma >= cached.e + e + 64);
@@ -10321,7 +10329,7 @@ inline cached_power get_cached_power_for_binary_exponent(int e)
For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
For n == 0, returns 1 and sets pow10 := 1.
*/
-inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
{
// LCOV_EXCL_START
if (n >= 1000000000)
@@ -10377,8 +10385,8 @@ inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)
}
}
-inline void grisu2_round(char* buf, int len, uint64_t dist, uint64_t delta,
- uint64_t rest, uint64_t ten_k)
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+ std::uint64_t rest, std::uint64_t ten_k)
{
assert(len >= 1);
assert(dist <= delta);
@@ -10439,8 +10447,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
assert(M_plus.e >= kAlpha);
assert(M_plus.e <= kGamma);
- uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
- uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
+ std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+ std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
@@ -10449,10 +10457,10 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
- const diyfp one(uint64_t{1} << -M_plus.e, M_plus.e);
+ const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
- auto p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
- uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
+ auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+ std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
@@ -10460,7 +10468,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
assert(p1 > 0);
- uint32_t pow10;
+ std::uint32_t pow10;
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
@@ -10488,8 +10496,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
- const uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
- const uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
+ const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
+ const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
@@ -10514,7 +10522,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
- const uint64_t rest = (uint64_t{p1} << -one.e) + p2;
+ const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
@@ -10530,7 +10538,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
- const uint64_t ten_n = uint64_t{pow10} << -one.e;
+ const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
@@ -10594,8 +10602,8 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
assert(p2 <= std::numeric_limits<std::uint64_t>::max() / 10);
p2 *= 10;
- const uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
- const uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+ const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
+ const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
@@ -10635,7 +10643,7 @@ inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
- const uint64_t ten_m = one.f;
+ const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
@@ -10770,7 +10778,7 @@ inline char* append_exponent(char* buf, int e)
*buf++ = '+';
}
- auto k = static_cast<uint32_t>(e);
+ auto k = static_cast<std::uint32_t>(e);
if (k < 10)
{
// Always print at least two digits in the exponent.
@@ -10970,8 +10978,8 @@ class serializer
using number_float_t = typename BasicJsonType::number_float_t;
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
- static constexpr uint8_t UTF8_ACCEPT = 0;
- static constexpr uint8_t UTF8_REJECT = 1;
+ static constexpr std::uint8_t UTF8_ACCEPT = 0;
+ static constexpr std::uint8_t UTF8_REJECT = 1;
public:
/*!
@@ -11223,8 +11231,8 @@ class serializer
*/
void dump_escaped(const string_t& s, const bool ensure_ascii)
{
- uint32_t codepoint;
- uint8_t state = UTF8_ACCEPT;
+ std::uint32_t codepoint;
+ std::uint8_t state = UTF8_ACCEPT;
std::size_t bytes = 0; // number of bytes written to string_buffer
// number of bytes written at the point of the last valid byte
@@ -11299,14 +11307,14 @@ class serializer
if (codepoint <= 0xFFFF)
{
(std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
- static_cast<uint16_t>(codepoint));
+ static_cast<std::uint16_t>(codepoint));
bytes += 6;
}
else
{
(std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
- static_cast<uint16_t>(0xD7C0 + (codepoint >> 10)),
- static_cast<uint16_t>(0xDC00 + (codepoint & 0x3FF)));
+ static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+ static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
bytes += 12;
}
}
@@ -11433,7 +11441,7 @@ class serializer
case error_handler_t::strict:
{
std::string sn(3, '\0');
- (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<uint8_t>(s.back()));
+ (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
}
@@ -11515,16 +11523,16 @@ class serializer
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
- {'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'}, {'0', '5'}, {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'},
- {'1', '0'}, {'1', '1'}, {'1', '2'}, {'1', '3'}, {'1', '4'}, {'1', '5'}, {'1', '6'}, {'1', '7'}, {'1', '8'}, {'1', '9'},
- {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'}, {'2', '4'}, {'2', '5'}, {'2', '6'}, {'2', '7'}, {'2', '8'}, {'2', '9'},
- {'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'}, {'3', '5'}, {'3', '6'}, {'3', '7'}, {'3', '8'}, {'3', '9'},
- {'4', '0'}, {'4', '1'}, {'4', '2'}, {'4', '3'}, {'4', '4'}, {'4', '5'}, {'4', '6'}, {'4', '7'}, {'4', '8'}, {'4', '9'},
- {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'}, {'5', '4'}, {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'},
- {'6', '0'}, {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'}, {'6', '5'}, {'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'},
- {'7', '0'}, {'7', '1'}, {'7', '2'}, {'7', '3'}, {'7', '4'}, {'7', '5'}, {'7', '6'}, {'7', '7'}, {'7', '8'}, {'7', '9'},
- {'8', '0'}, {'8', '1'}, {'8', '2'}, {'8', '3'}, {'8', '4'}, {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'},
- {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'}, {'9', '5'}, {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'},
+ {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+ {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+ {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+ {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+ {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+ {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+ {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+ {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+ {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+ {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
@@ -11695,9 +11703,9 @@ class serializer
@copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
@sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
*/
- static uint8_t decode(uint8_t& state, uint32_t& codep, const uint8_t byte) noexcept
+ static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
{
- static const std::array<uint8_t, 400> utf8d =
+ static const std::array<std::uint8_t, 400> utf8d =
{
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
@@ -11717,11 +11725,11 @@ class serializer
}
};
- const uint8_t type = utf8d[byte];
+ const std::uint8_t type = utf8d[byte];
codep = (state != UTF8_ACCEPT)
- ? (byte & 0x3fu) | (codep << 6)
- : static_cast<uint32_t>(0xff >> type) & (byte);
+ ? (byte & 0x3fu) | (codep << 6u)
+ : (0xFFu >> type) & (byte);
state = utf8d[256u + state * 16u + type];
return state;
@@ -18740,13 +18748,9 @@ class basic_json
const bool strict = true)
{
assert(sax);
- switch (format)
- {
- case input_format_t::json:
- return parser(std::move(i)).sax_parse(sax, strict);
- default:
- return detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
- }
+ return format == input_format_t::json
+ ? parser(std::move(i)).sax_parse(sax, strict)
+ : detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
}
/*!