bblanchon/ArduinoJson
1
0
Fork 1
mirror of https://github.com/bblanchon/ArduinoJson.git synced 2025-07-18 21:12:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

Rename VariantConstRef to JsonVariantConst

Browse Source
This commit is contained in:
Benoit Blanchon
2022-12-19 12:05:08 +01:00
parent b8eff868e6
commit ef8ed28aec
29 changed files with 134 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

4
src/ArduinoJson.hpp
View File

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

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

@ -98,8 +98,8 @@ class JsonArray : public VariantOperators<JsonArray> {
return add().to<JsonArray>();
}
operator VariantConstRef() const {
return VariantConstRef(collectionToVariant(_data));
operator JsonVariantConst() const {
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(
VariantConstRef);
static InvalidConversion<JsonVariantConst, JsonArray> fromJson(
JsonVariantConst);
static bool checkJson(VariantConstRef) {
static bool checkJson(JsonVariantConst) {
return false;
}

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

@ -55,12 +55,12 @@ class JsonArrayConst : public VariantOperators<JsonArrayConst> {
}
}
FORCE_INLINE VariantConstRef operator[](size_t index) const {
return VariantConstRef(_data ? _data->getElement(index) : 0);
FORCE_INLINE JsonVariantConst operator[](size_t index) const {
return JsonVariantConst(_data ? _data->getElement(index) : 0);
}
operator VariantConstRef() const {
return VariantConstRef(collectionToVariant(_data));
operator JsonVariantConst() const {
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();
}

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

@ -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 {
return VariantConstRef(_slot->data());
JsonVariantConst operator*() const {
return JsonVariantConst(_slot->data());
}
VariantConstPtr operator->() {
return VariantConstPtr(_slot->data());

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

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

6
src/ArduinoJson/Deserialization/Filter.hpp
View File

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

2
src/ArduinoJson/Deserialization/Readers/VariantReader.hpp
View File

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

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

@ -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, JsonArray>::value || is_same<T, JsonArrayConst>::value ||
is_same<T, JsonObject>::value ||
is_same<T, VariantRef>::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)
: JsonDocument(allocPool(src.memoryUsage())) {
set(src);

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

@ -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 {
return VariantConstRef(_data.getElement(index));
FORCE_INLINE JsonVariantConst operator[](size_t index) const {
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 {
return VariantConstRef(&_data);
JsonVariantConst getVariant() const {
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

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

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

8
src/ArduinoJson/Json/JsonSerializer.hpp
View File

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

6
src/ArduinoJson/Json/PrettyJsonSerializer.hpp
View File

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

6
src/ArduinoJson/MsgPack/MsgPackSerializer.hpp
View File

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

2
src/ArduinoJson/Numbers/parseNumber.hpp
View File

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

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

@ -30,8 +30,8 @@ class JsonObject : public VariantOperators<JsonObject> {
return JsonObjectConst(_data);
}
operator VariantConstRef() const {
return VariantConstRef(collectionToVariant(_data));
operator JsonVariantConst() const {
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(
VariantConstRef);
static InvalidConversion<JsonVariantConst, JsonObject> fromJson(
JsonVariantConst);
static bool checkJson(VariantConstRef) {
static bool checkJson(JsonVariantConst) {
return false;
}

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

@ -19,8 +19,8 @@ class JsonObjectConst : public VariantOperators<JsonObjectConst> {
JsonObjectConst() : _data(0) {}
JsonObjectConst(const CollectionData* data) : _data(data) {}
operator VariantConstRef() const {
return VariantConstRef(collectionToVariant(_data));
operator JsonVariantConst() const {
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();
}

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

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

2
src/ArduinoJson/Serialization/measure.hpp
View File

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

10
src/ArduinoJson/Serialization/serialize.hpp
View File

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

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

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

20
src/ArduinoJson/Variant/VariantConstRef.hpp → src/ArduinoJson/Variant/JsonVariantConst.hpp
View File

@ -22,13 +22,13 @@ namespace ARDUINOJSON_NAMESPACE {
class JsonArray;
class JsonObject;
class VariantConstRef : public VariantTag,
public VariantOperators<VariantConstRef> {
class JsonVariantConst : public VariantTag,
public VariantOperators<JsonVariantConst> {
friend class VariantAttorney;
public:
VariantConstRef() : _data(0) {}
explicit VariantConstRef(const VariantData* data) : _data(data) {}
JsonVariantConst() : _data(0) {}
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 {
return VariantConstRef(variantGetElement(_data, index));
FORCE_INLINE JsonVariantConst operator[](size_t index) const {
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

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

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

4
src/ArduinoJson/Variant/VariantCompare.hpp
View File

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

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

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

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

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

16
src/ArduinoJson/Variant/VariantRef.hpp
View File

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

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

@ -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 {
return VariantConstRef(getData());
FORCE_INLINE JsonVariantConst getVariantConst() const {
return JsonVariantConst(getData());
}
FORCE_INLINE VariantRef getOrCreateVariant() const;