Reversed parameters of convertToJson() and convertFromJson()

Now the order matches copyArray(): source first, destination second.

extras/tests/JsonVariant/converters.cpp

@@ -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

src/ArduinoJson/Array/ArrayRef.hpp

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

src/ArduinoJson/Array/ElementProxy.hpp

@@ -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;

src/ArduinoJson/Document/JsonDocument.hpp

@@ -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

src/ArduinoJson/Object/MemberProxy.hpp

@@ -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;

src/ArduinoJson/Object/ObjectRef.hpp

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

src/ArduinoJson/Variant/ConverterImpl.hpp

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

src/ArduinoJson/Variant/VariantRef.hpp

@@ -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;
   }
 };