Rename VariantConstRef to JsonVariantConst

extras/tests/JsonVariant/converters.cpp

@@ -96,11 +96,11 @@ struct Converter<Complex> {
     dst["imag"] = src.imag();
   }
 
-  static Complex fromJson(VariantConstRef src) {
+  static Complex fromJson(JsonVariantConst src) {
     return Complex(src["real"], src["imag"]);
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     return src["real"].is<double>() && src["imag"].is<double>();
   }
 };

extras/tests/Misc/TypeTraits.cpp

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

src/ArduinoJson.hpp

@@ -23,7 +23,7 @@
 
 #include "ArduinoJson/Array/JsonArray.hpp"
 #include "ArduinoJson/Object/JsonObject.hpp"
-#include "ArduinoJson/Variant/VariantConstRef.hpp"
+#include "ArduinoJson/Variant/JsonVariantConst.hpp"
 
 #include "ArduinoJson/Document/DynamicJsonDocument.hpp"
 #include "ArduinoJson/Document/StaticJsonDocument.hpp"
@@ -57,7 +57,7 @@ using ARDUINOJSON_NAMESPACE::JsonPair;
 using ARDUINOJSON_NAMESPACE::JsonPairConst;
 using ARDUINOJSON_NAMESPACE::JsonString;
 using ARDUINOJSON_NAMESPACE::JsonUInt;
-typedef ARDUINOJSON_NAMESPACE::VariantConstRef JsonVariantConst;
+using ARDUINOJSON_NAMESPACE::JsonVariantConst;
 typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant;
 using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
 using ARDUINOJSON_NAMESPACE::copyArray;

src/ArduinoJson/Array/JsonArray.hpp

@@ -98,8 +98,8 @@ class JsonArray : public VariantOperators<JsonArray> {
     return add().to<JsonArray>();
   }
 
