Convert "variant functions" to static member functions

src/ArduinoJson/Array/ArrayImpl.hpp

@@ -23,7 +23,9 @@ inline bool ArrayData::copyFrom(const ArrayData& src,
 
   for (VariantSlot* s = src.head(); s; s = s->next()) {
     auto var = addElement(resources);
-    if (!variantCopyFrom(var, s->data(), resources))
+    if (!var)
+      return false;
+    if (!var->copyFrom(s->data(), resources))
       return false;
   }
   return true;

src/ArduinoJson/Array/ElementProxy.hpp

@@ -45,13 +45,15 @@ class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
   }
 
   FORCE_INLINE VariantData* getData() const {
-    return variantGetElement(VariantAttorney::getData(upstream_), index_);
+    return VariantData::getElement(VariantAttorney::getData(upstream_), index_);
   }
 
   FORCE_INLINE VariantData* getOrCreateData() const {
-    return variantGetOrAddElement(
-        VariantAttorney::getOrCreateData(upstream_), index_,
-        VariantAttorney::getResourceManager(upstream_));
+    auto data = VariantAttorney::getOrCreateData(upstream_);
+    if (!data)
+      return nullptr;
+    return data->getOrAddElement(
+        index_, VariantAttorney::getResourceManager(upstream_));
   }
 
   TUpstream upstream_;

src/ArduinoJson/Array/JsonArray.hpp

@@ -150,7 +150,7 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v6/api/jsonarray/nesting/
   FORCE_INLINE size_t nesting() const {
-    return variantNesting(collectionToVariant(data_));
+    return detail::VariantData::nesting(collectionToVariant(data_));
   }
 
   // Returns the number of elements in the array.
