From fc4f5fd05f8eb0458b9ab9e1c727000d0e57b5b7 Mon Sep 17 00:00:00 2001 From: Benoit Blanchon Date: Wed, 14 Apr 2021 11:42:53 +0200 Subject: [PATCH] Changed integer storage from positive/negative to signed/unsigned --- extras/tests/JsonVariant/as.cpp | 17 +++ .../MsgPackSerializer/serializeVariant.cpp | 10 +- extras/tests/Numbers/parseInteger.cpp | 1 + extras/tests/Numbers/parseNumber.cpp | 22 +++- extras/tests/TextFormatter/CMakeLists.txt | 1 + extras/tests/TextFormatter/writeInteger.cpp | 55 ++++++++++ src/ArduinoJson/Json/JsonSerializer.hpp | 8 +- src/ArduinoJson/Json/TextFormatter.hpp | 32 +++--- src/ArduinoJson/MsgPack/MsgPackSerializer.hpp | 31 +++--- src/ArduinoJson/Numbers/convertNumber.hpp | 100 +++++++++--------- src/ArduinoJson/Numbers/parseNumber.hpp | 16 ++- src/ArduinoJson/Variant/VariantCompare.hpp | 36 ++----- src/ArduinoJson/Variant/VariantContent.hpp | 8 +- src/ArduinoJson/Variant/VariantData.hpp | 54 +++------- src/ArduinoJson/Variant/VariantImpl.hpp | 27 ++--- src/ArduinoJson/Variant/Visitor.hpp | 4 +- 16 files changed, 251 insertions(+), 171 deletions(-) create mode 100644 extras/tests/TextFormatter/writeInteger.cpp diff --git a/extras/tests/JsonVariant/as.cpp b/extras/tests/JsonVariant/as.cpp index 783bf7af..843f17dd 100644 --- a/extras/tests/JsonVariant/as.cpp +++ b/extras/tests/JsonVariant/as.cpp @@ -76,11 +76,28 @@ TEST_CASE("JsonVariant::as()") { REQUIRE(variant.as() == "-42"); } + SECTION("set(42UL)") { + variant.set(42UL); + + REQUIRE(variant.as() == true); + REQUIRE(variant.as() == 42.0); + REQUIRE(variant.as() == "42"); + } + SECTION("set(0L)") { variant.set(0L); REQUIRE(variant.as() == false); REQUIRE(variant.as() == 0.0); + REQUIRE(variant.as() == "0"); + } + + SECTION("set(0UL)") { + variant.set(0UL); + + REQUIRE(variant.as() == false); + REQUIRE(variant.as() == 0.0); + REQUIRE(variant.as() == "0"); } SECTION("set(null)") { diff --git a/extras/tests/MsgPackSerializer/serializeVariant.cpp b/extras/tests/MsgPackSerializer/serializeVariant.cpp index fbfa9e4a..9b61f533 100644 --- a/extras/tests/MsgPackSerializer/serializeVariant.cpp +++ b/extras/tests/MsgPackSerializer/serializeVariant.cpp @@ -46,8 +46,14 @@ TEST_CASE("serialize MsgPack value") { } SECTION("positive fixint") { - checkVariant(0, "\x00"); - checkVariant(127, "\x7F"); + SECTION("signed") { + checkVariant(0, "\x00"); + checkVariant(127, "\x7F"); + } + SECTION("unsigned") { + checkVariant(0U, "\x00"); + checkVariant(127U, "\x7F"); + } } SECTION("uint 8") { diff --git a/extras/tests/Numbers/parseInteger.cpp b/extras/tests/Numbers/parseInteger.cpp index 1da365c2..a5a9039b 100644 --- a/extras/tests/Numbers/parseInteger.cpp +++ b/extras/tests/Numbers/parseInteger.cpp @@ -47,6 +47,7 @@ TEST_CASE("parseNumber()") { TEST_CASE("parseNumber()") { checkInteger("0", 0); + checkInteger("-0", 0); checkInteger("255", 255); checkInteger("+255", 255); checkInteger("3.14", 3); diff --git a/extras/tests/Numbers/parseNumber.cpp b/extras/tests/Numbers/parseNumber.cpp index 026cc13a..91c98e3c 100644 --- a/extras/tests/Numbers/parseNumber.cpp +++ b/extras/tests/Numbers/parseNumber.cpp @@ -23,7 +23,27 @@ TEST_CASE("Test unsigned integer overflow") { parseNumber("4294967296", second); } - REQUIRE(first.type() == uint8_t(VALUE_IS_POSITIVE_INTEGER)); + REQUIRE(first.type() == uint8_t(VALUE_IS_UNSIGNED_INTEGER)); + REQUIRE(second.type() == uint8_t(VALUE_IS_FLOAT)); +} + +TEST_CASE("Test signed integer overflow") { + VariantData first, second; + first.init(); + second.init(); + + // Avoids MSVC warning C4127 (conditional expression is constant) + size_t integerSize = sizeof(Integer); + + if (integerSize == 8) { + parseNumber("-9223372036854775808", first); + parseNumber("-9223372036854775809", second); + } else { + parseNumber("-2147483648", first); + parseNumber("-2147483649", second); + } + + REQUIRE(first.type() == uint8_t(VALUE_IS_SIGNED_INTEGER)); REQUIRE(second.type() == uint8_t(VALUE_IS_FLOAT)); } diff --git a/extras/tests/TextFormatter/CMakeLists.txt b/extras/tests/TextFormatter/CMakeLists.txt index c522f9d0..9fcd6eba 100644 --- a/extras/tests/TextFormatter/CMakeLists.txt +++ b/extras/tests/TextFormatter/CMakeLists.txt @@ -4,6 +4,7 @@ add_executable(TextFormatterTests writeFloat.cpp + writeInteger.cpp writeString.cpp ) diff --git a/extras/tests/TextFormatter/writeInteger.cpp b/extras/tests/TextFormatter/writeInteger.cpp new file mode 100644 index 00000000..6e9d9fac --- /dev/null +++ b/extras/tests/TextFormatter/writeInteger.cpp @@ -0,0 +1,55 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#include +#include +#include + +#include +#include + +using namespace ARDUINOJSON_NAMESPACE; + +template +void checkWriteInteger(T value, std::string expected) { + char output[1024]; + StaticStringWriter sb(output, sizeof(output)); + TextFormatter writer(sb); + writer.writeInteger(value); + REQUIRE(expected == output); + REQUIRE(writer.bytesWritten() == expected.size()); +} + +TEST_CASE("int8_t") { + checkWriteInteger(0, "0"); + checkWriteInteger(-128, "-128"); + checkWriteInteger(127, "127"); +} + +TEST_CASE("uint8_t") { + checkWriteInteger(0, "0"); + checkWriteInteger(255, "255"); +} + +TEST_CASE("int16_t") { + checkWriteInteger(0, "0"); + checkWriteInteger(-32768, "-32768"); + checkWriteInteger(32767, "32767"); +} + +TEST_CASE("uint16_t") { + checkWriteInteger(0, "0"); + checkWriteInteger(65535, "65535"); +} + +TEST_CASE("int32_t") { + checkWriteInteger(0, "0"); + checkWriteInteger(-2147483647 - 1, "-2147483648"); + checkWriteInteger(2147483647, "2147483647"); +} + +TEST_CASE("uint32_t") { + checkWriteInteger(0, "0"); + checkWriteInteger(4294967295U, "4294967295"); +} diff --git a/src/ArduinoJson/Json/JsonSerializer.hpp b/src/ArduinoJson/Json/JsonSerializer.hpp index 5d1796c9..220aa117 100644 --- a/src/ArduinoJson/Json/JsonSerializer.hpp +++ b/src/ArduinoJson/Json/JsonSerializer.hpp @@ -71,13 +71,13 @@ class JsonSerializer : public Visitor { return bytesWritten(); } - size_t visitNegativeInteger(UInt value) { - _formatter.writeNegativeInteger(value); + size_t visitSignedInteger(Integer value) { + _formatter.writeInteger(value); return bytesWritten(); } - size_t visitPositiveInteger(UInt value) { - _formatter.writePositiveInteger(value); + size_t visitUnsignedInteger(UInt value) { + _formatter.writeInteger(value); return bytesWritten(); } diff --git a/src/ArduinoJson/Json/TextFormatter.hpp b/src/ArduinoJson/Json/TextFormatter.hpp index 7caf53d2..23d16d03 100644 --- a/src/ArduinoJson/Json/TextFormatter.hpp +++ b/src/ArduinoJson/Json/TextFormatter.hpp @@ -12,6 +12,7 @@ #include #include #include +#include #include namespace ARDUINOJSON_NAMESPACE { @@ -75,28 +76,31 @@ class TextFormatter { FloatParts parts(value); - writePositiveInteger(parts.integral); + writeInteger(parts.integral); if (parts.decimalPlaces) writeDecimals(parts.decimal, parts.decimalPlaces); - if (parts.exponent < 0) { - writeRaw("e-"); - writePositiveInteger(-parts.exponent); - } - - if (parts.exponent > 0) { + if (parts.exponent) { writeRaw('e'); - writePositiveInteger(parts.exponent); + writeInteger(parts.exponent); } } - void writeNegativeInteger(UInt value) { - writeRaw('-'); - writePositiveInteger(value); - } - template - void writePositiveInteger(T value) { + typename enable_if::value>::type writeInteger(T value) { + typedef typename make_unsigned::type unsigned_type; + unsigned_type unsigned_value; + if (value < 0) { + writeRaw('-'); + unsigned_value = static_cast(-value); + } else { + unsigned_value = static_cast(value); + } + writeInteger(unsigned_value); + } + + template + typename enable_if::value>::type writeInteger(T value) { char buffer[22]; char *end = buffer + sizeof(buffer); char *begin = end; diff --git a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp index 6e595236..ca1424b9 100644 --- a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp +++ b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp @@ -101,30 +101,37 @@ class MsgPackSerializer : public Visitor { return bytesWritten(); } - size_t visitNegativeInteger(UInt value) { - UInt negated = UInt(~value + 1); - if (value <= 0x20) { - writeInteger(int8_t(negated)); - } else if (value <= 0x80) { + size_t visitSignedInteger(Integer value) { + if (value > 0) { + visitUnsignedInteger(static_cast(value)); + } else if (value >= -0x20) { + writeInteger(int8_t(value)); + } else if (value >= -0x80) { writeByte(0xD0); - writeInteger(int8_t(negated)); - } else if (value <= 0x8000) { + writeInteger(int8_t(value)); + } else if (value >= -0x8000) { writeByte(0xD1); - writeInteger(int16_t(negated)); - } else if (value <= 0x80000000) { + writeInteger(int16_t(value)); + } +#if ARDUINOJSON_USE_LONG_LONG + else if (value >= -0x80000000LL) +#else + else +#endif + { writeByte(0xD2); - writeInteger(int32_t(negated)); + writeInteger(int32_t(value)); } #if ARDUINOJSON_USE_LONG_LONG else { writeByte(0xD3); - writeInteger(int64_t(negated)); + writeInteger(int64_t(value)); } #endif return bytesWritten(); } - size_t visitPositiveInteger(UInt value) { + size_t visitUnsignedInteger(UInt value) { if (value <= 0x7F) { writeInteger(uint8_t(value)); } else if (value <= 0xFF) { diff --git a/src/ArduinoJson/Numbers/convertNumber.hpp b/src/ArduinoJson/Numbers/convertNumber.hpp index 2490a8b3..02bbefa5 100644 --- a/src/ArduinoJson/Numbers/convertNumber.hpp +++ b/src/ArduinoJson/Numbers/convertNumber.hpp @@ -15,84 +15,86 @@ #endif #include -#include -#include #include +#include namespace ARDUINOJSON_NAMESPACE { +// uint32 -> int32 +// uint64 -> int32 template -typename enable_if::value && sizeof(TOut) <= sizeof(TIn), +typename enable_if::value && is_unsigned::value && + is_integral::value && sizeof(TOut) <= sizeof(TIn), bool>::type -canStorePositiveInteger(TIn value) { +canConvertNumber(TIn value) { return value <= TIn(numeric_limits::highest()); } +// uint32 -> int64 template -typename enable_if::value && sizeof(TIn) < sizeof(TOut), +typename enable_if::value && is_unsigned::value && + is_integral::value && sizeof(TIn) < sizeof(TOut), bool>::type -canStorePositiveInteger(TIn) { +canConvertNumber(TIn) { return true; } +// uint32 -> float +// int32 -> float template -typename enable_if::value, bool>::type -canStorePositiveInteger(TIn) { +typename enable_if::value && is_floating_point::value, + bool>::type +canConvertNumber(TIn) { return true; } +// int64 -> int32 template -typename enable_if::value, bool>::type -canStoreNegativeInteger(TIn) { +typename enable_if::value && is_signed::value && + is_integral::value && is_signed::value && + sizeof(TOut) < sizeof(TIn), + bool>::type +canConvertNumber(TIn value) { + return value >= TIn(numeric_limits::lowest()) && + value <= TIn(numeric_limits::highest()); +} + +// int32 -> int32 +// int32 -> int64 +template +typename enable_if::value && is_signed::value && + is_integral::value && is_signed::value && + sizeof(TIn) <= sizeof(TOut), + bool>::type +canConvertNumber(TIn) { return true; } +// int32 -> uint32 template -typename enable_if::value && is_signed::value && - sizeof(TOut) <= sizeof(TIn), +typename enable_if::value && is_signed::value && + is_integral::value && is_unsigned::value, bool>::type -canStoreNegativeInteger(TIn value) { - return value <= TIn(numeric_limits::highest()) + 1; +canConvertNumber(TIn value) { + if (value < 0) + return false; + return value <= TIn(numeric_limits::highest()); } +// float -> int32 +// float -> int64 template -typename enable_if::value && is_signed::value && - sizeof(TIn) < sizeof(TOut), +typename enable_if::value && + !is_floating_point::value, bool>::type -canStoreNegativeInteger(TIn) { - return true; -} - -template -typename enable_if::value && is_unsigned::value, - bool>::type -canStoreNegativeInteger(TIn) { - return false; -} - -template -TOut convertPositiveInteger(TIn value) { - return canStorePositiveInteger(value) ? TOut(value) : 0; -} - -template -TOut convertNegativeInteger(TIn value) { - return canStoreNegativeInteger(value) ? TOut(~value + 1) : 0; -} - -template -typename enable_if::value, TOut>::type convertFloat( - TIn value) { - return TOut(value); -} - -template -typename enable_if::value, TOut>::type convertFloat( - TIn value) { +canConvertNumber(TIn value) { return value >= numeric_limits::lowest() && - value <= numeric_limits::highest() - ? TOut(value) - : 0; + value <= numeric_limits::highest(); +} + +template +TOut convertNumber(TIn value) { + return canConvertNumber(value) ? TOut(value) : 0; } } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Numbers/parseNumber.hpp b/src/ArduinoJson/Numbers/parseNumber.hpp index a8f0857d..cf050c78 100644 --- a/src/ArduinoJson/Numbers/parseNumber.hpp +++ b/src/ArduinoJson/Numbers/parseNumber.hpp @@ -69,11 +69,17 @@ inline bool parseNumber(const char* s, VariantData& result) { } if (*s == '\0') { - if (is_negative) - result.setNegativeInteger(UInt(mantissa)); - else - result.setPositiveInteger(UInt(mantissa)); - return true; + if (is_negative) { + const mantissa_t sintMantissaMax = mantissa_t(1) + << (sizeof(Integer) * 8 - 1); + if (mantissa <= sintMantissaMax) { + result.setInteger(Integer(~mantissa + 1)); + return true; + } + } else { + result.setInteger(UInt(mantissa)); + return true; + } } // avoid mantissa overflow diff --git a/src/ArduinoJson/Variant/VariantCompare.hpp b/src/ArduinoJson/Variant/VariantCompare.hpp index a944e0ad..025ef90a 100644 --- a/src/ArduinoJson/Variant/VariantCompare.hpp +++ b/src/ArduinoJson/Variant/VariantCompare.hpp @@ -57,16 +57,16 @@ struct Comparer::value || return arithmeticCompare(lhs, rhs); } - CompareResult visitNegativeInteger(UInt lhs) { - return arithmeticCompareNegateLeft(lhs, rhs); + CompareResult visitSignedInteger(Integer lhs) { + return arithmeticCompare(lhs, rhs); } - CompareResult visitPositiveInteger(UInt lhs) { + CompareResult visitUnsignedInteger(UInt lhs) { return arithmeticCompare(lhs, rhs); } CompareResult visitBoolean(bool lhs) { - return visitPositiveInteger(static_cast(lhs)); + return visitUnsignedInteger(static_cast(lhs)); } }; @@ -96,28 +96,6 @@ struct ArrayComparer : ComparerBase { } }; -struct NegativeIntegerComparer : ComparerBase { - UInt _rhs; - - explicit NegativeIntegerComparer(UInt rhs) : _rhs(rhs) {} - - CompareResult visitFloat(Float lhs) { - return arithmeticCompareNegateRight(lhs, _rhs); - } - - CompareResult visitNegativeInteger(UInt lhs) { - return arithmeticCompare(_rhs, lhs); - } - - CompareResult visitPositiveInteger(UInt) { - return COMPARE_RESULT_GREATER; - } - - CompareResult visitBoolean(bool) { - return COMPARE_RESULT_GREATER; - } -}; - struct ObjectComparer : ComparerBase { const CollectionData *_rhs; @@ -182,12 +160,12 @@ struct Comparer::value>::type> return accept(comparer); } - CompareResult visitNegativeInteger(UInt lhs) { - NegativeIntegerComparer comparer(lhs); + CompareResult visitSignedInteger(Integer lhs) { + Comparer comparer(lhs); return accept(comparer); } - CompareResult visitPositiveInteger(UInt lhs) { + CompareResult visitUnsignedInteger(UInt lhs) { Comparer comparer(lhs); return accept(comparer); } diff --git a/src/ArduinoJson/Variant/VariantContent.hpp b/src/ArduinoJson/Variant/VariantContent.hpp index 79840fed..54eb4a5d 100644 --- a/src/ArduinoJson/Variant/VariantContent.hpp +++ b/src/ArduinoJson/Variant/VariantContent.hpp @@ -25,8 +25,8 @@ enum { // CAUTION: no VALUE_IS_OWNED below VALUE_IS_BOOLEAN = 0x06, - VALUE_IS_POSITIVE_INTEGER = 0x08, - VALUE_IS_NEGATIVE_INTEGER = 0x0A, + VALUE_IS_UNSIGNED_INTEGER = 0x08, + VALUE_IS_SIGNED_INTEGER = 0x0A, VALUE_IS_FLOAT = 0x0C, COLLECTION_MASK = 0x60, @@ -43,7 +43,9 @@ struct RawData { union VariantContent { Float asFloat; - UInt asInteger; + bool asBoolean; + UInt asUnsignedInteger; + Integer asSignedInteger; CollectionData asCollection; const char *asString; struct { diff --git a/src/ArduinoJson/Variant/VariantData.hpp b/src/ArduinoJson/Variant/VariantData.hpp index 42994a45..469f607a 100644 --- a/src/ArduinoJson/Variant/VariantData.hpp +++ b/src/ArduinoJson/Variant/VariantData.hpp @@ -56,14 +56,14 @@ class VariantData { case VALUE_IS_LINKED_RAW: return visitor.visitRawJson(_content.asRaw.data, _content.asRaw.size); - case VALUE_IS_NEGATIVE_INTEGER: - return visitor.visitNegativeInteger(_content.asInteger); + case VALUE_IS_SIGNED_INTEGER: + return visitor.visitSignedInteger(_content.asSignedInteger); - case VALUE_IS_POSITIVE_INTEGER: - return visitor.visitPositiveInteger(_content.asInteger); + case VALUE_IS_UNSIGNED_INTEGER: + return visitor.visitUnsignedInteger(_content.asUnsignedInteger); case VALUE_IS_BOOLEAN: - return visitor.visitBoolean(_content.asInteger != 0); + return visitor.visitBoolean(_content.asBoolean != 0); default: return visitor.visitNull(); @@ -129,11 +129,11 @@ class VariantData { template bool isInteger() const { switch (type()) { - case VALUE_IS_POSITIVE_INTEGER: - return canStorePositiveInteger(_content.asInteger); + case VALUE_IS_UNSIGNED_INTEGER: + return canConvertNumber(_content.asUnsignedInteger); - case VALUE_IS_NEGATIVE_INTEGER: - return canStoreNegativeInteger(_content.asInteger); + case VALUE_IS_SIGNED_INTEGER: + return canConvertNumber(_content.asSignedInteger); default: return false; @@ -141,8 +141,8 @@ class VariantData { } bool isFloat() const { - return type() == VALUE_IS_FLOAT || type() == VALUE_IS_POSITIVE_INTEGER || - type() == VALUE_IS_NEGATIVE_INTEGER; + return type() == VALUE_IS_FLOAT || type() == VALUE_IS_UNSIGNED_INTEGER || + type() == VALUE_IS_SIGNED_INTEGER; } bool isString() const { @@ -174,7 +174,7 @@ class VariantData { void setBoolean(bool value) { setType(VALUE_IS_BOOLEAN); - _content.asInteger = static_cast(value); + _content.asBoolean = value; } void setFloat(Float value) { @@ -208,36 +208,14 @@ class VariantData { template typename enable_if::value>::type setInteger(T value) { - setUnsignedInteger(value); + setType(VALUE_IS_UNSIGNED_INTEGER); + _content.asUnsignedInteger = static_cast(value); } template typename enable_if::value>::type setInteger(T value) { - setSignedInteger(value); - } - - template - void setSignedInteger(T value) { - if (value >= 0) { - setPositiveInteger(static_cast(value)); - } else { - setNegativeInteger(~static_cast(value) + 1); - } - } - - void setUnsignedInteger(UInt value) { - setType(VALUE_IS_POSITIVE_INTEGER); - _content.asInteger = static_cast(value); - } - - void setPositiveInteger(UInt value) { - setType(VALUE_IS_POSITIVE_INTEGER); - _content.asInteger = value; - } - - void setNegativeInteger(UInt value) { - setType(VALUE_IS_NEGATIVE_INTEGER); - _content.asInteger = value; + setType(VALUE_IS_SIGNED_INTEGER); + _content.asSignedInteger = value; } void setNull() { diff --git a/src/ArduinoJson/Variant/VariantImpl.hpp b/src/ArduinoJson/Variant/VariantImpl.hpp index cc2221d5..b91e5845 100644 --- a/src/ArduinoJson/Variant/VariantImpl.hpp +++ b/src/ArduinoJson/Variant/VariantImpl.hpp @@ -18,16 +18,17 @@ namespace ARDUINOJSON_NAMESPACE { template inline T VariantData::asIntegral() const { switch (type()) { - case VALUE_IS_POSITIVE_INTEGER: case VALUE_IS_BOOLEAN: - return convertPositiveInteger(_content.asInteger); - case VALUE_IS_NEGATIVE_INTEGER: - return convertNegativeInteger(_content.asInteger); + return _content.asBoolean; + case VALUE_IS_UNSIGNED_INTEGER: + return convertNumber(_content.asUnsignedInteger); + case VALUE_IS_SIGNED_INTEGER: + return convertNumber(_content.asSignedInteger); case VALUE_IS_LINKED_STRING: case VALUE_IS_OWNED_STRING: return parseNumber(_content.asString); case VALUE_IS_FLOAT: - return convertFloat(_content.asFloat); + return convertNumber(_content.asFloat); default: return 0; } @@ -35,10 +36,11 @@ inline T VariantData::asIntegral() const { inline bool VariantData::asBoolean() const { switch (type()) { - case VALUE_IS_POSITIVE_INTEGER: case VALUE_IS_BOOLEAN: - case VALUE_IS_NEGATIVE_INTEGER: - return _content.asInteger != 0; + return _content.asBoolean; + case VALUE_IS_SIGNED_INTEGER: + case VALUE_IS_UNSIGNED_INTEGER: + return _content.asUnsignedInteger != 0; case VALUE_IS_FLOAT: return _content.asFloat != 0; case VALUE_IS_NULL: @@ -52,11 +54,12 @@ inline bool VariantData::asBoolean() const { template inline T VariantData::asFloat() const { switch (type()) { - case VALUE_IS_POSITIVE_INTEGER: case VALUE_IS_BOOLEAN: - return static_cast(_content.asInteger); - case VALUE_IS_NEGATIVE_INTEGER: - return -static_cast(_content.asInteger); + return static_cast(_content.asBoolean); + case VALUE_IS_UNSIGNED_INTEGER: + return static_cast(_content.asUnsignedInteger); + case VALUE_IS_SIGNED_INTEGER: + return static_cast(_content.asSignedInteger); case VALUE_IS_LINKED_STRING: case VALUE_IS_OWNED_STRING: return parseNumber(_content.asString); diff --git a/src/ArduinoJson/Variant/Visitor.hpp b/src/ArduinoJson/Variant/Visitor.hpp index 60c82f8f..33237dd2 100644 --- a/src/ArduinoJson/Variant/Visitor.hpp +++ b/src/ArduinoJson/Variant/Visitor.hpp @@ -26,7 +26,7 @@ struct Visitor { return TResult(); } - TResult visitNegativeInteger(UInt) { + TResult visitSignedInteger(Integer) { return TResult(); } @@ -38,7 +38,7 @@ struct Visitor { return TResult(); } - TResult visitPositiveInteger(UInt) { + TResult visitUnsignedInteger(UInt) { return TResult(); }