-  operator VariantConstRef() const {
+  operator JsonVariantConst() const {
-    return VariantConstRef(collectionToVariant(_data));
+    return JsonVariantConst(collectionToVariant(_data));
   }
 
   FORCE_INLINE bool isNull() const {
@@ -141,7 +141,7 @@ class JsonArray : public VariantOperators<JsonArray> {
 
 template <>
 struct Converter<JsonArray> : private VariantAttorney {
-  static void toJson(VariantConstRef src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, VariantRef dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
@@ -151,10 +151,10 @@ struct Converter<JsonArray> : private VariantAttorney {
     return JsonArray(pool, data != 0 ? data->asArray() : 0);
   }
 
-  static InvalidConversion<VariantConstRef, JsonArray> fromJson(
+  static InvalidConversion<JsonVariantConst, JsonArray> fromJson(
-      VariantConstRef);
+      JsonVariantConst);
 
-  static bool checkJson(VariantConstRef) {
+  static bool checkJson(JsonVariantConst) {
     return false;
   }
 

src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -55,12 +55,12 @@ class JsonArrayConst : public VariantOperators<JsonArrayConst> {
     }
   }
 
-  FORCE_INLINE VariantConstRef operator[](size_t index) const {
+  FORCE_INLINE JsonVariantConst operator[](size_t index) const {
-    return VariantConstRef(_data ? _data->getElement(index) : 0);
+    return JsonVariantConst(_data ? _data->getElement(index) : 0);
   }
 
-  operator VariantConstRef() const {
+  operator JsonVariantConst() const {
-    return VariantConstRef(collectionToVariant(_data));
+    return JsonVariantConst(collectionToVariant(_data));
   }
 
   FORCE_INLINE bool isNull() const {
@@ -93,16 +93,16 @@ class JsonArrayConst : public VariantOperators<JsonArrayConst> {
 
 template <>
 struct Converter<JsonArrayConst> : private VariantAttorney {
-  static void toJson(VariantConstRef src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, VariantRef dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static JsonArrayConst fromJson(VariantConstRef src) {
+  static JsonArrayConst fromJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data ? data->asArray() : 0;
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isArray();
   }

src/ArduinoJson/Array/JsonArrayIterator.hpp

@@ -67,16 +67,16 @@ class VariantConstPtr {
  public:
   VariantConstPtr(const VariantData* data) : _variant(data) {}
 
-  VariantConstRef* operator->() {
+  JsonVariantConst* operator->() {
     return &_variant;
   }
 
-  VariantConstRef& operator*() {
+  JsonVariantConst& operator*() {
     return _variant;
   }
 
  private:
-  VariantConstRef _variant;
+  JsonVariantConst _variant;
 };
 
 class JsonArrayConstIterator {
@@ -86,8 +86,8 @@ class JsonArrayConstIterator {
   JsonArrayConstIterator() : _slot(0) {}
   explicit JsonArrayConstIterator(const VariantSlot* slot) : _slot(slot) {}
 
-  VariantConstRef operator*() const {
+  JsonVariantConst operator*() const {
-    return VariantConstRef(_slot->data());
+    return JsonVariantConst(_slot->data());
   }
   VariantConstPtr operator->() {
     return VariantConstPtr(_slot->data());

src/ArduinoJson/Array/Utilities.hpp

@@ -57,7 +57,7 @@ inline bool copyArray(const T* src, size_t len, JsonDocument& dst) {
 // Trivial case form to stop the recursion
 template <typename T>
 inline typename enable_if<!is_array<T>::value, size_t>::type copyArray(
-    VariantConstRef src, T& dst) {
+    JsonVariantConst src, T& dst) {
   dst = src.as<T>();
   return 1;
 }
@@ -80,7 +80,7 @@ inline size_t copyArray(JsonArrayConst src, T* dst, size_t len) {
 
 // Special case for char[] which must be treated as a string
 template <size_t N>
-inline size_t copyArray(VariantConstRef src, char (&dst)[N]) {
+inline size_t copyArray(JsonVariantConst src, char (&dst)[N]) {
   JsonString s = src;
   size_t len = N - 1;
   if (len > s.size())

src/ArduinoJson/Deserialization/Filter.hpp

@@ -10,7 +10,7 @@ namespace ARDUINOJSON_NAMESPACE {
 
 class Filter {
  public:
-  explicit Filter(VariantConstRef v) : _variant(v) {}
+  explicit Filter(JsonVariantConst v) : _variant(v) {}
 
   bool allow() const {
     return _variant;
@@ -32,12 +32,12 @@ class Filter {
   Filter operator[](const TKey& key) const {
     if (_variant == true)  // "true" means "allow recursively"
       return *this;
-    VariantConstRef member = _variant[key];
+    JsonVariantConst member = _variant[key];
     return Filter(member.isNull() ? _variant["*"] : member);
   }
 
  private:
-  VariantConstRef _variant;
+  JsonVariantConst _variant;
 };
 
 struct AllowAllFilter {

src/ArduinoJson/Deserialization/Readers/VariantReader.hpp

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <ArduinoJson/Object/MemberProxy.hpp>
-#include <ArduinoJson/Variant/VariantConstRef.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 

src/ArduinoJson/Document/BasicJsonDocument.hpp

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

src/ArduinoJson/Document/JsonDocument.hpp

@@ -9,10 +9,9 @@
 #include <ArduinoJson/Object/JsonObject.hpp>
 #include <ArduinoJson/Object/MemberProxy.hpp>
 #include <ArduinoJson/Strings/StoragePolicy.hpp>
-#include <ArduinoJson/Variant/VariantConstRef.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
 #include <ArduinoJson/Variant/VariantTo.hpp>
 
-
 namespace ARDUINOJSON_NAMESPACE {
 
 class JsonDocument : public VariantOperators<const JsonDocument&> {
@@ -69,7 +68,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
   }
 
   bool set(const JsonDocument& src) {
-    return to<VariantRef>().set(src.as<VariantConstRef>());
+    return to<VariantRef>().set(src.as<JsonVariantConst>());
   }
 
   template <typename T>
@@ -160,9 +159,9 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
   // operator[](const String&) const
   template <typename TString>
   FORCE_INLINE
-      typename enable_if<IsString<TString>::value, VariantConstRef>::type
+      typename enable_if<IsString<TString>::value, JsonVariantConst>::type
       operator[](const TString& key) const {
-    return VariantConstRef(_data.getMember(adaptString(key)));
+    return JsonVariantConst(_data.getMember(adaptString(key)));
   }
 
   // operator[](char*) const
@@ -170,17 +169,17 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
   // operator[](const __FlashStringHelper*) const
   template <typename TChar>
   FORCE_INLINE
-      typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
+      typename enable_if<IsString<TChar*>::value, JsonVariantConst>::type
       operator[](TChar* key) const {
-    return VariantConstRef(_data.getMember(adaptString(key)));
+    return JsonVariantConst(_data.getMember(adaptString(key)));
   }
 
   FORCE_INLINE ElementProxy<JsonDocument&> operator[](size_t index) {
     return ElementProxy<JsonDocument&>(*this, index);
   }
 
-  FORCE_INLINE VariantConstRef operator[](size_t index) const {
+  FORCE_INLINE JsonVariantConst operator[](size_t index) const {
-    return VariantConstRef(_data.getElement(index));
+    return JsonVariantConst(_data.getElement(index));
   }
 
   FORCE_INLINE VariantRef add() {
@@ -223,7 +222,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     return getVariant();
   }
 
-  FORCE_INLINE operator VariantConstRef() const {
+  FORCE_INLINE operator JsonVariantConst() const {
     return getVariant();
   }
 
@@ -250,8 +249,8 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
     return VariantRef(&_pool, &_data);
   }
 
-  VariantConstRef getVariant() const {
+  JsonVariantConst getVariant() const {
-    return VariantConstRef(&_data);
+    return JsonVariantConst(&_data);
   }
 
   MemoryPool _pool;
@@ -280,7 +279,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
 };
 
 inline void convertToJson(const JsonDocument& src, VariantRef dst) {
-  dst.set(src.as<VariantConstRef>());
+  dst.set(src.as<JsonVariantConst>());
 }
 
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Document/StaticJsonDocument.hpp

@@ -24,7 +24,7 @@ class StaticJsonDocument : public JsonDocument {
   template <typename T>
   StaticJsonDocument(
       const T& src,
-      typename enable_if<is_convertible<T, VariantConstRef>::value>::type* = 0)
+      typename enable_if<is_convertible<T, JsonVariantConst>::value>::type* = 0)
       : JsonDocument(_buffer, _capacity) {
     set(src);
   }

src/ArduinoJson/Json/JsonSerializer.hpp

@@ -116,22 +116,22 @@ class JsonSerializer : public Visitor<size_t> {
 };
 
 template <typename TDestination>
-size_t serializeJson(VariantConstRef source, TDestination& destination) {
+size_t serializeJson(JsonVariantConst source, TDestination& destination) {
   return serialize<JsonSerializer>(source, destination);
 }
 
-inline size_t serializeJson(VariantConstRef source, void* buffer,
+inline size_t serializeJson(JsonVariantConst source, void* buffer,
                             size_t bufferSize) {
   return serialize<JsonSerializer>(source, buffer, bufferSize);
 }
 
-inline size_t measureJson(VariantConstRef source) {
+inline size_t measureJson(JsonVariantConst source) {
   return measure<JsonSerializer>(source);
 }
 
 #if ARDUINOJSON_ENABLE_STD_STREAM
 template <typename T>
-inline typename enable_if<is_convertible<T, VariantConstRef>::value,
+inline typename enable_if<is_convertible<T, JsonVariantConst>::value,
                           std::ostream&>::type
 operator<<(std::ostream& os, const T& source) {
   serializeJson(source, os);

src/ArduinoJson/Json/PrettyJsonSerializer.hpp

@@ -71,16 +71,16 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
 };
 
 template <typename TDestination>
-size_t serializeJsonPretty(VariantConstRef source, TDestination& destination) {
+size_t serializeJsonPretty(JsonVariantConst source, TDestination& destination) {
   return serialize<PrettyJsonSerializer>(source, destination);
 }
 
-inline size_t serializeJsonPretty(VariantConstRef source, void* buffer,
+inline size_t serializeJsonPretty(JsonVariantConst source, void* buffer,
                                   size_t bufferSize) {
   return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
 }
 
-inline size_t measureJsonPretty(VariantConstRef source) {
+inline size_t measureJsonPretty(JsonVariantConst source) {
   return measure<PrettyJsonSerializer>(source);
 }
 

src/ArduinoJson/MsgPack/MsgPackSerializer.hpp

@@ -198,16 +198,16 @@ class MsgPackSerializer : public Visitor<size_t> {
 };
 
 template <typename TDestination>
-inline size_t serializeMsgPack(VariantConstRef source, TDestination& output) {
+inline size_t serializeMsgPack(JsonVariantConst source, TDestination& output) {
   return serialize<MsgPackSerializer>(source, output);
 }
 
-inline size_t serializeMsgPack(VariantConstRef source, void* output,
+inline size_t serializeMsgPack(JsonVariantConst source, void* output,
                                size_t size) {
   return serialize<MsgPackSerializer>(source, output, size);
 }
 
-inline size_t measureMsgPack(VariantConstRef source) {
+inline size_t measureMsgPack(JsonVariantConst source) {
   return measure<MsgPackSerializer>(source);
 }
 

src/ArduinoJson/Numbers/parseNumber.hpp

@@ -148,6 +148,6 @@ inline T parseNumber(const char* s) {
   VariantData value;
   value.init();  // VariantData is a POD, so it has no constructor
   parseNumber(s, value);
-  return Converter<T>::fromJson(VariantConstRef(&value));
+  return Converter<T>::fromJson(JsonVariantConst(&value));
 }
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Object/JsonObject.hpp

@@ -30,8 +30,8 @@ class JsonObject : public VariantOperators<JsonObject> {
     return JsonObjectConst(_data);
   }
 
-  operator VariantConstRef() const {
+  operator JsonVariantConst() const {
-    return VariantConstRef(collectionToVariant(_data));
+    return JsonVariantConst(collectionToVariant(_data));
   }
 
   FORCE_INLINE bool isNull() const {
@@ -176,7 +176,7 @@ class JsonObject : public VariantOperators<JsonObject> {
 
 template <>
 struct Converter<JsonObject> : private VariantAttorney {
-  static void toJson(VariantConstRef src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, VariantRef dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
@@ -186,10 +186,10 @@ struct Converter<JsonObject> : private VariantAttorney {
     return JsonObject(pool, data != 0 ? data->asObject() : 0);
   }
 
-  static InvalidConversion<VariantConstRef, JsonObject> fromJson(
+  static InvalidConversion<JsonVariantConst, JsonObject> fromJson(
-      VariantConstRef);
+      JsonVariantConst);
 
-  static bool checkJson(VariantConstRef) {
+  static bool checkJson(JsonVariantConst) {
     return false;
   }
 

src/ArduinoJson/Object/JsonObjectConst.hpp

@@ -19,8 +19,8 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
   JsonObjectConst() : _data(0) {}
   JsonObjectConst(const CollectionData* data) : _data(data) {}
 
-  operator VariantConstRef() const {
+  operator JsonVariantConst() const {
-    return VariantConstRef(collectionToVariant(_data));
+    return JsonVariantConst(collectionToVariant(_data));
   }
 
   FORCE_INLINE bool isNull() const {
@@ -72,9 +72,9 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
   // operator[](const String&) const
   template <typename TString>
   FORCE_INLINE
-      typename enable_if<IsString<TString>::value, VariantConstRef>::type
+      typename enable_if<IsString<TString>::value, JsonVariantConst>::type
       operator[](const TString& key) const {
-    return VariantConstRef(getMember(adaptString(key)));
+    return JsonVariantConst(getMember(adaptString(key)));
   }
 
   // operator[](char*) const
@@ -82,9 +82,9 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
   // operator[](const __FlashStringHelper*) const
   template <typename TChar>
   FORCE_INLINE
-      typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
+      typename enable_if<IsString<TChar*>::value, JsonVariantConst>::type
       operator[](TChar* key) const {
-    return VariantConstRef(getMember(adaptString(key)));
+    return JsonVariantConst(getMember(adaptString(key)));
   }
 
   FORCE_INLINE bool operator==(JsonObjectConst rhs) const {
@@ -120,16 +120,16 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
 
 template <>
 struct Converter<JsonObjectConst> : private VariantAttorney {
-  static void toJson(VariantConstRef src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, VariantRef dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static JsonObjectConst fromJson(VariantConstRef src) {
+  static JsonObjectConst fromJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data != 0 ? data->asObject() : 0;
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isObject();
   }

src/ArduinoJson/Object/JsonPair.hpp

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <ArduinoJson/Strings/JsonString.hpp>
-#include <ArduinoJson/Variant/VariantConstRef.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
 #include <ArduinoJson/Variant/VariantRef.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
@@ -39,7 +39,7 @@ class JsonPairConst {
     if (slot) {
       _key = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
                                                      : JsonString::Linked);
-      _value = VariantConstRef(slot->data());
+      _value = JsonVariantConst(slot->data());
     }
   }
 
@@ -47,12 +47,12 @@ class JsonPairConst {
     return _key;
   }
 
-  VariantConstRef value() const {
+  JsonVariantConst value() const {
     return _value;
   }
 
  private:
   JsonString _key;
-  VariantConstRef _value;
+  JsonVariantConst _value;
 };
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Serialization/measure.hpp

@@ -10,7 +10,7 @@
 namespace ARDUINOJSON_NAMESPACE {
 
 template <template <typename> class TSerializer>
-size_t measure(VariantConstRef source) {
+size_t measure(JsonVariantConst source) {
   DummyWriter dp;
   TSerializer<DummyWriter> serializer(dp);
   return variantAccept(VariantAttorney::getData(source), serializer);

src/ArduinoJson/Serialization/serialize.hpp

@@ -10,27 +10,27 @@
 namespace ARDUINOJSON_NAMESPACE {
 
 template <template <typename> class TSerializer, typename TWriter>
-size_t doSerialize(VariantConstRef source, TWriter writer) {
+size_t doSerialize(JsonVariantConst source, TWriter writer) {
   TSerializer<TWriter> serializer(writer);
   return variantAccept(VariantAttorney::getData(source), serializer);
 }
 
 template <template <typename> class TSerializer, typename TDestination>
-size_t serialize(VariantConstRef source, TDestination& destination) {
+size_t serialize(JsonVariantConst source, TDestination& destination) {
   Writer<TDestination> writer(destination);
   return doSerialize<TSerializer>(source, writer);
 }
 
 template <template <typename> class TSerializer>
 typename enable_if<!TSerializer<StaticStringWriter>::producesText, size_t>::type
-serialize(VariantConstRef source, void* buffer, size_t bufferSize) {
+serialize(JsonVariantConst source, void* buffer, size_t bufferSize) {
   StaticStringWriter writer(reinterpret_cast<char*>(buffer), bufferSize);
   return doSerialize<TSerializer>(source, writer);
 }
 
 template <template <typename> class TSerializer>
 typename enable_if<TSerializer<StaticStringWriter>::producesText, size_t>::type
-serialize(VariantConstRef source, void* buffer, size_t bufferSize) {
+serialize(JsonVariantConst source, void* buffer, size_t bufferSize) {
   StaticStringWriter writer(reinterpret_cast<char*>(buffer), bufferSize);
   size_t n = doSerialize<TSerializer>(source, writer);
   // add null-terminator for text output (not counted in the size)
@@ -45,7 +45,7 @@ typename enable_if<sizeof(remove_reference<TChar>::type) == 1, size_t>::type
 #else
 typename enable_if<sizeof(TChar) == 1, size_t>::type
 #endif
-serialize(VariantConstRef source, TChar (&buffer)[N]) {
+serialize(JsonVariantConst source, TChar (&buffer)[N]) {
   return serialize<TSerializer>(source, buffer, N);
 }
 

src/ArduinoJson/Variant/ConverterImpl.hpp

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <ArduinoJson/Json/JsonSerializer.hpp>
-#include <ArduinoJson/Variant/VariantConstRef.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
 #include <ArduinoJson/Variant/VariantFunctions.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
@@ -18,7 +18,7 @@ struct Converter {
     // clang-format on
   }
 
-  static T fromJson(VariantConstRef src) {
+  static T fromJson(JsonVariantConst src) {
     // clang-format off
     T result; // Error here? See https://arduinojson.org/v6/non-default-constructible/
     convertFromJson(src, result);  // Error here? See https://arduinojson.org/v6/unsupported-as/
@@ -26,7 +26,7 @@ struct Converter {
     return result;
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     T dummy = T();
     // clang-format off
     return canConvertFromJson(src, dummy);  // Error here? See https://arduinojson.org/v6/unsupported-is/
@@ -46,13 +46,13 @@ struct Converter<
       data->setInteger(src);
   }
 
-  static T fromJson(VariantConstRef src) {
+  static T fromJson(JsonVariantConst src) {
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
     const VariantData* data = getData(src);
     return data ? data->asIntegral<T>() : T();
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isInteger<T>();
   }
@@ -65,12 +65,12 @@ struct Converter<T, typename enable_if<is_enum<T>::value>::type>
     dst.set(static_cast<JsonInteger>(src));
   }
 
-  static T fromJson(VariantConstRef src) {
+  static T fromJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data ? static_cast<T>(data->asIntegral<int>()) : T();
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isInteger<int>();
   }
@@ -84,12 +84,12 @@ struct Converter<bool> : private VariantAttorney {
       data->setBoolean(src);
   }
 
-  static bool fromJson(VariantConstRef src) {
+  static bool fromJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data ? data->asBoolean() : false;
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isBoolean();
   }
@@ -104,12 +104,12 @@ struct Converter<T, typename enable_if<is_floating_point<T>::value>::type>
       data->setFloat(static_cast<JsonFloat>(src));
   }
 
-  static T fromJson(VariantConstRef src) {
+  static T fromJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data ? data->asFloat<T>() : 0;
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isFloat();
   }
@@ -121,12 +121,12 @@ struct Converter<const char*> : private VariantAttorney {
     variantSetString(getData(dst), adaptString(src), getPool(dst));
   }
 
-  static const char* fromJson(VariantConstRef src) {
+  static const char* fromJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data ? data->asString().c_str() : 0;
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isString();
   }
@@ -138,12 +138,12 @@ struct Converter<JsonString> : private VariantAttorney {
     variantSetString(getData(dst), adaptString(src), getPool(dst));
   }
 
-  static JsonString fromJson(VariantConstRef src) {
+  static JsonString fromJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data ? data->asString() : 0;
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data && data->isString();
   }
@@ -188,10 +188,10 @@ struct Converter<decltype(nullptr)> : private VariantAttorney {
   static void toJson(decltype(nullptr), VariantRef dst) {
     variantSetNull(getData(dst));
   }
-  static decltype(nullptr) fromJson(VariantConstRef) {
+  static decltype(nullptr) fromJson(JsonVariantConst) {
     return nullptr;
   }
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return data == 0 || data->isNull();
   }
@@ -261,7 +261,7 @@ inline void convertToJson(const ::Printable& src, VariantRef dst) {
 
 #if ARDUINOJSON_ENABLE_ARDUINO_STRING
 
-inline void convertFromJson(VariantConstRef src, ::String& dst) {
+inline void convertFromJson(JsonVariantConst src, ::String& dst) {
   JsonString str = src.as<JsonString>();
   if (str)
     dst = str.c_str();
@@ -269,7 +269,7 @@ inline void convertFromJson(VariantConstRef src, ::String& dst) {
     serializeJson(src, dst);
 }
 
-inline bool canConvertFromJson(VariantConstRef src, const ::String&) {
+inline bool canConvertFromJson(JsonVariantConst src, const ::String&) {
   return src.is<JsonString>();
 }
 
@@ -277,7 +277,7 @@ inline bool canConvertFromJson(VariantConstRef src, const ::String&) {
 
 #if ARDUINOJSON_ENABLE_STD_STRING
 
-inline void convertFromJson(VariantConstRef src, std::string& dst) {
+inline void convertFromJson(JsonVariantConst src, std::string& dst) {
   JsonString str = src.as<JsonString>();
   if (str)
     dst.assign(str.c_str(), str.size());
@@ -285,7 +285,7 @@ inline void convertFromJson(VariantConstRef src, std::string& dst) {
     serializeJson(src, dst);
 }
 
-inline bool canConvertFromJson(VariantConstRef src, const std::string&) {
+inline bool canConvertFromJson(JsonVariantConst src, const std::string&) {
   return src.is<JsonString>();
 }
 
@@ -293,13 +293,13 @@ inline bool canConvertFromJson(VariantConstRef src, const std::string&) {
 
 #if ARDUINOJSON_ENABLE_STRING_VIEW
 
-inline void convertFromJson(VariantConstRef src, std::string_view& dst) {
+inline void convertFromJson(JsonVariantConst src, std::string_view& dst) {
   JsonString str = src.as<JsonString>();
   if (str)  // the standard doesn't allow passing null to the constructor
     dst = std::string_view(str.c_str(), str.size());
 }
 
-inline bool canConvertFromJson(VariantConstRef src, const std::string_view&) {
+inline bool canConvertFromJson(JsonVariantConst src, const std::string_view&) {
   return src.is<JsonString>();
 }
 
@@ -309,7 +309,7 @@ template <typename T>
 struct ConverterNeedsWriteableRef {
  protected:  // <- to avoid GCC's "all member functions in class are private"
   static int probe(T (*f)(VariantRef));
-  static char probe(T (*f)(VariantConstRef));
+  static char probe(T (*f)(JsonVariantConst));
 
  public:
   static const bool value =

src/ArduinoJson/Variant/JsonVariantConst.hpp

@@ -22,13 +22,13 @@ namespace ARDUINOJSON_NAMESPACE {
 class JsonArray;
 class JsonObject;
 
-class VariantConstRef : public VariantTag,
+class JsonVariantConst : public VariantTag,
-                        public VariantOperators<VariantConstRef> {
+                         public VariantOperators<JsonVariantConst> {
   friend class VariantAttorney;
 
  public:
-  VariantConstRef() : _data(0) {}
+  JsonVariantConst() : _data(0) {}
-  explicit VariantConstRef(const VariantData* data) : _data(data) {}
+  explicit JsonVariantConst(const VariantData* data) : _data(data) {}
 
   FORCE_INLINE bool isNull() const {
     return variantIsNull(_data);
@@ -101,17 +101,17 @@ class VariantConstRef : public VariantTag,
     return as<T>();
   }
 
-  FORCE_INLINE VariantConstRef operator[](size_t index) const {
+  FORCE_INLINE JsonVariantConst operator[](size_t index) const {
-    return VariantConstRef(variantGetElement(_data, index));
+    return JsonVariantConst(variantGetElement(_data, index));
   }
 
   // operator[](const std::string&) const
   // operator[](const String&) const
   template <typename TString>
   FORCE_INLINE
-      typename enable_if<IsString<TString>::value, VariantConstRef>::type
+      typename enable_if<IsString<TString>::value, JsonVariantConst>::type
       operator[](const TString& key) const {
-    return VariantConstRef(variantGetMember(_data, adaptString(key)));
+    return JsonVariantConst(variantGetMember(_data, adaptString(key)));
   }
 
   // operator[](char*) const
@@ -119,9 +119,9 @@ class VariantConstRef : public VariantTag,
   // operator[](const __FlashStringHelper*) const
   template <typename TChar>
   FORCE_INLINE
-      typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
+      typename enable_if<IsString<TChar*>::value, JsonVariantConst>::type
       operator[](TChar* key) const {
-    return VariantConstRef(variantGetMember(_data, adaptString(key)));
+    return JsonVariantConst(variantGetMember(_data, adaptString(key)));
   }
 
   // containsKey(const std::string&) const

src/ArduinoJson/Variant/VariantAttorney.hpp

@@ -7,7 +7,7 @@
 #include <ArduinoJson/Polyfills/attributes.hpp>
 #include <ArduinoJson/Polyfills/type_traits.hpp>
 #include <ArduinoJson/Variant/VariantTo.hpp>
-#include "VariantConstRef.hpp"
+#include "JsonVariantConst.hpp"
 
 namespace ARDUINOJSON_NAMESPACE {
 

src/ArduinoJson/Variant/VariantCompare.hpp

@@ -194,14 +194,14 @@ struct VariantComparer : ComparerBase {
 
 template <typename T>
 struct Comparer<
-    T, typename enable_if<is_convertible<T, VariantConstRef>::value>::type>
+    T, typename enable_if<is_convertible<T, JsonVariantConst>::value>::type>
     : VariantComparer {
   explicit Comparer(const T& value)
       : VariantComparer(VariantAttorney::getData(value)) {}
 };
 
 template <typename T>
-CompareResult compare(VariantConstRef lhs, const T& rhs) {
+CompareResult compare(JsonVariantConst lhs, const T& rhs) {
   Comparer<T> comparer(rhs);
   return variantAccept(VariantAttorney::getData(lhs), comparer);
 }

src/ArduinoJson/Variant/VariantImpl.hpp

@@ -149,7 +149,7 @@ inline bool VariantRefBase<TDerived>::set(char value) const {
 
 template <typename TDerived>
 inline void convertToJson(const VariantRefBase<TDerived>& src, VariantRef dst) {
-  dst.set(src.template as<VariantConstRef>());
+  dst.set(src.template as<JsonVariantConst>());
 }
 
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Variant/VariantOperators.hpp

@@ -11,10 +11,10 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-class VariantConstRef;
+class JsonVariantConst;
 
 template <typename T>
-CompareResult compare(VariantConstRef lhs,
+CompareResult compare(JsonVariantConst lhs,
                       const T& rhs);  // VariantCompare.cpp
 
 struct VariantOperatorTag {};
@@ -47,7 +47,7 @@ struct VariantOperators : VariantOperatorTag {
   //
   // JsonVariant operator|(JsonVariant, JsonVariant)
   template <typename T>
-  friend typename enable_if<IsVariant<T>::value, VariantConstRef>::type
+  friend typename enable_if<IsVariant<T>::value, JsonVariantConst>::type
   operator|(const TVariant& variant, T defaultValue) {
     if (variant)
       return variant;

src/ArduinoJson/Variant/VariantRef.hpp

@@ -44,30 +44,30 @@ struct Converter<VariantRef> : private VariantAttorney {
     return src;
   }
 
-  static InvalidConversion<VariantConstRef, VariantRef> fromJson(
+  static InvalidConversion<JsonVariantConst, VariantRef> fromJson(
-      VariantConstRef);
+      JsonVariantConst);
 
   static bool checkJson(VariantRef src) {
     VariantData* data = getData(src);
     return !!data;
   }
 
-  static bool checkJson(VariantConstRef) {
+  static bool checkJson(JsonVariantConst) {
     return false;
   }
 };
 
 template <>
-struct Converter<VariantConstRef> : private VariantAttorney {
+struct Converter<JsonVariantConst> : private VariantAttorney {
-  static void toJson(VariantConstRef src, VariantRef dst) {
+  static void toJson(JsonVariantConst src, VariantRef dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static VariantConstRef fromJson(VariantConstRef src) {
+  static JsonVariantConst fromJson(JsonVariantConst src) {
-    return VariantConstRef(getData(src));
+    return JsonVariantConst(getData(src));
   }
 
-  static bool checkJson(VariantConstRef src) {
+  static bool checkJson(JsonVariantConst src) {
     const VariantData* data = getData(src);
     return !!data;
   }

src/ArduinoJson/Variant/VariantRefBase.hpp

@@ -6,7 +6,7 @@
 
 #include <ArduinoJson/Configuration.hpp>
 #include <ArduinoJson/Variant/Converter.hpp>
-#include <ArduinoJson/Variant/VariantConstRef.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
 #include <ArduinoJson/Variant/VariantOperators.hpp>
 #include <ArduinoJson/Variant/VariantTo.hpp>
 
@@ -119,7 +119,7 @@ class VariantRefBase : public VariantTag {
     return is<signed char>();
   }
 
-  FORCE_INLINE void shallowCopy(VariantConstRef target) {
+  FORCE_INLINE void shallowCopy(JsonVariantConst target) {
     VariantData* data = getOrCreateData();
     if (!data)
       return;
@@ -258,8 +258,8 @@ class VariantRefBase : public VariantTag {
  private:
   FORCE_INLINE VariantRef getVariant() const;
 
-  FORCE_INLINE VariantConstRef getVariantConst() const {
+  FORCE_INLINE JsonVariantConst getVariantConst() const {
-    return VariantConstRef(getData());
+    return JsonVariantConst(getData());
   }
 
   FORCE_INLINE VariantRef getOrCreateVariant() const;