Extract VariantRefBase from VariantProxy

src/ArduinoJson.hpp

@@ -23,7 +23,7 @@
 
 #include "ArduinoJson/Array/ArrayRef.hpp"
 #include "ArduinoJson/Object/ObjectRef.hpp"
-#include "ArduinoJson/Variant/VariantRef.hpp"
+#include "ArduinoJson/Variant/VariantConstRef.hpp"
 
 #include "ArduinoJson/Document/DynamicJsonDocument.hpp"
 #include "ArduinoJson/Document/StaticJsonDocument.hpp"

src/ArduinoJson/Deserialization/Readers/VariantReader.hpp

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

src/ArduinoJson/Document/JsonDocument.hpp

@@ -9,7 +9,7 @@
 #include <ArduinoJson/Object/MemberProxy.hpp>
 #include <ArduinoJson/Object/ObjectRef.hpp>
 #include <ArduinoJson/Strings/StoragePolicy.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
+#include <ArduinoJson/Variant/VariantConstRef.hpp>
 #include <ArduinoJson/Variant/VariantTo.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {

src/ArduinoJson/Object/Pair.hpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <ArduinoJson/Strings/String.hpp>
+#include <ArduinoJson/Variant/VariantConstRef.hpp>
 #include <ArduinoJson/Variant/VariantRef.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {

src/ArduinoJson/Variant/ConverterImpl.hpp

@@ -5,8 +5,8 @@
 #pragma once
 
 #include <ArduinoJson/Json/JsonSerializer.hpp>
