feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests 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

36
extras/tests/JsonVariant/converters.cpp
View File

@ -13,22 +13,22 @@ struct Date {
int year; int year;
}; };
bool convertToJson(JsonVariant variant, const Date& date) { bool convertToJson(const Date& src, JsonVariant dst) {
variant["day"] = date.day; dst["day"] = src.day;
variant["month"] = date.month; dst["month"] = src.month;
variant["year"] = date.year; dst["year"] = src.year;
return true; return true;
} }
void convertFromJson(Date& date, JsonVariantConst variant) { void convertFromJson(JsonVariantConst src, Date& dst) {
date.day = variant["day"]; dst.day = src["day"];
date.month = variant["month"]; dst.month = src["month"];
date.year = variant["year"]; dst.year = src["year"];
} }
bool canConvertFromJson(Date&, JsonVariantConst variant) { bool canConvertFromJson(JsonVariantConst src, const Date&) {
return variant["day"].is<int>() && variant["month"].is<int>() && return src["day"].is<int>() && src["month"].is<int>() &&
variant["year"].is<int>(); src["year"].is<int>();
} }
} // namespace } // namespace
@ -92,18 +92,18 @@ class Complex {
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
template <> template <>
struct Converter<Complex> { struct Converter<Complex> {
static bool toJson(VariantRef variant, const Complex& value) { static bool toJson(const Complex& src, VariantRef dst) {
variant["real"] = value.real(); dst["real"] = src.real();
variant["imag"] = value.imag(); dst["imag"] = src.imag();
return true; return true;
} }
static Complex fromJson(VariantConstRef variant) { static Complex fromJson(VariantConstRef src) {
return Complex(variant["real"], variant["imag"]); return Complex(src["real"], src["imag"]);
} }
static bool checkJson(VariantConstRef variant) { static bool checkJson(VariantConstRef src) {
return variant["real"].is<double>() && variant["imag"].is<double>(); return src["real"].is<double>() && src["imag"].is<double>();
} }
}; };
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

26
src/ArduinoJson/Array/ArrayRef.hpp
View File

@ -167,29 +167,29 @@ class ArrayRef : public ArrayRefBase<CollectionData>,
template <> template <>
struct Converter<ArrayConstRef> { struct Converter<ArrayConstRef> {
static bool toJson(VariantRef variant, VariantConstRef value) { static bool toJson(VariantConstRef src, VariantRef dst) {
return variantCopyFrom(getData(variant), getData(value), getPool(variant)); return variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static ArrayConstRef fromJson(VariantConstRef variant) { static ArrayConstRef fromJson(VariantConstRef src) {
return ArrayConstRef(variantAsArray(getData(variant))); return ArrayConstRef(variantAsArray(getData(src)));
} }
static bool checkJson(VariantConstRef variant) { static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(variant); const VariantData* data = getData(src);
return data && data->isArray(); return data && data->isArray();
} }
}; };
template <> template <>
struct Converter<ArrayRef> { struct Converter<ArrayRef> {
static bool toJson(VariantRef variant, VariantConstRef value) { static bool toJson(VariantConstRef src, VariantRef dst) {
return variantCopyFrom(getData(variant), getData(value), getPool(variant)); return variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static ArrayRef fromJson(VariantRef variant) { static ArrayRef fromJson(VariantRef src) {
VariantData* data = getData(variant); VariantData* data = getData(src);
MemoryPool* pool = getPool(variant); MemoryPool* pool = getPool(src);
return ArrayRef(pool, data != 0 ? data->asArray() : 0); return ArrayRef(pool, data != 0 ? data->asArray() : 0);
} }
@ -197,8 +197,8 @@ struct Converter<ArrayRef> {
return false; return false;
} }
static bool checkJson(VariantRef variant) { static bool checkJson(VariantRef src) {
VariantData* data = getData(variant); VariantData* data = getData(src);
return data && data->isArray(); return data && data->isArray();
} }
}; };

4
src/ArduinoJson/Array/ElementProxy.hpp
View File

@ -177,8 +177,8 @@ class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
return _array.getOrAddElement(_index); return _array.getOrAddElement(_index);
} }
friend bool convertToJson(VariantRef variant, const this_type& value) { friend bool convertToJson(const this_type& src, VariantRef dst) {
return variant.set(value.getUpstreamElement()); return dst.set(src.getUpstreamElement());
} }
TArray _array; TArray _array;

4
src/ArduinoJson/Document/JsonDocument.hpp
View File

@ -337,8 +337,8 @@ class JsonDocument : public Visitable {
JsonDocument& operator=(const JsonDocument&); JsonDocument& operator=(const JsonDocument&);
}; };
inline bool convertToJson(VariantRef variant, const JsonDocument& doc) { inline bool convertToJson(const JsonDocument& src, VariantRef dst) {
return variant.set(doc.as<VariantConstRef>()); return dst.set(src.as<VariantConstRef>());
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE

4
src/ArduinoJson/Object/MemberProxy.hpp
View File

@ -186,8 +186,8 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
return _object.getOrAddMember(_key); return _object.getOrAddMember(_key);
} }
friend bool convertToJson(VariantRef variant, const this_type &value) { friend bool convertToJson(const this_type &src, VariantRef dst) {
return variant.set(value.getUpstreamMember()); return dst.set(src.getUpstreamMember());
} }
TObject _object; TObject _object;

