Rename `VariantRef` to `JsonVariant`

extras/tests/JsonVariant/converters.cpp

@@ -91,7 +91,7 @@ class Complex {
 namespace ARDUINOJSON_NAMESPACE {
 template <>
 struct Converter<Complex> {
-  static void toJson(const Complex& src, VariantRef dst) {
+  static void toJson(const Complex& src, JsonVariant dst) {
     dst["real"] = src.real();
     dst["imag"] = src.imag();
   }

extras/tests/Misc/TypeTraits.cpp

@@ -181,7 +181,7 @@ TEST_CASE("Polyfills/type_traits") {
     CHECK((is_convertible<DeserializationError, JsonVariantConst>::value ==
            false));
     CHECK((is_convertible<JsonPair, JsonVariantConst>::value == false));
-    CHECK((is_convertible<VariantRef, JsonVariantConst>::value == true));
+    CHECK((is_convertible<JsonVariant, JsonVariantConst>::value == true));
     CHECK((is_convertible<JsonVariantConst, JsonVariantConst>::value == true));
     CHECK((is_convertible<JsonArray, JsonVariantConst>::value == true));
     CHECK((is_convertible<ElementProxy<JsonArray>, JsonVariantConst>::value ==

src/ArduinoJson.hpp

@@ -47,8 +47,15 @@
 #include "ArduinoJson/compatibility.hpp"
 
 namespace ArduinoJson {
+using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
+using ARDUINOJSON_NAMESPACE::copyArray;
+using ARDUINOJSON_NAMESPACE::DeserializationError;
+using ARDUINOJSON_NAMESPACE::deserializeJson;
+using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
+using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
 using ARDUINOJSON_NAMESPACE::JsonArray;
 using ARDUINOJSON_NAMESPACE::JsonArrayConst;
+using ARDUINOJSON_NAMESPACE::JsonDocument;
 using ARDUINOJSON_NAMESPACE::JsonFloat;
 using ARDUINOJSON_NAMESPACE::JsonInteger;
 using ARDUINOJSON_NAMESPACE::JsonObject;
@@ -57,15 +64,8 @@ using ARDUINOJSON_NAMESPACE::JsonPair;
 using ARDUINOJSON_NAMESPACE::JsonPairConst;
 using ARDUINOJSON_NAMESPACE::JsonString;
 using ARDUINOJSON_NAMESPACE::JsonUInt;
+using ARDUINOJSON_NAMESPACE::JsonVariant;
 using ARDUINOJSON_NAMESPACE::JsonVariantConst;
-typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant;
-using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
-using ARDUINOJSON_NAMESPACE::copyArray;
-using ARDUINOJSON_NAMESPACE::DeserializationError;
-using ARDUINOJSON_NAMESPACE::deserializeJson;
-using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
-using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
-using ARDUINOJSON_NAMESPACE::JsonDocument;
 using ARDUINOJSON_NAMESPACE::measureJson;
 using ARDUINOJSON_NAMESPACE::serialized;
 using ARDUINOJSON_NAMESPACE::serializeJson;

src/ArduinoJson/Array/JsonArray.hpp

@@ -21,19 +21,19 @@ class JsonArray : public VariantOperators<JsonArray> {
   FORCE_INLINE JsonArray(MemoryPool* pool, CollectionData* data)
       : _data(data), _pool(pool) {}
 
-  operator VariantRef() {
+  operator JsonVariant() {
     void* data = _data;  // prevent warning cast-align
-    return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
+    return JsonVariant(_pool, reinterpret_cast<VariantData*>(data));
   }
 
   operator JsonArrayConst() const {
     return JsonArrayConst(_data);
   }
 
-  VariantRef add() const {
+  JsonVariant add() const {
     if (!_data)
-      return VariantRef();
-    return VariantRef(_pool, _data->addElement(_pool));
+      return JsonVariant();
+    return JsonVariant(_pool, _data->addElement(_pool));
   }
 
   template <typename T>
@@ -141,11 +141,11 @@ class JsonArray : public VariantOperators<JsonArray> {
 
 template <>
 struct Converter<JsonArray> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static JsonArray fromJson(VariantRef src) {
+  static JsonArray fromJson(JsonVariant src) {
     VariantData* data = getData(src);
     MemoryPool* pool = getPool(src);
     return JsonArray(pool, data != 0 ? data->asArray() : 0);
@@ -158,7 +158,7 @@ struct Converter<JsonArray> : private VariantAttorney {
     return false;
   }
 
-  static bool checkJson(VariantRef src) {
+  static bool checkJson(JsonVariant src) {
     VariantData* data = getData(src);
     return data && data->isArray();
   }

src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -93,7 +93,7 @@ class JsonArrayConst : public VariantOperators<JsonArrayConst> {
 
 template <>
 struct Converter<JsonArrayConst> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 

src/ArduinoJson/Array/JsonArrayIterator.hpp

@@ -4,8 +4,8 @@
 
 #pragma once
 
+#include <ArduinoJson/Variant/JsonVariant.hpp>
 #include <ArduinoJson/Variant/SlotFunctions.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 
@@ -13,16 +13,16 @@ class VariantPtr {
  public:
   VariantPtr(MemoryPool* pool, VariantData* data) : _variant(pool, data) {}
 
-  VariantRef* operator->() {
+  JsonVariant* operator->() {
     return &_variant;
   }
 
-  VariantRef& operator*() {
+  JsonVariant& operator*() {
     return _variant;
   }
 
  private:
-  VariantRef _variant;
+  JsonVariant _variant;
 };
 
 class JsonArrayIterator {
@@ -33,8 +33,8 @@ class JsonArrayIterator {
   explicit JsonArrayIterator(MemoryPool* pool, VariantSlot* slot)
       : _pool(pool), _slot(slot) {}
 
-  VariantRef operator*() const {
-    return VariantRef(_pool, _slot->data());
+  JsonVariant operator*() const {
+    return JsonVariant(_pool, _slot->data());
   }
   VariantPtr operator->() {
     return VariantPtr(_pool, _slot->data());

src/ArduinoJson/Array/Utilities.hpp

@@ -12,7 +12,7 @@ namespace ARDUINOJSON_NAMESPACE {
 // Trivial form to stop the recursion
 template <typename T>
 inline typename enable_if<!is_array<T>::value, bool>::type copyArray(
-    const T& src, VariantRef dst) {
+    const T& src, JsonVariant dst) {
   return dst.set(src);
 }
 

src/ArduinoJson/Document/BasicJsonDocument.hpp

@@ -65,7 +65,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
   BasicJsonDocument(
       const T& src,
       typename enable_if<
-          is_same<T, VariantRef>::value ||
+          is_same<T, JsonVariant>::value ||
           is_same<T, JsonVariantConst>::value || is_same<T, JsonArray>::value ||
           is_same<T, JsonArrayConst>::value || is_same<T, JsonObject>::value ||
           is_same<T, JsonObjectConst>::value>::type* = 0)
@@ -74,7 +74,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
   }
 
   // disambiguate
-  BasicJsonDocument(VariantRef src)
+  BasicJsonDocument(JsonVariant src)
       : JsonDocument(allocPool(src.memoryUsage())) {
     set(src);
   }

src/ArduinoJson/Document/JsonDocument.hpp

@@ -68,13 +68,13 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
   }
 
   bool set(const JsonDocument& src) {
-    return to<VariantRef>().set(src.as<JsonVariantConst>());
+    return to<JsonVariant>().set(src.as<JsonVariantConst>());
   }
 
   template <typename T>
   typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set(
       const T& src) {
-    return to<VariantRef>().set(src);
+    return to<JsonVariant>().set(src);
   }
 
   template <typename T>
@@ -182,8 +182,8 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     return JsonVariantConst(_data.getElement(index));
   }
 
-  FORCE_INLINE VariantRef add() {
-    return VariantRef(&_pool, _data.addElement(&_pool));
+  FORCE_INLINE JsonVariant add() {
+    return JsonVariant(&_pool, _data.addElement(&_pool));
   }
 
   template <typename TValue>
@@ -218,7 +218,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     _data.remove(adaptString(key));
   }
 
-  FORCE_INLINE operator VariantRef() {
+  FORCE_INLINE operator JsonVariant() {
     return getVariant();
   }
 
@@ -245,8 +245,8 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     _pool = pool;
   }
 
-  VariantRef getVariant() {
-    return VariantRef(&_pool, &_data);
+  JsonVariant getVariant() {
+    return JsonVariant(&_pool, &_data);
   }
 
   JsonVariantConst getVariant() const {
@@ -278,7 +278,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
   }
 };
 
-inline void convertToJson(const JsonDocument& src, VariantRef dst) {
+inline void convertToJson(const JsonDocument& src, JsonVariant dst) {
   dst.set(src.as<JsonVariantConst>());
 }
 

src/ArduinoJson/Document/StaticJsonDocument.hpp

@@ -30,7 +30,7 @@ class StaticJsonDocument : public JsonDocument {
   }
 
   // disambiguate
-  StaticJsonDocument(VariantRef src) : JsonDocument(_buffer, _capacity) {
+  StaticJsonDocument(JsonVariant src) : JsonDocument(_buffer, _capacity) {
     set(src);
   }
 

src/ArduinoJson/Object/JsonObject.hpp

@@ -21,9 +21,9 @@ class JsonObject : public VariantOperators<JsonObject> {
   FORCE_INLINE JsonObject(MemoryPool* buf, CollectionData* data)
       : _data(data), _pool(buf) {}
 
-  operator VariantRef() const {
+  operator JsonVariant() const {
     void* data = _data;  // prevent warning cast-align
-    return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
+    return JsonVariant(_pool, reinterpret_cast<VariantData*>(data));
   }
 
   operator JsonObjectConst() const {
@@ -176,11 +176,11 @@ class JsonObject : public VariantOperators<JsonObject> {
 
 template <>
 struct Converter<JsonObject> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static JsonObject fromJson(VariantRef src) {
+  static JsonObject fromJson(JsonVariant src) {
     VariantData* data = getData(src);
     MemoryPool* pool = getPool(src);
     return JsonObject(pool, data != 0 ? data->asObject() : 0);
@@ -193,7 +193,7 @@ struct Converter<JsonObject> : private VariantAttorney {
     return false;
   }
 
-  static bool checkJson(VariantRef src) {
+  static bool checkJson(JsonVariant src) {
     VariantData* data = getData(src);
     return data && data->isObject();
   }

src/ArduinoJson/Object/JsonObjectConst.hpp

@@ -120,7 +120,7 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
 
 template <>
 struct Converter<JsonObjectConst> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 

src/ArduinoJson/Object/JsonPair.hpp

@@ -5,8 +5,8 @@
 #pragma once
 
 #include <ArduinoJson/Strings/JsonString.hpp>
+#include <ArduinoJson/Variant/JsonVariant.hpp>
 #include <ArduinoJson/Variant/JsonVariantConst.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 // A key value pair for CollectionData.
@@ -16,7 +16,7 @@ class JsonPair {
     if (slot) {
       _key = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
                                                      : JsonString::Linked);
-      _value = VariantRef(pool, slot->data());
+      _value = JsonVariant(pool, slot->data());
     }
   }
 
@@ -24,13 +24,13 @@ class JsonPair {
     return _key;
   }
 
-  VariantRef value() const {
+  JsonVariant value() const {
     return _value;
   }
 
  private:
   JsonString _key;
-  VariantRef _value;
+  JsonVariant _value;
 };
 
 class JsonPairConst {

src/ArduinoJson/Variant/ConverterImpl.hpp

@@ -12,7 +12,7 @@ namespace ARDUINOJSON_NAMESPACE {
 
 template <typename T, typename Enable>
 struct Converter {
-  static void toJson(const T& src, VariantRef dst) {
+  static void toJson(const T& src, JsonVariant dst) {
     // clang-format off
     convertToJson(src, dst); // Error here? See https://arduinojson.org/v6/unsupported-set/
     // clang-format on
@@ -39,7 +39,7 @@ struct Converter<
     T, typename enable_if<is_integral<T>::value && !is_same<bool, T>::value &&
                           !is_same<char, T>::value>::type>
     : private VariantAttorney {
-  static void toJson(T src, VariantRef dst) {
+  static void toJson(T src, JsonVariant dst) {
     VariantData* data = getData(dst);
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
     if (data)
@@ -61,7 +61,7 @@ struct Converter<
 template <typename T>
 struct Converter<T, typename enable_if<is_enum<T>::value>::type>
     : private VariantAttorney {
-  static void toJson(T src, VariantRef dst) {
+  static void toJson(T src, JsonVariant dst) {
     dst.set(static_cast<JsonInteger>(src));
   }
 
@@ -78,7 +78,7 @@ struct Converter<T, typename enable_if<is_enum<T>::value>::type>
 
 template <>
 struct Converter<bool> : private VariantAttorney {
-  static void toJson(bool src, VariantRef dst) {
+  static void toJson(bool src, JsonVariant dst) {
     VariantData* data = getData(dst);
     if (data)
       data->setBoolean(src);
@@ -98,7 +98,7 @@ struct Converter<bool> : private VariantAttorney {
 template <typename T>
 struct Converter<T, typename enable_if<is_floating_point<T>::value>::type>
     : private VariantAttorney {
-  static void toJson(T src, VariantRef dst) {
+  static void toJson(T src, JsonVariant dst) {
     VariantData* data = getData(dst);
     if (data)
       data->setFloat(static_cast<JsonFloat>(src));
@@ -117,7 +117,7 @@ struct Converter<T, typename enable_if<is_floating_point<T>::value>::type>
 
 template <>
 struct Converter<const char*> : private VariantAttorney {
-  static void toJson(const char* src, VariantRef dst) {
+  static void toJson(const char* src, JsonVariant dst) {
     variantSetString(getData(dst), adaptString(src), getPool(dst));
   }
 
@@ -134,7 +134,7 @@ struct Converter<const char*> : private VariantAttorney {
 
 template <>
 struct Converter<JsonString> : private VariantAttorney {
-  static void toJson(JsonString src, VariantRef dst) {
+  static void toJson(JsonString src, JsonVariant dst) {
     variantSetString(getData(dst), adaptString(src), getPool(dst));
   }
 
@@ -151,7 +151,7 @@ struct Converter<JsonString> : private VariantAttorney {
 
 template <typename T>
 inline typename enable_if<IsString<T>::value, bool>::type convertToJson(
-    const T& src, VariantRef dst) {
+    const T& src, JsonVariant dst) {
   VariantData* data = VariantAttorney::getData(dst);
   MemoryPool* pool = VariantAttorney::getPool(dst);
   return variantSetString(data, adaptString(src), pool);
@@ -159,7 +159,7 @@ inline typename enable_if<IsString<T>::value, bool>::type convertToJson(
 
 template <>
 struct Converter<SerializedValue<const char*> > {
-  static void toJson(SerializedValue<const char*> src, VariantRef dst) {
+  static void toJson(SerializedValue<const char*> src, JsonVariant dst) {
     VariantData* data = VariantAttorney::getData(dst);
     if (data)
       data->setLinkedRaw(src);
@@ -173,7 +173,7 @@ template <typename T>
 struct Converter<SerializedValue<T>,
                  typename enable_if<!is_same<const char*, T>::value>::type>
     : private VariantAttorney {
-  static void toJson(SerializedValue<T> src, VariantRef dst) {
+  static void toJson(SerializedValue<T> src, JsonVariant dst) {
     VariantData* data = getData(dst);
     MemoryPool* pool = getPool(dst);
     if (data)
@@ -185,7 +185,7 @@ struct Converter<SerializedValue<T>,
 
 template <>
 struct Converter<decltype(nullptr)> : private VariantAttorney {
-  static void toJson(decltype(nullptr), VariantRef dst) {
+  static void toJson(decltype(nullptr), JsonVariant dst) {
     variantSetNull(getData(dst));
   }
   static decltype(nullptr) fromJson(JsonVariantConst) {
@@ -242,7 +242,7 @@ class MemoryPoolPrint : public Print {
   size_t _capacity;
 };
 
-inline void convertToJson(const ::Printable& src, VariantRef dst) {
+inline void convertToJson(const ::Printable& src, JsonVariant dst) {
   MemoryPool* pool = VariantAttorney::getPool(dst);
   VariantData* data = VariantAttorney::getData(dst);
   if (!pool || !data)
@@ -308,7 +308,7 @@ inline bool canConvertFromJson(JsonVariantConst src, const std::string_view&) {
 template <typename T>
 struct ConverterNeedsWriteableRef {
  protected:  // <- to avoid GCC's "all member functions in class are private"
-  static int probe(T (*f)(VariantRef));
+  static int probe(T (*f)(JsonVariant));
   static char probe(T (*f)(JsonVariantConst));
 
  public:

src/ArduinoJson/Variant/VariantRef.hpp → src/ArduinoJson/Variant/JsonVariant.hpp

@@ -8,14 +8,14 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-class VariantRef : public VariantRefBase<VariantRef>,
-                   public VariantOperators<VariantRef> {
+class JsonVariant : public VariantRefBase<JsonVariant>,
+                    public VariantOperators<JsonVariant> {
   friend class VariantAttorney;
 
  public:
-  VariantRef() : _data(0), _pool(0) {}
+  JsonVariant() : _data(0), _pool(0) {}
 
-  VariantRef(MemoryPool* pool, VariantData* data) : _data(data), _pool(pool) {}
+  JsonVariant(MemoryPool* pool, VariantData* data) : _data(data), _pool(pool) {}
 
  private:
   FORCE_INLINE MemoryPool* getPool() const {
@@ -35,19 +35,19 @@ class VariantRef : public VariantRefBase<VariantRef>,
 };
 
 template <>
-struct Converter<VariantRef> : private VariantAttorney {
-  static void toJson(VariantRef src, VariantRef dst) {
+struct Converter<JsonVariant> : private VariantAttorney {
+  static void toJson(JsonVariant src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static VariantRef fromJson(VariantRef src) {
+  static JsonVariant fromJson(JsonVariant src) {
     return src;
   }
 
-  static InvalidConversion<JsonVariantConst, VariantRef> fromJson(
+  static InvalidConversion<JsonVariantConst, JsonVariant> fromJson(
       JsonVariantConst);
 
-  static bool checkJson(VariantRef src) {
+  static bool checkJson(JsonVariant src) {
     VariantData* data = getData(src);
     return !!data;
   }
@@ -59,7 +59,7 @@ struct Converter<VariantRef> : private VariantAttorney {
 
 template <>
 struct Converter<JsonVariantConst> : private VariantAttorney {
-  static void toJson(JsonVariantConst src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 

src/ArduinoJson/Variant/VariantImpl.hpp

@@ -9,7 +9,7 @@
 #include <ArduinoJson/Numbers/convertNumber.hpp>
 #include <ArduinoJson/Numbers/parseNumber.hpp>
 #include <ArduinoJson/Object/JsonObject.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
+#include <ArduinoJson/Variant/JsonVariant.hpp>
 
 #include <string.h>  // for strcmp
 
@@ -105,18 +105,19 @@ inline bool VariantData::copyFrom(const VariantData& src, MemoryPool* pool) {
 }
 
 template <typename TDerived>
-inline VariantRef VariantRefBase<TDerived>::add() const {
-  return VariantRef(getPool(), variantAddElement(getOrCreateData(), getPool()));
+inline JsonVariant VariantRefBase<TDerived>::add() const {
+  return JsonVariant(getPool(),
+                     variantAddElement(getOrCreateData(), getPool()));
 }
 
 template <typename TDerived>
-inline VariantRef VariantRefBase<TDerived>::getVariant() const {
-  return VariantRef(getPool(), getData());
+inline JsonVariant VariantRefBase<TDerived>::getVariant() const {
+  return JsonVariant(getPool(), getData());
 }
 
 template <typename TDerived>
-inline VariantRef VariantRefBase<TDerived>::getOrCreateVariant() const {
-  return VariantRef(getPool(), getOrCreateData());
+inline JsonVariant VariantRefBase<TDerived>::getOrCreateVariant() const {
+  return JsonVariant(getPool(), getOrCreateData());
 }
 
 template <typename TDerived>
@@ -135,7 +136,7 @@ VariantRefBase<TDerived>::to() const {
 
 template <typename TDerived>
 template <typename T>
-typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type
+typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type
 VariantRefBase<TDerived>::to() const {
   variantSetNull(getOrCreateData());
   return *this;
@@ -148,7 +149,8 @@ inline bool VariantRefBase<TDerived>::set(char value) const {
 }
 
 template <typename TDerived>
-inline void convertToJson(const VariantRefBase<TDerived>& src, VariantRef dst) {
+inline void convertToJson(const VariantRefBase<TDerived>& src,
+                          JsonVariant dst) {
   dst.set(src.template as<JsonVariantConst>());
 }
 

src/ArduinoJson/Variant/VariantOperators.hpp

@@ -21,7 +21,7 @@ struct VariantOperatorTag {};
 
 template <typename TVariant>
 struct VariantOperators : VariantOperatorTag {
-  // Returns the default value if the VariantRef is unbound or incompatible
+  // Returns the default value if the JsonVariant is unbound or incompatible
   //
   // int operator|(JsonVariant, int)
   // float operator|(JsonVariant, float)

src/ArduinoJson/Variant/VariantRefBase.hpp

@@ -12,7 +12,7 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-class VariantRef;
+class JsonVariant;
 
 template <typename>
 class ElementProxy;
@@ -83,9 +83,9 @@ class VariantRefBase : public VariantTag {
   typename enable_if<is_same<T, JsonObject>::value, JsonObject>::type to()
       const;
   //
-  // VariantRef to<VariantRef>()
+  // JsonVariant to<JsonVariant>()
   template <typename T>
-  typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type to()
+  typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type to()
       const;
 
   template <typename T>
@@ -161,7 +161,7 @@ class VariantRefBase : public VariantTag {
     return variantNesting(getData());
   }
 
-  FORCE_INLINE VariantRef add() const;
+  FORCE_INLINE JsonVariant add() const;
 
   template <typename T>
   FORCE_INLINE bool add(const T& value) const {
@@ -256,13 +256,13 @@ class VariantRefBase : public VariantTag {
   }
 
  private:
-  FORCE_INLINE VariantRef getVariant() const;
+  FORCE_INLINE JsonVariant getVariant() const;
 
   FORCE_INLINE JsonVariantConst getVariantConst() const {
     return JsonVariantConst(getData());
   }
 
-  FORCE_INLINE VariantRef getOrCreateVariant() const;
+  FORCE_INLINE JsonVariant getOrCreateVariant() const;
 };
 
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Variant/VariantTo.hpp

@@ -9,10 +9,10 @@
 namespace ARDUINOJSON_NAMESPACE {
 class JsonArray;
 class JsonObject;
-class VariantRef;
+class JsonVariant;
 
 // A metafunction that returns the type of the value returned by
-// VariantRef::to<T>()
+// JsonVariant::to<T>()
 template <typename T>
 struct VariantTo {};
 
@@ -25,8 +25,8 @@ struct VariantTo<JsonObject> {
   typedef JsonObject type;
 };
 template <>
-struct VariantTo<VariantRef> {
-  typedef VariantRef type;
+struct VariantTo<JsonVariant> {
+  typedef JsonVariant type;
 };
 
 }  // namespace ARDUINOJSON_NAMESPACE