+#include <ArduinoJson/Variant/VariantConstRef.hpp>
 #include <ArduinoJson/Variant/VariantFunctions.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 

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 "VariantRef.hpp"
+#include "VariantConstRef.hpp"
 
 namespace ARDUINOJSON_NAMESPACE {
 

src/ArduinoJson/Variant/VariantConstRef.hpp

@@ -0,0 +1,138 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>  // for uint8_t
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/VariantAttorney.hpp>
+#include <ArduinoJson/Variant/VariantConstRef.hpp>
+#include <ArduinoJson/Variant/VariantFunctions.hpp>
+#include <ArduinoJson/Variant/VariantOperators.hpp>
+#include <ArduinoJson/Variant/VariantShortcuts.hpp>
+#include <ArduinoJson/Variant/VariantTag.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// Forward declarations.
+class ArrayRef;
+class ObjectRef;
+
+class VariantConstRef : public VariantTag,
+                        public VariantOperators<VariantConstRef>,
+                        public VariantShortcuts<VariantConstRef> {
+  friend class VariantAttorney;
+
+ public:
+  VariantConstRef() : _data(0) {}
+  explicit VariantConstRef(const VariantData* data) : _data(data) {}
+
+  FORCE_INLINE bool isNull() const {
+    return variantIsNull(_data);
+  }
+
+  FORCE_INLINE bool isUnbound() const {
+    return !_data;
+  }
+
+  FORCE_INLINE size_t memoryUsage() const {
+    return _data ? _data->memoryUsage() : 0;
+  }
+
+  FORCE_INLINE size_t nesting() const {
+    return variantNesting(_data);
+  }
+
+  size_t size() const {
+    return variantSize(_data);
+  }
+
+  template <typename T>
+  FORCE_INLINE
+      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
+                         T>::type
+      as() const {
+    return Converter<T>::fromJson(*this);
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
+  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
+      as() const {
+    return as<const char*>();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type
+  ARDUINOJSON_DEPRECATED(
+      "Support for char is deprecated, use int8_t or uint8_t instead")
+      as() const {
+    return static_cast<char>(as<signed char>());
+  }
+
+  template <typename T>
+  FORCE_INLINE
+      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
+                         bool>::type
+      is() const {
+    return Converter<T>::checkJson(*this);
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
+  ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
+      is() const {
+    return is<const char*>();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type
+  ARDUINOJSON_DEPRECATED(
+      "Support for char is deprecated, use int8_t or uint8_t instead")
+      is() const {
+    return is<signed char>();
+  }
+
+  template <typename T>
+  FORCE_INLINE operator T() const {
+    return as<T>();
+  }
+
+  FORCE_INLINE VariantConstRef operator[](size_t index) const {
+    return VariantConstRef(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
+      operator[](const TString& key) const {
+    return VariantConstRef(variantGetMember(_data, adaptString(key)));
+  }
+
+  // operator[](char*) const
+  // operator[](const char*) const
+  // operator[](const __FlashStringHelper*) const
+  template <typename TChar>
+  FORCE_INLINE
+      typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
+      operator[](TChar* key) const {
+    return VariantConstRef(variantGetMember(_data, adaptString(key)));
+  }
+
+ protected:
+  const VariantData* getData() const {
+    return _data;
+  }
+
+ private:
+  const VariantData* _data;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Variant/VariantImpl.hpp

@@ -105,30 +105,55 @@ inline bool VariantData::copyFrom(const VariantData& src, MemoryPool* pool) {
   }
 }
 
+template <typename TSource>
+inline VariantRef VariantRefBase<TSource>::add() const {
+  return VariantRef(getPool(), variantAddElement(getOrCreateData(), getPool()));
+}
+
+template <typename TSource>
+inline VariantRef VariantRefBase<TSource>::getVariant() const {
+  return VariantRef(getPool(), getData());
+}
+
+template <typename TSource>
+inline VariantRef VariantRefBase<TSource>::getOrCreateVariant() const {
+  return VariantRef(getPool(), getOrCreateData());
+}
+
+template <typename TSource>
 template <typename T>
 inline typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type
-VariantRef::to() const {
-  return ArrayRef(_pool, variantToArray(_data));
+VariantRefBase<TSource>::to() const {
+  return ArrayRef(getPool(), variantToArray(getOrCreateData()));
 }
 
+template <typename TSource>
 template <typename T>
 typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type
-VariantRef::to() const {
-  return ObjectRef(_pool, variantToObject(_data));
+VariantRefBase<TSource>::to() const {
+  return ObjectRef(getPool(), variantToObject(getOrCreateData()));
 }
 
+template <typename TSource>
 template <typename T>
 typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type
-VariantRef::to() const {
-  variantSetNull(_data);
+VariantRefBase<TSource>::to() const {
+  variantSetNull(getOrCreateData());
   return *this;
 }
 
 // Out of class definition to avoid #1560
-inline bool VariantRef::set(char value) const {
+template <typename TSource>
+inline bool VariantRefBase<TSource>::set(char value) const {
   return set(static_cast<signed char>(value));
 }
 
+template <typename TDataSource>
+inline void convertToJson(const VariantRefBase<TDataSource>& src,
+                          VariantRef dst) {
+  dst.set(src.template as<VariantConstRef>());
+}
+
 // TODO: move somewhere else
 template <typename TAdaptedString, typename TCallback>
 bool CopyStringStoragePolicy::store(TAdaptedString str, MemoryPool* pool,

src/ArduinoJson/Variant/VariantProxy.hpp

@@ -4,10 +4,8 @@
 
 #pragma once
 
-#include <ArduinoJson/Configuration.hpp>
 #include <ArduinoJson/Variant/VariantOperators.hpp>
-#include <ArduinoJson/Variant/VariantShortcuts.hpp>
-#include <ArduinoJson/Variant/VariantTo.hpp>
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
 
 #ifdef _MSC_VER
 #  pragma warning(push)
@@ -17,165 +15,33 @@
 namespace ARDUINOJSON_NAMESPACE {
 
 template <typename TDataSource>
-class VariantProxy : public VariantShortcuts<VariantProxy<TDataSource> >,
-                     public VariantOperators<VariantProxy<TDataSource> >,
-                     public VariantTag {
-  friend class VariantAttorney;
-
+class VariantProxy : public VariantRefBase<TDataSource>,
+                     public VariantOperators<VariantProxy<TDataSource> > {
  public:
-  explicit FORCE_INLINE VariantProxy(TDataSource source) : _source(source) {}
+  explicit FORCE_INLINE VariantProxy(TDataSource source)
+      : VariantRefBase<TDataSource>(source) {}
 
-  // Copy-constructor required because of user-defined copy-assignment operator
-  FORCE_INLINE VariantProxy(const VariantProxy& src) : _source(src._source) {}
+  // Copy-constructor required because of user-defined copy-assignment
+  // operator
+  FORCE_INLINE VariantProxy(const VariantProxy& src)
+      : VariantRefBase<TDataSource>(src) {}
 
   FORCE_INLINE VariantProxy& operator=(const VariantProxy& src) {
-    getOrAddUpstreamVariant().set(src);
+    this->set(src);
     return *this;
   }
 
   template <typename T>
   FORCE_INLINE VariantProxy& operator=(const T& src) {
-    getOrAddUpstreamVariant().set(src);
+    this->set(src);
     return *this;
   }
 
   template <typename T>
   FORCE_INLINE VariantProxy& operator=(T* src) {
-    getOrAddUpstreamVariant().set(src);
+    this->set(src);
     return *this;
   }
-
-  FORCE_INLINE void clear() const {
-    getUpstreamVariant().clear();
-  }
-
-  FORCE_INLINE bool isNull() const {
-    return getUpstreamVariantConst().isNull();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<!is_same<T, char*>::value &&
-                                      !ConverterNeedsWriteableRef<T>::value,
-                                  T>::type
-  as() const {
-    return getUpstreamVariantConst().template as<T>();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<ConverterNeedsWriteableRef<T>::value, T>::type
-  as() const {
-    return getUpstreamVariant().template as<T>();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
-  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
-      as() const {
-    return as<const char*>();
-  }
-
-  template <typename T>
-  FORCE_INLINE operator T() const {
-    return as<T>();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename VariantTo<T>::type to() {
-    return getOrAddUpstreamVariant().template to<T>();
-  }
-
-  template <typename T>
-  FORCE_INLINE
-      typename enable_if<ConverterNeedsWriteableRef<T>::value, bool>::type
-      is() const {
-    return getUpstreamVariant().template is<T>();
-  }
-
-  template <typename T>
-  FORCE_INLINE
-      typename enable_if<!ConverterNeedsWriteableRef<T>::value, bool>::type
-      is() const {
-    return getUpstreamVariantConst().template is<T>();
-  }
-
-  FORCE_INLINE void shallowCopy(VariantConstRef value) {
-    getOrAddUpstreamVariant().shallowCopy(value);
-  }
-
-  template <typename T>
-  FORCE_INLINE bool set(const T& value) {
-    return getOrAddUpstreamVariant().set(value);
-  }
-
-  template <typename T>
-  FORCE_INLINE bool set(T* value) {
-    return getOrAddUpstreamVariant().set(value);
-  }
-
-  FORCE_INLINE size_t size() const {
-    return getUpstreamVariantConst().size();
-  }
-
-  FORCE_INLINE size_t memoryUsage() const {
-    return getUpstreamVariantConst().memoryUsage();
-  }
-
-  FORCE_INLINE VariantRef add() const {
-    return getOrAddUpstreamVariant().add();
-  }
-
-  using ArrayShortcuts<VariantProxy<TDataSource> >::add;
-
-  FORCE_INLINE void remove(size_t index) const {
-    getUpstreamVariant().remove(index);
-  }
-  // remove(char*) const
-  // remove(const char*) const
-  // remove(const __FlashStringHelper*) const
-  template <typename TChar>
-  FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
-      TChar* key) const {
-    getUpstreamVariant().remove(key);
-  }
-  // remove(const std::string&) const
-  // remove(const String&) const
-  template <typename TString>
-  FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
-      const TString& key) const {
-    getUpstreamVariant().remove(key);
-  }
-
- protected:
-  FORCE_INLINE MemoryPool* getPool() const {
-    return _source.getPool();
-  }
-
-  FORCE_INLINE VariantData* getData() const {
-    return _source.getData();
-  }
-
-  FORCE_INLINE VariantData* getOrCreateData() const {
-    return _source.getOrCreateData();
-  }
-
- private:
-  FORCE_INLINE VariantRef getUpstreamVariant() const {
-    return VariantRef(getPool(), getData());
-  }
-
-  FORCE_INLINE VariantConstRef getUpstreamVariantConst() const {
-    return VariantConstRef(getData());
-  }
-
-  FORCE_INLINE VariantRef getOrAddUpstreamVariant() const {
-    return VariantRef(getPool(), getOrCreateData());
-  }
-
-  friend void convertToJson(const VariantProxy& src, VariantRef dst) {
-    dst.set(src.getUpstreamVariantConst());
-  }
-
-  const TDataSource _source;
 };
 
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Variant/VariantRef.hpp

@@ -4,310 +4,43 @@
 
 #pragma once
 
-#include <stddef.h>
-#include <stdint.h>  // for uint8_t
-
-#include <ArduinoJson/Memory/MemoryPool.hpp>
-#include <ArduinoJson/Polyfills/type_traits.hpp>
-#include <ArduinoJson/Strings/StringAdapters.hpp>
-#include <ArduinoJson/Variant/Converter.hpp>
-#include <ArduinoJson/Variant/VariantAttorney.hpp>
-#include <ArduinoJson/Variant/VariantFunctions.hpp>
-#include <ArduinoJson/Variant/VariantOperators.hpp>
-#include <ArduinoJson/Variant/VariantRef.hpp>
-#include <ArduinoJson/Variant/VariantShortcuts.hpp>
-#include <ArduinoJson/Variant/VariantTag.hpp>
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 
-// Forward declarations.
-class ArrayRef;
-class ObjectRef;
-
-// Contains the methods shared by VariantRef and VariantConstRef
-template <typename TData>
-class VariantRefBase : public VariantTag {
+class VariantDataSource {
  public:
-  FORCE_INLINE bool isNull() const {
-    return variantIsNull(_data);
-  }
+  VariantDataSource() : _data(0), _pool(0) {}
 
-  FORCE_INLINE bool isUnbound() const {
-    return !_data;
-  }
+  VariantDataSource(MemoryPool* pool, VariantData* data)
+      : _data(data), _pool(pool) {}
 
-  FORCE_INLINE size_t memoryUsage() const {
-    return _data ? _data->memoryUsage() : 0;
-  }
-
-  FORCE_INLINE size_t nesting() const {
-    return variantNesting(_data);
-  }
-
-  size_t size() const {
-    return variantSize(_data);
-  }
-
- protected:
-  VariantRefBase(TData* data) : _data(data) {}
-  TData* _data;
-};
-
-class VariantConstRef : public VariantRefBase<const VariantData>,
-                        public VariantOperators<VariantConstRef>,
-                        public VariantShortcuts<VariantConstRef> {
-  typedef VariantRefBase<const VariantData> base_type;
-
-  friend class VariantAttorney;
-
- public:
-  VariantConstRef() : base_type(0) {}
-  explicit VariantConstRef(const VariantData* data) : base_type(data) {}
-
-  template <typename T>
-  FORCE_INLINE
-      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
-                         T>::type
-      as() const {
-    return Converter<T>::fromJson(*this);
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
-  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
-      as() const {
-    return as<const char*>();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type
-  ARDUINOJSON_DEPRECATED(
-      "Support for char is deprecated, use int8_t or uint8_t instead")
-      as() const {
-    return static_cast<char>(as<signed char>());
-  }
-
-  template <typename T>
-  FORCE_INLINE
-      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
-                         bool>::type
-      is() const {
-    return Converter<T>::checkJson(*this);
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
-  ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
-      is() const {
-    return is<const char*>();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type
-  ARDUINOJSON_DEPRECATED(
-      "Support for char is deprecated, use int8_t or uint8_t instead")
-      is() const {
-    return is<signed char>();
-  }
-
-  template <typename T>
-  FORCE_INLINE operator T() const {
-    return as<T>();
-  }
-
-  FORCE_INLINE VariantConstRef operator[](size_t index) const {
-    return VariantConstRef(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
-      operator[](const TString& key) const {
-    return VariantConstRef(variantGetMember(_data, adaptString(key)));
-  }
-
-  // operator[](char*) const
-  // operator[](const char*) const
-  // operator[](const __FlashStringHelper*) const
-  template <typename TChar>
-  FORCE_INLINE
-      typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
-      operator[](TChar* key) const {
-    return VariantConstRef(variantGetMember(_data, adaptString(key)));
-  }
-
- protected:
-  const VariantData* getData() const {
-    return _data;
-  }
-};
-
-// A variant that can be a any value serializable to a JSON value.
-//
-// It can be set to:
-// - a boolean
-// - a char, short, int or a long (signed or unsigned)
-// - a string (const char*)
-// - a reference to a ArrayRef or ObjectRef
-class VariantRef : public VariantRefBase<VariantData>,
-                   public VariantOperators<VariantRef>,
-                   public VariantShortcuts<VariantRef> {
-  typedef VariantRefBase<VariantData> base_type;
-
- public:
-  // Intenal use only
-  FORCE_INLINE VariantRef(MemoryPool* pool, VariantData* data)
-      : base_type(data), _pool(pool) {}
-
-  // Creates an uninitialized VariantRef
-  FORCE_INLINE VariantRef() : base_type(0), _pool(0) {}
-
-  FORCE_INLINE void clear() const {
-    return variantSetNull(_data);
-  }
-
-  template <typename T>
-  FORCE_INLINE bool set(const T& value) const {
-    Converter<T>::toJson(value, *this);
-    return _pool && !_pool->overflowed();
-  }
-
-  bool ARDUINOJSON_DEPRECATED(
-      "Support for char is deprecated, use int8_t or uint8_t instead")
-      set(char value) const;
-
-  template <typename T>
-  FORCE_INLINE bool set(T* value) const {
-    Converter<T*>::toJson(value, *this);
-    return _pool && !_pool->overflowed();
-  }
-
-  template <typename T>
-  FORCE_INLINE
-      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
-                         T>::type
-      as() const {
-    return Converter<T>::fromJson(*this);
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
-  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
-      as() const {
-    return as<const char*>();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type
-  ARDUINOJSON_DEPRECATED(
-      "Support for char is deprecated, use int8_t or uint8_t instead")
-      as() const {
-    return static_cast<char>(as<signed char>());
-  }
-
-  template <typename T>
-  FORCE_INLINE
-      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
-                         bool>::type
-      is() const {
-    return Converter<T>::checkJson(*this);
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
-  ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
-      is() const {
-    return is<const char*>();
-  }
-
-  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type
-  ARDUINOJSON_DEPRECATED(
-      "Support for char is deprecated, use int8_t or uint8_t instead")
-      is() const {
-    return is<signed char>();
-  }
-
-  template <typename T>
-  FORCE_INLINE operator T() const {
-    return as<T>();
-  }
-
-  FORCE_INLINE operator VariantConstRef() const {
-    return VariantConstRef(_data);
-  }
-
-  // Change the type of the variant
-  //
-  // ArrayRef to<ArrayRef>()
-  template <typename T>
-  typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type to() const;
-  //
-  // ObjectRef to<ObjectRef>()
-  template <typename T>
-  typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type to() const;
-  //
-  // ObjectRef to<VariantRef>()
-  template <typename T>
-  typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type to()
-      const;
-
-  VariantRef add() const {
-    return VariantRef(_pool, variantAddElement(_data, _pool));
-  }
-
-  using ArrayShortcuts<VariantRef>::add;
-
-  FORCE_INLINE void remove(size_t index) const {
-    if (_data)
-      _data->remove(index);
-  }
-  // remove(char*) const
-  // remove(const char*) const
-  // remove(const __FlashStringHelper*) const
-  template <typename TChar>
-  FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
-      TChar* key) const {
-    if (_data)
-      _data->remove(adaptString(key));
-  }
-  // remove(const std::string&) const
-  // remove(const String&) const
-  template <typename TString>
-  FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
-      const TString& key) const {
-    if (_data)
-      _data->remove(adaptString(key));
-  }
-
-  inline void shallowCopy(VariantConstRef target) {
-    if (!_data)
-      return;
-    const VariantData* targetData = VariantAttorney::getData(target);
-    if (targetData)
-      *_data = *targetData;
-    else
-      _data->setNull();
-  }
-
-  MemoryPool* getPool() const {
+  FORCE_INLINE MemoryPool* getPool() const {
     return _pool;
   }
 
-  VariantData* getData() const {
+  FORCE_INLINE VariantData* getData() const {
     return _data;
   }
 
-  VariantData* getOrCreateData() const {
+  FORCE_INLINE VariantData* getOrCreateData() const {
     return _data;
   }
 
  private:
+  VariantData* _data;
   MemoryPool* _pool;
 };
 
+class VariantRef : public VariantRefBase<VariantDataSource>,
+                   public VariantOperators<VariantRef> {
+ public:
+  VariantRef() : VariantRefBase<VariantDataSource>(VariantDataSource()) {}
+
+  VariantRef(MemoryPool* pool, VariantData* data)
+      : VariantRefBase<VariantDataSource>(VariantDataSource(pool, data)) {}
+};
+
 template <>
 struct Converter<VariantRef> : private VariantAttorney {
   static void toJson(VariantRef src, VariantRef dst) {

src/ArduinoJson/Variant/VariantRefBase.hpp

@@ -0,0 +1,215 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Variant/Converter.hpp>
+#include <ArduinoJson/Variant/VariantConstRef.hpp>
+#include <ArduinoJson/Variant/VariantOperators.hpp>
+#include <ArduinoJson/Variant/VariantShortcuts.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class VariantRef;
+
+template <typename TDataSource>
+class VariantRefBase : public VariantShortcuts<VariantRefBase<TDataSource> >,
+                       public VariantTag {
+  friend class VariantAttorney;
+
+ public:
+  explicit FORCE_INLINE VariantRefBase(TDataSource source) : _source(source) {}
+
+  FORCE_INLINE void clear() const {
+    variantSetNull(getData());
+  }
+
+  FORCE_INLINE bool isNull() const {
+    return variantIsNull(getData());
+  }
+
+  FORCE_INLINE bool isUnbound() const {
+    return !getData();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<!is_same<T, char*>::value &&
+                                      !is_same<T, char>::value &&
+                                      !ConverterNeedsWriteableRef<T>::value,
+                                  T>::type
+  as() const {
+    return Converter<T>::fromJson(getVariantConst());
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<ConverterNeedsWriteableRef<T>::value, T>::type
+  as() const {
+    return Converter<T>::fromJson(getVariant());
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
+  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
+      as() const {
+    return as<const char*>();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type
+  ARDUINOJSON_DEPRECATED(
+      "Support for char is deprecated, use int8_t or uint8_t instead")
+      as() const {
+    return static_cast<char>(as<signed char>());
+  }
+
+  template <typename T>
+  FORCE_INLINE operator T() const {
+    return as<T>();
+  }
+
+  // Change the type of the variant
+  //
+  // ArrayRef to<ArrayRef>()
+  template <typename T>
+  typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type to() const;
+  //
+  // ObjectRef to<ObjectRef>()
+  template <typename T>
+  typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type to() const;
+  //
+  // VariantRef to<VariantRef>()
+  template <typename T>
+  typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type to()
+      const;
+
+  template <typename T>
+  FORCE_INLINE
+      typename enable_if<ConverterNeedsWriteableRef<T>::value, bool>::type
+      is() const {
+    return Converter<T>::checkJson(getVariant());
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<!ConverterNeedsWriteableRef<T>::value &&
+                                      !is_same<T, char*>::value &&
+                                      !is_same<T, char>::value,
+                                  bool>::type
+  is() const {
+    return Converter<T>::checkJson(getVariantConst());
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
+  ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
+      is() const {
+    return is<const char*>();
+  }
+
+  template <typename T>
+  FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type
+  ARDUINOJSON_DEPRECATED(
+      "Support for char is deprecated, use int8_t or uint8_t instead")
+      is() const {
+    return is<signed char>();
+  }
+
+  FORCE_INLINE void shallowCopy(VariantConstRef target) {
+    VariantData* data = getOrCreateData();
+    if (!data)
+      return;
+    const VariantData* targetData = VariantAttorney::getData(target);
+    if (targetData)
+      *data = *targetData;
+    else
+      data->setNull();
+  }
+
+  template <typename T>
+  FORCE_INLINE bool set(const T& value) const {
+    Converter<T>::toJson(value, getOrCreateVariant());
+    MemoryPool* pool = getPool();
+    return pool && !pool->overflowed();
+  }
+
+  template <typename T>
+  FORCE_INLINE bool set(T* value) const {
+    Converter<T*>::toJson(value, getOrCreateVariant());
+    MemoryPool* pool = getPool();
+    return pool && !pool->overflowed();
+  }
+
+  bool ARDUINOJSON_DEPRECATED(
+      "Support for char is deprecated, use int8_t or uint8_t instead")
+      set(char value) const;
+
+  FORCE_INLINE size_t size() const {
+    return variantSize(getData());
+  }
+
+  FORCE_INLINE size_t memoryUsage() const {
+    VariantData* data = getData();
+    return data ? data->memoryUsage() : 0;
+  }
+
+  FORCE_INLINE size_t nesting() const {
+    return variantNesting(getData());
+  }
+
+  FORCE_INLINE VariantRef add() const;
+
+  using ArrayShortcuts<VariantRefBase<TDataSource> >::add;
+
+  FORCE_INLINE void remove(size_t index) const {
+    VariantData* data = getData();
+    if (data)
+      data->remove(index);
+  }
+  // remove(char*) const
+  // remove(const char*) const
+  // remove(const __FlashStringHelper*) const
+  template <typename TChar>
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
+      TChar* key) const {
+    VariantData* data = getData();
+    if (data)
+      data->remove(adaptString(key));
+  }
+  // remove(const std::string&) const
+  // remove(const String&) const
+  template <typename TString>
+  FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
+      const TString& key) const {
+    VariantData* data = getData();
+    if (data)
+      data->remove(adaptString(key));
+  }
+
+ protected:
+  FORCE_INLINE MemoryPool* getPool() const {
+    return _source.getPool();
+  }
+
+  FORCE_INLINE VariantData* getData() const {
+    return _source.getData();
+  }
+
+  FORCE_INLINE VariantData* getOrCreateData() const {
+    return _source.getOrCreateData();
+  }
+
+ private:
+  FORCE_INLINE VariantRef getVariant() const;
+
+  FORCE_INLINE VariantConstRef getVariantConst() const {
+    return VariantConstRef(getData());
+  }
+
+  FORCE_INLINE VariantRef getOrCreateVariant() const;
+
+  TDataSource _source;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE