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 { namespace ARDUINOJSON_NAMESPACE {
template <> template <>
struct Converter<Complex> { struct Converter<Complex> {
static void toJson(const Complex& src, VariantRef dst) { static void toJson(const Complex& src, JsonVariant dst) {
dst["real"] = src.real(); dst["real"] = src.real();
dst["imag"] = src.imag(); 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 == CHECK((is_convertible<DeserializationError, JsonVariantConst>::value ==
false)); false));
CHECK((is_convertible<JsonPair, 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<JsonVariantConst, JsonVariantConst>::value == true));
CHECK((is_convertible<JsonArray, JsonVariantConst>::value == true)); CHECK((is_convertible<JsonArray, JsonVariantConst>::value == true));
CHECK((is_convertible<ElementProxy<JsonArray>, JsonVariantConst>::value == CHECK((is_convertible<ElementProxy<JsonArray>, JsonVariantConst>::value ==

16
src/ArduinoJson.hpp
View File

@ -47,8 +47,15 @@
#include "ArduinoJson/compatibility.hpp" #include "ArduinoJson/compatibility.hpp"
namespace ArduinoJson { 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::JsonArray;
using ARDUINOJSON_NAMESPACE::JsonArrayConst; using ARDUINOJSON_NAMESPACE::JsonArrayConst;
using ARDUINOJSON_NAMESPACE::JsonDocument;
using ARDUINOJSON_NAMESPACE::JsonFloat; using ARDUINOJSON_NAMESPACE::JsonFloat;
using ARDUINOJSON_NAMESPACE::JsonInteger; using ARDUINOJSON_NAMESPACE::JsonInteger;
using ARDUINOJSON_NAMESPACE::JsonObject; using ARDUINOJSON_NAMESPACE::JsonObject;
@ -57,15 +64,8 @@ using ARDUINOJSON_NAMESPACE::JsonPair;
using ARDUINOJSON_NAMESPACE::JsonPairConst; using ARDUINOJSON_NAMESPACE::JsonPairConst;
using ARDUINOJSON_NAMESPACE::JsonString; using ARDUINOJSON_NAMESPACE::JsonString;
using ARDUINOJSON_NAMESPACE::JsonUInt; using ARDUINOJSON_NAMESPACE::JsonUInt;
using ARDUINOJSON_NAMESPACE::JsonVariant;
using ARDUINOJSON_NAMESPACE::JsonVariantConst; 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::measureJson;
using ARDUINOJSON_NAMESPACE::serialized; using ARDUINOJSON_NAMESPACE::serialized;
using ARDUINOJSON_NAMESPACE::serializeJson; 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) FORCE_INLINE JsonArray(MemoryPool* pool, CollectionData* data)
: _data(data), _pool(pool) {} : _data(data), _pool(pool) {}
operator VariantRef() { operator JsonVariant() {
void* data = _data; // prevent warning cast-align void* data = _data; // prevent warning cast-align
return VariantRef(_pool, reinterpret_cast<VariantData*>(data)); return JsonVariant(_pool, reinterpret_cast<VariantData*>(data));
} }
operator JsonArrayConst() const { operator JsonArrayConst() const {
return JsonArrayConst(_data); return JsonArrayConst(_data);
} }
VariantRef add() const { JsonVariant add() const {
if (!_data) if (!_data)
return VariantRef(); return JsonVariant();
return VariantRef(_pool, _data->addElement(_pool)); return JsonVariant(_pool, _data->addElement(_pool));
} }
template <typename T> template <typename T>
@ -141,11 +141,11 @@ class JsonArray : public VariantOperators<JsonArray> {
template <> template <>
struct Converter<JsonArray> : private VariantAttorney { 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)); variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static JsonArray fromJson(VariantRef src) { static JsonArray fromJson(JsonVariant src) {
VariantData* data = getData(src); VariantData* data = getData(src);
MemoryPool* pool = getPool(src); MemoryPool* pool = getPool(src);
return JsonArray(pool, data != 0 ? data->asArray() : 0); return JsonArray(pool, data != 0 ? data->asArray() : 0);
@ -158,7 +158,7 @@ struct Converter<JsonArray> : private VariantAttorney {
return false; return false;
} }
static bool checkJson(VariantRef src) { static bool checkJson(JsonVariant src) {
VariantData* data = getData(src); VariantData* data = getData(src);
return data && data->isArray(); return data && data->isArray();
} }

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

@ -93,7 +93,7 @@ class JsonArrayConst : public VariantOperators<JsonArrayConst> {
template <> template <>
struct Converter<JsonArrayConst> : private VariantAttorney { 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)); variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }

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

@ -4,8 +4,8 @@
#pragma once #pragma once
#include <ArduinoJson/Variant/JsonVariant.hpp>
#include <ArduinoJson/Variant/SlotFunctions.hpp> #include <ArduinoJson/Variant/SlotFunctions.hpp>
#include <ArduinoJson/Variant/VariantRef.hpp>
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
@ -13,16 +13,16 @@ class VariantPtr {
public: public:
VariantPtr(MemoryPool* pool, VariantData* data) : _variant(pool, data) {} VariantPtr(MemoryPool* pool, VariantData* data) : _variant(pool, data) {}
VariantRef* operator->() { JsonVariant* operator->() {
return &_variant; return &_variant;
} }
VariantRef& operator*() { JsonVariant& operator*() {
return _variant; return _variant;
} }
private: private:
VariantRef _variant; JsonVariant _variant;
}; };
class JsonArrayIterator { class JsonArrayIterator {
@ -33,8 +33,8 @@ class JsonArrayIterator {
explicit JsonArrayIterator(MemoryPool* pool, VariantSlot* slot) explicit JsonArrayIterator(MemoryPool* pool, VariantSlot* slot)
: _pool(pool), _slot(slot) {} : _pool(pool), _slot(slot) {}
VariantRef operator*() const { JsonVariant operator*() const {
return VariantRef(_pool, _slot->data()); return JsonVariant(_pool, _slot->data());
} }
VariantPtr operator->() { VariantPtr operator->() {
return VariantPtr(_pool, _slot->data()); 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 // Trivial form to stop the recursion
template <typename T> template <typename T>
inline typename enable_if<!is_array<T>::value, bool>::type copyArray( 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); return dst.set(src);
} }

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

@ -65,7 +65,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
BasicJsonDocument( BasicJsonDocument(
const T& src, const T& src,
typename enable_if< 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, JsonVariantConst>::value || is_same<T, JsonArray>::value ||
is_same<T, JsonArrayConst>::value || is_same<T, JsonObject>::value || is_same<T, JsonArrayConst>::value || is_same<T, JsonObject>::value ||
is_same<T, JsonObjectConst>::value>::type* = 0) is_same<T, JsonObjectConst>::value>::type* = 0)
@ -74,7 +74,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
} }
// disambiguate // disambiguate
BasicJsonDocument(VariantRef src) BasicJsonDocument(JsonVariant src)
: JsonDocument(allocPool(src.memoryUsage())) { : JsonDocument(allocPool(src.memoryUsage())) {
set(src); 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) { bool set(const JsonDocument& src) {
return to<VariantRef>().set(src.as<JsonVariantConst>()); return to<JsonVariant>().set(src.as<JsonVariantConst>());
} }
template <typename T> template <typename T>
typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set( typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set(
const T& src) { const T& src) {
return to<VariantRef>().set(src); return to<JsonVariant>().set(src);
} }
template <typename T> template <typename T>
@ -182,8 +182,8 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
return JsonVariantConst(_data.getElement(index)); return JsonVariantConst(_data.getElement(index));
} }
FORCE_INLINE VariantRef add() { FORCE_INLINE JsonVariant add() {
return VariantRef(&_pool, _data.addElement(&_pool)); return JsonVariant(&_pool, _data.addElement(&_pool));
} }
template <typename TValue> template <typename TValue>
@ -218,7 +218,7 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
_data.remove(adaptString(key)); _data.remove(adaptString(key));
} }
FORCE_INLINE operator VariantRef() { FORCE_INLINE operator JsonVariant() {
return getVariant(); return getVariant();
} }
@ -245,8 +245,8 @@ class JsonDocument : public VariantOperators<const JsonDocument&> {
_pool = pool; _pool = pool;
} }
VariantRef getVariant() { JsonVariant getVariant() {
return VariantRef(&_pool, &_data); return JsonVariant(&_pool, &_data);
} }
JsonVariantConst getVariant() const { 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>()); dst.set(src.as<JsonVariantConst>());
} }

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

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

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

@ -120,7 +120,7 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
template <> template <>
struct Converter<JsonObjectConst> : private VariantAttorney { 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)); variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }

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

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

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

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

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

@ -8,14 +8,14 @@
namespace ARDUINOJSON_NAMESPACE { namespace ARDUINOJSON_NAMESPACE {
class VariantRef : public VariantRefBase<VariantRef>, class JsonVariant : public VariantRefBase<JsonVariant>,
public VariantOperators<VariantRef> { public VariantOperators<JsonVariant> {
friend class VariantAttorney; friend class VariantAttorney;
public: 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: private:
FORCE_INLINE MemoryPool* getPool() const { FORCE_INLINE MemoryPool* getPool() const {
@ -35,19 +35,19 @@ class VariantRef : public VariantRefBase<VariantRef>,
}; };
template <> template <>
struct Converter<VariantRef> : private VariantAttorney { struct Converter<JsonVariant> : private VariantAttorney {
static void toJson(VariantRef src, VariantRef dst) { static void toJson(JsonVariant src, JsonVariant dst) {
variantCopyFrom(getData(dst), getData(src), getPool(dst)); variantCopyFrom(getData(dst), getData(src), getPool(dst));
} }
static VariantRef fromJson(VariantRef src) { static JsonVariant fromJson(JsonVariant src) {
return src; return src;
} }
static InvalidConversion<JsonVariantConst, VariantRef> fromJson( static InvalidConversion<JsonVariantConst, JsonVariant> fromJson(
JsonVariantConst); JsonVariantConst);
static bool checkJson(VariantRef src) { static bool checkJson(JsonVariant src) {
VariantData* data = getData(src); VariantData* data = getData(src);
return !!data; return !!data;
} }
@ -59,7 +59,7 @@ struct Converter<VariantRef> : private VariantAttorney {
template <> template <>
struct Converter<JsonVariantConst> : private VariantAttorney { 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)); 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/convertNumber.hpp>
#include <ArduinoJson/Numbers/parseNumber.hpp> #include <ArduinoJson/Numbers/parseNumber.hpp>
#include <ArduinoJson/Object/JsonObject.hpp> #include <ArduinoJson/Object/JsonObject.hpp>
#include <ArduinoJson/Variant/VariantRef.hpp> #include <ArduinoJson/Variant/JsonVariant.hpp>
#include <string.h> // for strcmp #include <string.h> // for strcmp
@ -105,18 +105,19 @@ inline bool VariantData::copyFrom(const VariantData& src, MemoryPool* pool) {
} }
template <typename TDerived> template <typename TDerived>
inline VariantRef VariantRefBase<TDerived>::add() const { inline JsonVariant VariantRefBase<TDerived>::add() const {
return VariantRef(getPool(), variantAddElement(getOrCreateData(), getPool())); return JsonVariant(getPool(),
variantAddElement(getOrCreateData(), getPool()));
} }
template <typename TDerived> template <typename TDerived>
inline VariantRef VariantRefBase<TDerived>::getVariant() const { inline JsonVariant VariantRefBase<TDerived>::getVariant() const {
return VariantRef(getPool(), getData()); return JsonVariant(getPool(), getData());
} }
template <typename TDerived> template <typename TDerived>
inline VariantRef VariantRefBase<TDerived>::getOrCreateVariant() const { inline JsonVariant VariantRefBase<TDerived>::getOrCreateVariant() const {
return VariantRef(getPool(), getOrCreateData()); return JsonVariant(getPool(), getOrCreateData());
} }
template <typename TDerived> template <typename TDerived>
@ -135,7 +136,7 @@ VariantRefBase<TDerived>::to() const {
template <typename TDerived> template <typename TDerived>
template <typename T> 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 { VariantRefBase<TDerived>::to() const {
variantSetNull(getOrCreateData()); variantSetNull(getOrCreateData());
return *this; return *this;
@ -148,7 +149,8 @@ inline bool VariantRefBase<TDerived>::set(char value) const {
} }
template <typename TDerived> 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>()); dst.set(src.template as<JsonVariantConst>());
} }

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

@ -21,7 +21,7 @@ struct VariantOperatorTag {};
template <typename TVariant> template <typename TVariant>
struct VariantOperators : VariantOperatorTag { 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) // int operator|(JsonVariant, int)
// float operator|(JsonVariant, float) // float operator|(JsonVariant, float)

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

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

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

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