bblanchon/ArduinoJson
1
0
Fork 1
mirror of https://github.com/bblanchon/ArduinoJson.git synced 2025-07-17 20:42:24 +02:00
Code Issues Packages Projects Releases Wiki Activity

Rename VariantRef to JsonVariant

Browse Source
This commit is contained in:
Benoit Blanchon
2022-12-19 12:07:40 +01:00
parent ef8ed28aec
commit b0730f04f7
19 changed files with 92 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
extras/tests/JsonVariant/converters.cpp
View File

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

2
extras/tests/Misc/TypeTraits.cpp
View File

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

16
src/ArduinoJson.hpp
View File

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

16
src/ArduinoJson/Array/JsonArray.hpp
View File

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

2
src/ArduinoJson/Array/JsonArrayConst.hpp
View File

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

12
src/ArduinoJson/Array/JsonArrayIterator.hpp
View File

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

2
src/ArduinoJson/Array/Utilities.hpp
View File

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

4
src/ArduinoJson/Document/BasicJsonDocument.hpp
View File

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

16
src/ArduinoJson/Document/JsonDocument.hpp
View File

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

2
src/ArduinoJson/Document/StaticJsonDocument.hpp
View File

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

10
src/ArduinoJson/Object/JsonObject.hpp
View File

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

2
src/ArduinoJson/Object/JsonObjectConst.hpp
View File

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

8
src/ArduinoJson/Object/JsonPair.hpp
View File

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

26
src/ArduinoJson/Variant/ConverterImpl.hpp
View File

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

20
src/ArduinoJson/Variant/VariantRef.hpp → src/ArduinoJson/Variant/JsonVariant.hpp
View File

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

20
src/ArduinoJson/Variant/VariantImpl.hpp
View File

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

2
src/ArduinoJson/Variant/VariantOperators.hpp
View File

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

12
src/ArduinoJson/Variant/VariantRefBase.hpp
View File

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

8
src/ArduinoJson/Variant/VariantTo.hpp
View File

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