github-mirrors/thirdparty-ArduinoJson
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-ArduinoJson.git synced 2025-10-31 08:42:39 +01:00
Code Issues Packages Projects Releases Wiki Activity

Reversed parameters of convertToJson() and convertFromJson()

Browse Source 
Now the order matches copyArray(): source first, destination second.
This commit is contained in:
Benoit Blanchon
2021-04-27 19:28:36 +02:00
parent 526cad54d7
commit 337864618c
8 changed files with 130 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
src/ArduinoJson/Variant/ConverterImpl.hpp
View File

@@ -12,24 +12,24 @@ namespace ARDUINOJSON_NAMESPACE {
template <typename T, typename Enable>
struct Converter {
static bool toJson(VariantRef variant, const T& value) {
static bool toJson(const T& src, VariantRef dst) {
// clang-format off
return convertToJson(variant, value); // Error here? See https://arduinojson.org/v6/unsupported-set/
return convertToJson(src, dst); // Error here? See https://arduinojson.org/v6/unsupported-set/
// clang-format on
}
static T fromJson(VariantConstRef variant) {
static T fromJson(VariantConstRef src) {
// clang-format off
T value; // Error here? See https://arduinojson.org/v6/non-default-constructible/
convertFromJson(value, variant); // Error here? See https://arduinojson.org/v6/unsupported-as/
T result; // Error here? See https://arduinojson.org/v6/non-default-constructible/
convertFromJson(src, result); // Error here? See https://arduinojson.org/v6/unsupported-as/
// clang-format on
return value;
return result;
}
static bool checkJson(VariantConstRef variant) {
static bool checkJson(VariantConstRef src) {
T dummy;
// clang-format off
return canConvertFromJson(dummy, variant); // Error here? See https://arduinojson.org/v6/unsupported-is/
return canConvertFromJson(src, dummy); // Error here? See https://arduinojson.org/v6/unsupported-is/
// clang-format on
}
};
@@ -38,137 +38,136 @@ template <typename T>
struct Converter<
T, typename enable_if<is_integral<T>::value && !is_same<bool, T>::value &&
!is_same<char, T>::value>::type> {
static bool toJson(VariantRef variant, T value) {
VariantData* data = getData(variant);
static bool toJson(T src, VariantRef dst) {
VariantData* data = getData(dst);
ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
if (!data)
return false;
data->setInteger(value);
data->setInteger(src);
return true;
}
static T fromJson(VariantConstRef variant) {
static T fromJson(VariantConstRef src) {
ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
const VariantData* data = getData(variant);
const VariantData* data = getData(src);
return data ? data->asIntegral<T>() : T();
}
static bool checkJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data && data->isInteger<T>();
}
};
template <typename T>
struct Converter<T, typename enable_if<is_enum<T>::value>::type> {
static bool toJson(VariantRef variant, T value) {
return variant.set(static_cast<Integer>(value));
static bool toJson(T src, VariantRef dst) {
return dst.set(static_cast<Integer>(src));
}
static T fromJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static T fromJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data ? static_cast<T>(data->asIntegral<int>()) : T();
}
static bool checkJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data && data->isInteger<int>();
}
};
template <>
struct Converter<bool> {
static bool toJson(VariantRef variant, bool value) {
VariantData* data = getData(variant);
static bool toJson(bool src, VariantRef dst) {
VariantData* data = getData(dst);
if (!data)
return false;
data->setBoolean(value);
data->setBoolean(src);
return true;
}
static bool fromJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static bool fromJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data ? data->asBoolean() : false;
}
static bool checkJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data && data->isBoolean();
}
};
template <typename T>
struct Converter<T, typename enable_if<is_floating_point<T>::value>::type> {
static bool toJson(VariantRef variant, T value) {
VariantData* data = getData(variant);
static bool toJson(T src, VariantRef dst) {
VariantData* data = getData(dst);
if (!data)
return false;
data->setFloat(static_cast<Float>(value));
data->setFloat(static_cast<Float>(src));
return true;
}
static T fromJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static T fromJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data ? data->asFloat<T>() : false;
}
static bool checkJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data && data->isFloat();
}
};
template <>
struct Converter<const char*> {
static bool toJson(VariantRef variant, const char* value) {
return variantSetString(getData(variant), adaptString(value),
getPool(variant));
static bool toJson(const char* src, VariantRef dst) {
return variantSetString(getData(dst), adaptString(src), getPool(dst));
}
static const char* fromJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static const char* fromJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data ? data->asString() : 0;
}
static bool checkJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data && data->isString();
}
};
template <typename T>
inline typename enable_if<IsString<T>::value, bool>::type convertToJson(
VariantRef variant, const T& value) {
VariantData* data = getData(variant);
MemoryPool* pool = getPool(variant);
return variantSetString(data, adaptString(value), pool);
const T& src, VariantRef dst) {
VariantData* data = getData(dst);
MemoryPool* pool = getPool(dst);
return variantSetString(data, adaptString(src), pool);
}
template <typename T>
inline typename enable_if<IsWriteableString<T>::value>::type convertFromJson(
T& value, VariantConstRef variant) {
const VariantData* data = getData(variant);
VariantConstRef src, T& dst) {
const VariantData* data = getData(src);
const char* cstr = data != 0 ? data->asString() : 0;
if (cstr)
value = cstr;
dst = cstr;
else
serializeJson(variant, value);
serializeJson(src, dst);
}
template <typename T>
inline typename enable_if<IsWriteableString<T>::value, bool>::type
canConvertFromJson(T&, VariantConstRef variant) {
const VariantData* data = getData(variant);
canConvertFromJson(VariantConstRef src, const T&) {
const VariantData* data = getData(src);
return data && data->isString();
}
template <>
struct Converter<SerializedValue<const char*> > {
static bool toJson(VariantRef variant, SerializedValue<const char*> value) {
VariantData* data = getData(variant);
static bool toJson(SerializedValue<const char*> src, VariantRef dst) {
VariantData* data = getData(dst);
if (!data)
return false;
data->setLinkedRaw(value);
data->setLinkedRaw(src);
return true;
}
};
@@ -179,10 +178,10 @@ struct Converter<SerializedValue<const char*> > {
template <typename T>
struct Converter<SerializedValue<T>,
typename enable_if<!is_same<const char*, T>::value>::type> {
static bool toJson(VariantRef variant, SerializedValue<T> value) {
VariantData* data = getData(variant);
MemoryPool* pool = getPool(variant);
return data != 0 && data->setOwnedRaw(value, pool);
static bool toJson(SerializedValue<T> src, VariantRef dst) {
VariantData* data = getData(dst);
MemoryPool* pool = getPool(dst);
return data != 0 && data->setOwnedRaw(src, pool);
}
};
@@ -190,15 +189,15 @@ struct Converter<SerializedValue<T>,
template <>
struct Converter<decltype(nullptr)> {
static bool toJson(VariantRef variant, decltype(nullptr)) {
variantSetNull(getData(variant));
static bool toJson(decltype(nullptr), VariantRef dst) {
variantSetNull(getData(dst));
return true;
}
static decltype(nullptr) fromJson(VariantConstRef) {
return nullptr;
}
static bool checkJson(VariantConstRef variant) {
const VariantData* data = getData(variant);
static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(src);
return data == 0 || data->isNull();
}
};
@@ -248,13 +247,13 @@ class MemoryPoolPrint : public Print {
size_t _capacity;
};
inline bool convertToJson(VariantRef variant, const ::Printable& value) {
MemoryPool* pool = getPool(variant);
VariantData* data = getData(variant);
inline bool convertToJson(const ::Printable& src, VariantRef dst) {
MemoryPool* pool = getPool(dst);
VariantData* data = getData(dst);
if (!pool || !data)
return false;
MemoryPoolPrint print(pool);
value.printTo(print);
src.printTo(print);
if (print.overflowed()) {
pool->markAsOverflowed();
data->setNull();