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

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

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

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

@ -337,8 +337,8 @@ class JsonDocument : public Visitable {
JsonDocument& operator=(const JsonDocument&);
};
inline bool convertToJson(VariantRef variant, const JsonDocument& doc) {
return variant.set(doc.as<VariantConstRef>());
inline bool convertToJson(const JsonDocument& src, VariantRef dst) {
return dst.set(src.as<VariantConstRef>());
}
} // 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);
}
friend bool convertToJson(VariantRef variant, const this_type &value) {
return variant.set(value.getUpstreamMember());
friend bool convertToJson(const this_type &src, VariantRef dst) {
return dst.set(src.getUpstreamMember());
}
TObject _object;

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

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

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();

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

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