@@ -179,7 +179,8 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
 template <>
 struct Converter<JsonArray> : private detail::VariantAttorney {
   static void toJson(JsonVariantConst src, JsonVariant dst) {
-    variantCopyFrom(getData(dst), getData(src), getResourceManager(dst));
+    detail::VariantData::copy(getData(dst), getData(src),
+                              getResourceManager(dst));
   }
 
   static JsonArray fromJson(JsonVariant src) {
@@ -209,8 +210,9 @@ template <typename TDerived>
 template <typename T>
 inline typename enable_if<is_same<T, JsonArray>::value, JsonArray>::type
 VariantRefBase<TDerived>::to() const {
-  return JsonArray(variantToArray(getOrCreateData(), getResourceManager()),
-                   getResourceManager());
+  return JsonArray(
+      VariantData::toArray(getOrCreateData(), getResourceManager()),
+      getResourceManager());
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -78,7 +78,7 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v6/api/jsonarrayconst/nesting/
   FORCE_INLINE size_t nesting() const {
-    return variantNesting(collectionToVariant(data_));
+    return detail::VariantData::nesting(collectionToVariant(data_));
   }
 
   // Returns the number of elements in the array.
@@ -98,7 +98,8 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
 template <>
 struct Converter<JsonArrayConst> : private detail::VariantAttorney {
   static void toJson(JsonVariantConst src, JsonVariant dst) {
-    variantCopyFrom(getData(dst), getData(src), getResourceManager(dst));
+    detail::VariantData::copy(getData(dst), getData(src),
+                              getResourceManager(dst));
   }
 
   static JsonArrayConst fromJson(JsonVariantConst src) {

src/ArduinoJson/Document/JsonDocument.hpp

@@ -318,7 +318,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // ⚠️ Doesn't release the memory associated with the removed element.
   // https://arduinojson.org/v6/api/jsondocument/remove/
   FORCE_INLINE void remove(size_t index) {
-    variantRemoveElement(getData(), index, getResourceManager());
+    detail::VariantData::removeElement(getData(), index, getResourceManager());
   }
 
   // Removes a member of the root object.
@@ -327,8 +327,8 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename TChar>
   FORCE_INLINE typename detail::enable_if<detail::IsString<TChar*>::value>::type
   remove(TChar* key) {
-    variantRemoveMember(getData(), detail::adaptString(key),
-                        getResourceManager());
+    detail::VariantData::removeMember(getData(), detail::adaptString(key),
+                                      getResourceManager());
   }
 
   // Removes a member of the root object.
@@ -338,8 +338,8 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   FORCE_INLINE
       typename detail::enable_if<detail::IsString<TString>::value>::type
       remove(const TString& key) {
-    variantRemoveMember(getData(), detail::adaptString(key),
-                        getResourceManager());
+    detail::VariantData::removeMember(getData(), detail::adaptString(key),
+                                      getResourceManager());
   }
 
   FORCE_INLINE operator JsonVariant() {

src/ArduinoJson/Object/JsonObject.hpp

@@ -62,7 +62,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   // Returns the depth (nesting level) of the object.
   // https://arduinojson.org/v6/api/jsonobject/nesting/
   FORCE_INLINE size_t nesting() const {
-    return variantNesting(collectionToVariant(data_));
+    return detail::VariantData::nesting(collectionToVariant(data_));
   }
 
   // Returns the number of members in the object.
@@ -210,7 +210,8 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
 template <>
 struct Converter<JsonObject> : private detail::VariantAttorney {
   static void toJson(JsonVariantConst src, JsonVariant dst) {
-    variantCopyFrom(getData(dst), getData(src), getResourceManager(dst));
+    detail::VariantData::copy(getData(dst), getData(src),
+                              getResourceManager(dst));
   }
 
   static JsonObject fromJson(JsonVariant src) {
@@ -240,8 +241,9 @@ template <typename TDerived>
 template <typename T>
 typename enable_if<is_same<T, JsonObject>::value, JsonObject>::type
 VariantRefBase<TDerived>::to() const {
-  return JsonObject(variantToObject(getOrCreateData(), getResourceManager()),
-                    getResourceManager());
+  return JsonObject(
+      VariantData::toObject(getOrCreateData(), getResourceManager()),
+      getResourceManager());
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Object/JsonObjectConst.hpp

@@ -49,7 +49,7 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
   // Returns the depth (nesting level) of the object.
   // https://arduinojson.org/v6/api/jsonobjectconst/nesting/
   FORCE_INLINE size_t nesting() const {
-    return variantNesting(collectionToVariant(data_));
+    return detail::VariantData::nesting(collectionToVariant(data_));
   }
 
   // Returns the number of members in the object.
@@ -122,7 +122,8 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
 template <>
 struct Converter<JsonObjectConst> : private detail::VariantAttorney {
   static void toJson(JsonVariantConst src, JsonVariant dst) {
-    variantCopyFrom(getData(dst), getData(src), getResourceManager(dst));
+    detail::VariantData::copy(getData(dst), getData(src),
+                              getResourceManager(dst));
   }
 
   static JsonObjectConst fromJson(JsonVariantConst src) {

src/ArduinoJson/Object/JsonObjectImpl.hpp

@@ -54,16 +54,16 @@ template <typename TDerived>
 template <typename TString>
 inline typename enable_if<IsString<TString>::value, bool>::type
 VariantRefBase<TDerived>::containsKey(const TString& key) const {
-  return variantGetMember(VariantAttorney::getData(derived()),
-                          adaptString(key)) != 0;
+  return VariantData::getMember(VariantAttorney::getData(derived()),
+                                adaptString(key)) != 0;
 }
 
 template <typename TDerived>
 template <typename TChar>
 inline typename enable_if<IsString<TChar*>::value, bool>::type
 VariantRefBase<TDerived>::containsKey(TChar* key) const {
-  return variantGetMember(VariantAttorney::getData(derived()),
-                          adaptString(key)) != 0;
+  return VariantData::getMember(VariantAttorney::getData(derived()),
+                                adaptString(key)) != 0;
 }
 
 template <typename TDerived>

src/ArduinoJson/Object/MemberProxy.hpp

@@ -46,14 +46,16 @@ class MemberProxy
   }
 
   FORCE_INLINE VariantData* getData() const {
-    return variantGetMember(VariantAttorney::getData(upstream_),
-                            adaptString(key_));
+    return VariantData::getMember(VariantAttorney::getData(upstream_),
+                                  adaptString(key_));
   }
 
   FORCE_INLINE VariantData* getOrCreateData() const {
-    return variantGetOrAddMember(
-        VariantAttorney::getOrCreateData(upstream_), adaptString(key_),
-        VariantAttorney::getResourceManager(upstream_));
+    auto data = VariantAttorney::getOrCreateData(upstream_);
+    if (!data)
+      return nullptr;
+    return data->getOrAddMember(adaptString(key_),
+                                VariantAttorney::getResourceManager(upstream_));
   }
 
  private:

src/ArduinoJson/Object/ObjectImpl.hpp

@@ -49,7 +49,9 @@ inline bool ObjectData::copyFrom(const ObjectData& src,
     JsonString key(s->key(),
                    s->ownsKey() ? JsonString::Copied : JsonString::Linked);
     auto var = addMember(adaptString(key), resources);
-    if (!variantCopyFrom(var, s->data(), resources))
+    if (!var)
+      return false;
+    if (!var->copyFrom(s->data(), resources))
       return false;
   }
   return true;

src/ArduinoJson/Serialization/measure.hpp

@@ -12,7 +12,7 @@ template <template <typename> class TSerializer>
 size_t measure(ArduinoJson::JsonVariantConst source) {
   DummyWriter dp;
   TSerializer<DummyWriter> serializer(dp);
-  return variantAccept(VariantAttorney::getData(source), serializer);
+  return VariantData::accept(VariantAttorney::getData(source), serializer);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Serialization/serialize.hpp

@@ -11,7 +11,7 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 template <template <typename> class TSerializer, typename TWriter>
 size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) {
   TSerializer<TWriter> serializer(writer);
-  return variantAccept(VariantAttorney::getData(source), serializer);
+  return VariantData::accept(VariantAttorney::getData(source), serializer);
 }
 
 template <template <typename> class TSerializer, typename TDestination>

src/ArduinoJson/Variant/ConverterImpl.hpp

@@ -42,7 +42,9 @@ struct Converter<
     : private detail::VariantAttorney {
   static void toJson(T src, JsonVariant dst) {
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
-    variantSetInteger(getData(dst), src, getResourceManager(dst));
+    auto data = getData(dst);
+    if (data)
+      data->setInteger(src, getResourceManager(dst));
   }
 
   static T fromJson(JsonVariantConst src) {
@@ -78,7 +80,9 @@ struct Converter<T, typename detail::enable_if<detail::is_enum<T>::value>::type>
 template <>
 struct Converter<bool> : private detail::VariantAttorney {
   static void toJson(bool src, JsonVariant dst) {
-    variantSetBoolean(getData(dst), src, getResourceManager(dst));
+    auto data = getData(dst);
+    if (data)
+      data->setBoolean(src, getResourceManager(dst));
   }
 
   static bool fromJson(JsonVariantConst src) {
@@ -97,8 +101,9 @@ struct Converter<
     T, typename detail::enable_if<detail::is_floating_point<T>::value>::type>
     : private detail::VariantAttorney {
   static void toJson(T src, JsonVariant dst) {
-    variantSetFloat(getData(dst), static_cast<JsonFloat>(src),
-                    getResourceManager(dst));
+    auto data = getData(dst);
+    if (data)
+      data->setFloat(static_cast<JsonFloat>(src), getResourceManager(dst));
   }
 
   static T fromJson(JsonVariantConst src) {
@@ -115,8 +120,8 @@ struct Converter<
 template <>
 struct Converter<const char*> : private detail::VariantAttorney {
   static void toJson(const char* src, JsonVariant dst) {
-    variantSetString(getData(dst), detail::adaptString(src),
-                     getResourceManager(dst));
+    detail::VariantData::setString(getData(dst), detail::adaptString(src),
+                                   getResourceManager(dst));
   }
 
   static const char* fromJson(JsonVariantConst src) {
@@ -133,8 +138,8 @@ struct Converter<const char*> : private detail::VariantAttorney {
 template <>
 struct Converter<JsonString> : private detail::VariantAttorney {
   static void toJson(JsonString src, JsonVariant dst) {
-    variantSetString(getData(dst), detail::adaptString(src),
-                     getResourceManager(dst));
+    detail::VariantData::setString(getData(dst), detail::adaptString(src),
+                                   getResourceManager(dst));
   }
 
   static JsonString fromJson(JsonVariantConst src) {
@@ -154,7 +159,7 @@ convertToJson(const T& src, JsonVariant dst) {
   using namespace detail;
   auto data = VariantAttorney::getData(dst);
   auto resources = VariantAttorney::getResourceManager(dst);
-  variantSetString(data, adaptString(src), resources);
+  detail::VariantData::setString(data, adaptString(src), resources);
 }
 
 // SerializedValue<std::string>
@@ -163,14 +168,15 @@ convertToJson(const T& src, JsonVariant dst) {
 template <typename T>
 struct Converter<SerializedValue<T>> : private detail::VariantAttorney {
   static void toJson(SerializedValue<T> src, JsonVariant dst) {
-    variantSetRawString(getData(dst), src, getResourceManager(dst));
+    detail::VariantData::setRawString(getData(dst), src,
+                                      getResourceManager(dst));
   }
 };
 
 template <>
 struct Converter<decltype(nullptr)> : private detail::VariantAttorney {
   static void toJson(decltype(nullptr), JsonVariant dst) {
-    variantSetNull(getData(dst), getResourceManager(dst));
+    detail::VariantData::setNull(getData(dst), getResourceManager(dst));
   }
   static decltype(nullptr) fromJson(JsonVariantConst) {
     return nullptr;

src/ArduinoJson/Variant/JsonVariant.hpp

@@ -42,8 +42,8 @@ class JsonVariant : public detail::VariantRefBase<JsonVariant>,
 template <>
 struct Converter<JsonVariant> : private detail::VariantAttorney {
   static void toJson(JsonVariant src, JsonVariant dst) {
-    detail::variantCopyFrom(getData(dst), getData(src),
-                            getResourceManager(dst));
+    detail::VariantData::copy(getData(dst), getData(src),
+                              getResourceManager(dst));
   }
 
   static JsonVariant fromJson(JsonVariant src) {
@@ -66,7 +66,8 @@ struct Converter<JsonVariant> : private detail::VariantAttorney {
 template <>
 struct Converter<JsonVariantConst> : private detail::VariantAttorney {
   static void toJson(JsonVariantConst src, JsonVariant dst) {
-    variantCopyFrom(getData(dst), getData(src), getResourceManager(dst));
+    detail::VariantData::copy(getData(dst), getData(src),
+                              getResourceManager(dst));
   }
 
   static JsonVariantConst fromJson(JsonVariantConst src) {
@@ -85,8 +86,9 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 template <typename TDerived>
 inline JsonVariant VariantRefBase<TDerived>::add() const {
-  return JsonVariant(variantAddElement(getOrCreateData(), getResourceManager()),
-                     getResourceManager());
+  return JsonVariant(
+      detail::VariantData::addElement(getOrCreateData(), getResourceManager()),
+      getResourceManager());
 }
 
 template <typename TDerived>
@@ -103,7 +105,7 @@ template <typename TDerived>
 template <typename T>
 typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type
 VariantRefBase<TDerived>::to() const {
-  variantSetNull(getOrCreateData(), getResourceManager());
+  detail::VariantData::setNull(getOrCreateData(), getResourceManager());
   return *this;
 }
 

src/ArduinoJson/Variant/JsonVariantConst.hpp

@@ -37,8 +37,7 @@ class JsonVariantConst : public detail::VariantTag,
   // Returns true if the value is null or the reference is unbound.
   // https://arduinojson.org/v6/api/jsonvariantconst/isnull/
   FORCE_INLINE bool isNull() const {
-    using namespace detail;
-    return variantIsNull(data_);
+    return detail::VariantData::isNull(data_);
   }
 
   // Returns true if the reference is unbound.
@@ -55,13 +54,13 @@ class JsonVariantConst : public detail::VariantTag,
   // Returns the depth (nesting level) of the value.
   // https://arduinojson.org/v6/api/jsonvariantconst/nesting/
   FORCE_INLINE size_t nesting() const {
-    return variantNesting(data_);
+    return detail::VariantData::nesting(data_);
   }
 
   // Returns the size of the array or object.
   // https://arduinojson.org/v6/api/jsonvariantconst/size/
   size_t size() const {
-    return variantSize(data_);
+    return detail::VariantData::size(data_);
   }
 
   // Casts the value to the specified type.
@@ -92,7 +91,7 @@ class JsonVariantConst : public detail::VariantTag,
   // Gets array's element at specified index.
   // https://arduinojson.org/v6/api/jsonvariantconst/subscript/
   FORCE_INLINE JsonVariantConst operator[](size_t index) const {
-    return JsonVariantConst(variantGetElement(data_, index));
+    return JsonVariantConst(detail::VariantData::getElement(data_, index));
   }
 
   // Gets object's member with specified key.
@@ -101,7 +100,8 @@ class JsonVariantConst : public detail::VariantTag,
   FORCE_INLINE typename detail::enable_if<detail::IsString<TString>::value,
                                           JsonVariantConst>::type
   operator[](const TString& key) const {
-    return JsonVariantConst(variantGetMember(data_, detail::adaptString(key)));
+    return JsonVariantConst(
+        detail::VariantData::getMember(data_, detail::adaptString(key)));
   }
 
   // Gets object's member with specified key.
@@ -110,7 +110,8 @@ class JsonVariantConst : public detail::VariantTag,
   FORCE_INLINE typename detail::enable_if<detail::IsString<TChar*>::value,
                                           JsonVariantConst>::type
   operator[](TChar* key) const {
-    return JsonVariantConst(variantGetMember(data_, detail::adaptString(key)));
+    return JsonVariantConst(
+        detail::VariantData::getMember(data_, detail::adaptString(key)));
   }
 
   // Returns true if tge object contains the specified key.
@@ -119,7 +120,8 @@ class JsonVariantConst : public detail::VariantTag,
   FORCE_INLINE
       typename detail::enable_if<detail::IsString<TString>::value, bool>::type
       containsKey(const TString& key) const {
-    return variantGetMember(getData(), detail::adaptString(key)) != 0;
+    return detail::VariantData::getMember(getData(),
+                                          detail::adaptString(key)) != 0;
   }
 
   // Returns true if tge object contains the specified key.
@@ -128,7 +130,8 @@ class JsonVariantConst : public detail::VariantTag,
   FORCE_INLINE
       typename detail::enable_if<detail::IsString<TChar*>::value, bool>::type
       containsKey(TChar* key) const {
-    return variantGetMember(getData(), detail::adaptString(key)) != 0;
+    return detail::VariantData::getMember(getData(),
+                                          detail::adaptString(key)) != 0;
   }
 
  protected:

src/ArduinoJson/Variant/VariantCompare.hpp

@@ -176,7 +176,7 @@ struct VariantComparer : ComparerBase {
  private:
   template <typename TComparer>
   CompareResult accept(TComparer& comparer) {
-    CompareResult reversedResult = variantAccept(rhs, comparer);
+    CompareResult reversedResult = VariantData::accept(rhs, comparer);
     switch (reversedResult) {
       case COMPARE_RESULT_GREATER:
         return COMPARE_RESULT_LESS;
@@ -199,12 +199,12 @@ struct Comparer<T, typename enable_if<is_convertible<
 template <typename T>
 CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T& rhs) {
   Comparer<T> comparer(rhs);
-  return variantAccept(VariantAttorney::getData(lhs), comparer);
+  return VariantData::accept(VariantAttorney::getData(lhs), comparer);
 }
 
 inline CompareResult compare(const VariantData* lhs, const VariantData* rhs) {
   VariantComparer comparer(rhs);
-  return variantAccept(lhs, comparer);
+  return VariantData::accept(lhs, comparer);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Variant/VariantData.hpp

@@ -63,11 +63,26 @@ class VariantData {
     }
   }
 
+  template <typename TVisitor>
+  static typename TVisitor::result_type accept(const VariantData* var,
+                                               TVisitor& visitor) {
+    if (var != 0)
+      return var->accept(visitor);
+    else
+      return visitor.visitNull();
+  }
+
   VariantData* addElement(ResourceManager* resources) {
     auto array = isNull() ? &toArray() : asArray();
     return detail::ArrayData::addElement(array, resources);
   }
 
+  static VariantData* addElement(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return nullptr;
+    return var->addElement(resources);
+  }
+
   bool asBoolean() const {
     switch (type()) {
       case VALUE_IS_BOOLEAN:
@@ -201,6 +216,13 @@ class VariantData {
     }
   }
 
+  static bool copy(VariantData* dst, const VariantData* src,
+                   ResourceManager* resources) {
+    if (!dst)
+      return false;
+    return dst->copyFrom(src, resources);
+  }
+
   VariantData* getElement(size_t index) const {
     auto array = asArray();
     if (!array)
@@ -208,6 +230,10 @@ class VariantData {
     return array->getElement(index);
   }
 
+  static VariantData* getElement(const VariantData* var, size_t index) {
+    return var != 0 ? var->getElement(index) : 0;
+  }
+
   template <typename TAdaptedString>
   VariantData* getMember(TAdaptedString key) const {
     auto object = asObject();
@@ -216,6 +242,13 @@ class VariantData {
     return object->getMember(key);
   }
 
+  template <typename TAdaptedString>
+  static VariantData* getMember(const VariantData* var, TAdaptedString key) {
+    if (!var)
+      return 0;
+    return var->getMember(key);
+  }
+
   VariantData* getOrAddElement(size_t index, ResourceManager* resources) {
     auto array = isNull() ? &toArray() : asArray();
     if (!array)
@@ -267,6 +300,12 @@ class VariantData {
     return type() == VALUE_IS_NULL;
   }
 
+  static bool isNull(const VariantData* var) {
+    if (!var)
+      return true;
+    return var->isNull();
+  }
+
   bool isObject() const {
     return (flags_ & VALUE_IS_OBJECT) != 0;
   }
@@ -307,6 +346,12 @@ class VariantData {
     return maxChildNesting + 1;
   }
 
+  static size_t nesting(const VariantData* var) {
+    if (!var)
+      return 0;
+    return var->nesting();
+  }
+
   void operator=(const VariantData& src) {
     content_ = src.content_;
     flags_ = uint8_t((flags_ & OWNED_KEY_BIT) | (src.flags_ & ~OWNED_KEY_BIT));
@@ -316,11 +361,26 @@ class VariantData {
     ArrayData::removeElement(asArray(), index, resources);
   }
 
+  static void removeElement(VariantData* var, size_t index,
+                            ResourceManager* resources) {
+    if (!var)
+      return;
+    var->removeElement(index, resources);
+  }
+
   template <typename TAdaptedString>
   void removeMember(TAdaptedString key, ResourceManager* resources) {
     ObjectData::removeMember(asObject(), key, resources);
   }
 
+  template <typename TAdaptedString>
+  static void removeMember(VariantData* var, TAdaptedString key,
+                           ResourceManager* resources) {
+    if (!var)
+      return;
+    var->removeMember(key, resources);
+  }
+
   void reset() {
     flags_ = VALUE_IS_NULL;
   }
@@ -372,6 +432,12 @@ class VariantData {
     setNull();
   }
 
+  static void setNull(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return;
+    var->setNull(resources);
+  }
+
   void setRawString(StringNode* s) {
     ARDUINOJSON_ASSERT(s);
     setType(VALUE_IS_RAW_STRING);
@@ -388,6 +454,14 @@ class VariantData {
       setNull();
   }
 
+  template <typename T>
+  static void setRawString(VariantData* var, SerializedValue<T> value,
+                           ResourceManager* resources) {
+    if (!var)
+      return;
+    var->setRawString(value, resources);
+  }
+
   template <typename TAdaptedString>
   void setString(TAdaptedString value, ResourceManager* resources) {
     setNull(resources);
@@ -405,6 +479,14 @@ class VariantData {
       setOwnedString(dup);
   }
 
+  template <typename TAdaptedString>
+  static void setString(VariantData* var, TAdaptedString value,
+                        ResourceManager* resources) {
+    if (!var)
+      return;
+    var->setString(value, resources);
+  }
+
   void setLinkedString(const char* s) {
     ARDUINOJSON_ASSERT(s);
     setType(VALUE_IS_LINKED_STRING);
@@ -421,6 +503,10 @@ class VariantData {
     return isCollection() ? content_.asCollection.size() : 0;
   }
 
+  static size_t size(const VariantData* var) {
+    return var != 0 ? var->size() : 0;
+  }
+
   ArrayData& toArray() {
     setType(VALUE_IS_ARRAY);
     new (&content_.asArray) ArrayData();
@@ -432,6 +518,12 @@ class VariantData {
     return toArray();
   }
 
+  static ArrayData* toArray(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return 0;
+    return &var->toArray(resources);
+  }
+
   ObjectData& toObject() {
     setType(VALUE_IS_OBJECT);
     new (&content_.asObject) ObjectData();
@@ -443,6 +535,12 @@ class VariantData {
     return toObject();
   }
 
+  static ObjectData* toObject(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return 0;
+    return &var->toObject(resources);
+  }
+
   uint8_t type() const {
     return flags_ & VALUE_MASK;
   }
@@ -465,140 +563,4 @@ class VariantData {
   }
 };
 
-template <typename TVisitor>
-typename TVisitor::result_type variantAccept(const VariantData* var,
-                                             TVisitor& visitor) {
-  if (var != 0)
-    return var->accept(visitor);
-  else
-    return visitor.visitNull();
-}
-
-inline bool variantCopyFrom(VariantData* dst, const VariantData* src,
-                            ResourceManager* resources) {
-  if (!dst)
-    return false;
-  return dst->copyFrom(src, resources);
-}
-
-inline VariantData* variantAddElement(VariantData* var,
-                                      ResourceManager* resources) {
-  if (!var)
-    return nullptr;
-  return var->addElement(resources);
-}
-
-inline VariantData* variantGetElement(const VariantData* var, size_t index) {
-  return var != 0 ? var->getElement(index) : 0;
-}
-
-template <typename TAdaptedString>
-VariantData* variantGetMember(const VariantData* var, TAdaptedString key) {
-  if (!var)
-    return 0;
-  return var->getMember(key);
-}
-
-inline VariantData* variantGetOrAddElement(VariantData* var, size_t index,
-                                           ResourceManager* resources) {
-  if (!var)
-    return nullptr;
-  return var->getOrAddElement(index, resources);
-}
-
-template <typename TAdaptedString>
-VariantData* variantGetOrAddMember(VariantData* var, TAdaptedString key,
-                                   ResourceManager* resources) {
-  if (!var)
-    return nullptr;
-  return var->getOrAddMember(key, resources);
-}
-
-inline bool variantIsNull(const VariantData* var) {
-  if (!var)
-    return true;
-  return var->isNull();
-}
-
-inline size_t variantNesting(const VariantData* var) {
-  if (!var)
-    return 0;
-  return var->nesting();
-}
-
-inline void variantRemoveElement(VariantData* var, size_t index,
-                                 ResourceManager* resources) {
-  if (!var)
-    return;
-  var->removeElement(index, resources);
-}
-
-template <typename TAdaptedString>
-void variantRemoveMember(VariantData* var, TAdaptedString key,
-                         ResourceManager* resources) {
-  if (!var)
-    return;
-  var->removeMember(key, resources);
-}
-
-inline void variantSetBoolean(VariantData* var, bool value,
-                              ResourceManager* resources) {
-  if (!var)
-    return;
-  var->setBoolean(value, resources);
-}
-
-inline void variantSetFloat(VariantData* var, JsonFloat value,
-                            ResourceManager* resources) {
-  if (!var)
-    return;
-  var->setFloat(value, resources);
-}
-
-template <typename T>
-void variantSetInteger(VariantData* var, T value, ResourceManager* resources) {
-  if (!var)
-    return;
-  var->setInteger(value, resources);
-}
-
-inline void variantSetNull(VariantData* var, ResourceManager* resources) {
-  if (!var)
-    return;
-  var->setNull(resources);
-}
-
-template <typename T>
-void variantSetRawString(VariantData* var, SerializedValue<T> value,
-                         ResourceManager* resources) {
-  if (!var)
-    return;
-  var->setRawString(value, resources);
-}
-
-template <typename TAdaptedString>
-void variantSetString(VariantData* var, TAdaptedString value,
-                      ResourceManager* resources) {
-  if (!var)
-    return;
-  var->setString(value, resources);
-}
-
-inline size_t variantSize(const VariantData* var) {
-  return var != 0 ? var->size() : 0;
-}
-
-inline ArrayData* variantToArray(VariantData* var, ResourceManager* resources) {
-  if (!var)
-    return 0;
-  return &var->toArray(resources);
-}
-
-inline ObjectData* variantToObject(VariantData* var,
-                                   ResourceManager* resources) {
-  if (!var)
-    return 0;
-  return &var->toObject(resources);
-}
-
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Variant/VariantRefBase.hpp

@@ -30,13 +30,13 @@ class VariantRefBase : public VariantTag {
   // ⚠️ Doesn't release the memory associated with the previous value.
   // https://arduinojson.org/v6/api/jsonvariant/clear/
   FORCE_INLINE void clear() const {
-    variantSetNull(getOrCreateData(), getResourceManager());
+    VariantData::setNull(getOrCreateData(), getResourceManager());
   }
 
   // Returns true if the value is null or the reference is unbound.
   // https://arduinojson.org/v6/api/jsonvariant/isnull/
   FORCE_INLINE bool isNull() const {
-    return variantIsNull(getData());
+    return VariantData::isNull(getData());
   }
 
   // Returns true if the reference is unbound.
@@ -112,7 +112,7 @@ class VariantRefBase : public VariantTag {
     VariantData* data = getOrCreateData();
     if (!data)
       return;
-    variantSetNull(data, getResourceManager());
+    data->setNull(getResourceManager());
     const VariantData* targetData = VariantAttorney::getData(target);
     if (targetData)
       *data = *targetData;
@@ -139,7 +139,7 @@ class VariantRefBase : public VariantTag {
   // Returns the size of the array or object.
   // https://arduinojson.org/v6/api/jsonvariant/size/
   FORCE_INLINE size_t size() const {
-    return variantSize(getData());
+    return VariantData::size(getData());
   }
 
   // Returns the number of bytes occupied by the value.
@@ -152,7 +152,7 @@ class VariantRefBase : public VariantTag {
   // Returns the depth (nesting level) of the value.
   // https://arduinojson.org/v6/api/jsonvariant/nesting/
   FORCE_INLINE size_t nesting() const {
-    return variantNesting(getData());
+    return VariantData::nesting(getData());
   }
 
   // Appends a new (null) element to the array.
@@ -178,7 +178,7 @@ class VariantRefBase : public VariantTag {
   // ⚠️ Doesn't release the memory associated with the removed element.
   // https://arduinojson.org/v6/api/jsonvariant/remove/
   FORCE_INLINE void remove(size_t index) const {
-    variantRemoveElement(getData(), index, getResourceManager());
+    VariantData::removeElement(getData(), index, getResourceManager());
   }
 
   // Removes a member of the object.
@@ -187,7 +187,8 @@ class VariantRefBase : public VariantTag {
   template <typename TChar>
   FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
       TChar* key) const {
-    variantRemoveMember(getData(), adaptString(key), getResourceManager());
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
   }
 
   // Removes a member of the object.
@@ -196,7 +197,8 @@ class VariantRefBase : public VariantTag {
   template <typename TString>
   FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
       const TString& key) const {
-    variantRemoveMember(getData(), adaptString(key), getResourceManager());
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
   }
 
   // Creates an array and appends it to the array.