26
src/ArduinoJson/Object/ObjectRef.hpp
View File

@ -239,29 +239,29 @@ class ObjectRef : public ObjectRefBase<CollectionData>,
template <> template <>
struct Converter<ObjectConstRef> { struct Converter<ObjectConstRef> {
static bool toJson(VariantRef variant, VariantConstRef value) { static bool toJson(VariantConstRef src, VariantRef dst) {
return variantCopyFrom(getData(variant), getData(value), getPool(variant)); return variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static ObjectConstRef fromJson(VariantConstRef variant) { static ObjectConstRef fromJson(VariantConstRef src) {
return ObjectConstRef(variantAsObject(getData(variant))); return ObjectConstRef(variantAsObject(getData(src)));
} }
static bool checkJson(VariantConstRef variant) { static bool checkJson(VariantConstRef src) {
const VariantData* data = getData(variant); const VariantData* data = getData(src);
return data && data->isObject(); return data && data->isObject();
} }
}; };
template <> template <>
struct Converter<ObjectRef> { struct Converter<ObjectRef> {
static bool toJson(VariantRef variant, VariantConstRef value) { static bool toJson(VariantConstRef src, VariantRef dst) {
return variantCopyFrom(getData(variant), getData(value), getPool(variant)); return variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static ObjectRef fromJson(VariantRef variant) { static ObjectRef fromJson(VariantRef src) {
VariantData* data = getData(variant); VariantData* data = getData(src);
MemoryPool* pool = getPool(variant); MemoryPool* pool = getPool(src);
return ObjectRef(pool, data != 0 ? data->asObject() : 0); return ObjectRef(pool, data != 0 ? data->asObject() : 0);
} }
@ -269,8 +269,8 @@ struct Converter<ObjectRef> {
return false; return false;
} }
static bool checkJson(VariantRef variant) { static bool checkJson(VariantRef src) {
VariantData* data = getData(variant); VariantData* data = getData(src);
return data && data->isObject(); return data && data->isObject();
} }
}; };

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

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

28
src/ArduinoJson/Variant/VariantRef.hpp
View File

@ -85,12 +85,12 @@ class VariantRef : public VariantRefBase<VariantData>,
template <typename T> template <typename T>
FORCE_INLINE bool set(const T &value) const { FORCE_INLINE bool set(const T &value) const {
return Converter<T>::toJson(*this, value); return Converter<T>::toJson(value, *this);
} }
template <typename T> template <typename T>
FORCE_INLINE bool set(T *value) const { FORCE_INLINE bool set(T *value) const {
return Converter<T *>::toJson(*this, value); return Converter<T *>::toJson(value, *this);
} }
template <typename T> template <typename T>
@ -277,14 +277,14 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
template <> template <>
struct Converter<VariantRef> { struct Converter<VariantRef> {
static bool toJson(VariantRef variant, VariantRef value) { static bool toJson(VariantRef src, VariantRef dst) {
return variantCopyFrom(getData(variant), getData(value), getPool(variant)); return variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static VariantRef fromJson(VariantRef variant) { static VariantRef fromJson(VariantRef src) {
return variant; return src;
} }
static bool checkJson(VariantRef variant) { static bool checkJson(VariantRef src) {
VariantData *data = getData(variant); VariantData *data = getData(src);
return !!data; return !!data;
} }
static bool checkJson(VariantConstRef) { static bool checkJson(VariantConstRef) {
@ -294,16 +294,16 @@ struct Converter<VariantRef> {
template <> template <>
struct Converter<VariantConstRef> { struct Converter<VariantConstRef> {
static bool toJson(VariantRef variant, VariantConstRef value) { static bool toJson(VariantConstRef src, VariantRef dst) {
return variantCopyFrom(getData(variant), getData(value), getPool(variant)); return variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static VariantConstRef fromJson(VariantConstRef variant) { static VariantConstRef fromJson(VariantConstRef src) {
return VariantConstRef(getData(variant)); return VariantConstRef(getData(src));
} }
static bool checkJson(VariantConstRef variant) { static bool checkJson(VariantConstRef src) {
const VariantData *data = getData(variant); const VariantData *data = getData(src);
return !!data; return !!data;
} }
}; };