feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests Activity

Remove Visitable

Browse Source
This commit is contained in:
Benoit Blanchon
2022-07-03 15:37:08 +02:00
parent 7c2ca773ff
commit 77b4270d97
14 changed files with 75 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ArduinoJson/Array/ArrayRef.hpp
View File

@ -62,8 +62,7 @@ class ArrayRefBase {
};
class ArrayConstRef : public ArrayRefBase<const CollectionData>,
public VariantOperators<ArrayConstRef>,
public Visitable {
public VariantOperators<ArrayConstRef> {
friend class ArrayRef;
typedef ArrayRefBase<const CollectionData> base_type;
@ -117,8 +116,7 @@ class ArrayConstRef : public ArrayRefBase<const CollectionData>,
class ArrayRef : public ArrayRefBase<CollectionData>,
public ArrayShortcuts<ArrayRef>,
public VariantOperators<ArrayRef>,
public Visitable {
public VariantOperators<ArrayRef> {
typedef ArrayRefBase<CollectionData> base_type;
public:

3
src/ArduinoJson/Array/ElementProxy.hpp
View File

@ -19,13 +19,10 @@ namespace ARDUINOJSON_NAMESPACE {
template <typename TArray>
class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
public VariantShortcuts<ElementProxy<TArray> >,
public Visitable,
public VariantTag {
typedef ElementProxy<TArray> this_type;
public:
typedef VariantRef variant_type;
FORCE_INLINE ElementProxy(TArray array, size_t index)
: _array(array), _index(index) {}

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

@ -14,8 +14,7 @@
namespace ARDUINOJSON_NAMESPACE {
class JsonDocument : public Visitable,
public VariantOperators<const JsonDocument&> {
class JsonDocument : public VariantOperators<const JsonDocument&> {
public:
template <typename TVisitor>
typename TVisitor::result_type accept(TVisitor& visitor) const {

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

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

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

@ -5,7 +5,6 @@
#pragma once
#include <ArduinoJson/Json/TextFormatter.hpp>
#include <ArduinoJson/Misc/Visitable.hpp>
#include <ArduinoJson/Serialization/measure.hpp>
#include <ArduinoJson/Serialization/serialize.hpp>
#include <ArduinoJson/Variant/Visitor.hpp>
@ -132,7 +131,8 @@ inline size_t measureJson(VariantConstRef source) {
#if ARDUINOJSON_ENABLE_STD_STREAM
template <typename T>
inline typename enable_if<IsVisitable<T>::value, std::ostream &>::type
inline typename enable_if<is_convertible<T, VariantConstRef>::value,
std::ostream &>::type
operator<<(std::ostream &os, const T &source) {
serializeJson(source, os);
return os;

21
src/ArduinoJson/Misc/Visitable.hpp
View File

@ -1,21 +0,0 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2022, Benoit BLANCHON
// MIT License
#pragma once
#include <ArduinoJson/Polyfills/type_traits.hpp>
namespace ARDUINOJSON_NAMESPACE {
struct Visitable {
// template<Visitor>
// void accept(Visitor&) const;
};
template <typename T>
struct IsVisitable : is_base_of<Visitable, T> {};
template <typename T>
struct IsVisitable<T &> : IsVisitable<T> {};
} // namespace ARDUINOJSON_NAMESPACE

3
src/ArduinoJson/Object/MemberProxy.hpp
View File

@ -22,13 +22,10 @@ namespace ARDUINOJSON_NAMESPACE {
template <typename TObject, typename TStringRef>
class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
public VariantShortcuts<MemberProxy<TObject, TStringRef> >,
public Visitable,
public VariantTag {
typedef MemberProxy<TObject, TStringRef> this_type;
public:
typedef VariantRef variant_type;
FORCE_INLINE MemberProxy(TObject variant, TStringRef key)
: _object(variant), _key(key) {}

6
src/ArduinoJson/Object/ObjectRef.hpp
View File

@ -57,8 +57,7 @@ class ObjectRefBase {
};
class ObjectConstRef : public ObjectRefBase<const CollectionData>,
public VariantOperators<ObjectConstRef>,
public Visitable {
public VariantOperators<ObjectConstRef> {
friend class ObjectRef;
typedef ObjectRefBase<const CollectionData> base_type;
@ -148,8 +147,7 @@ class ObjectConstRef : public ObjectRefBase<const CollectionData>,
class ObjectRef : public ObjectRefBase<CollectionData>,
public ObjectShortcuts<ObjectRef>,
public VariantOperators<ObjectRef>,
public Visitable {
public VariantOperators<ObjectRef> {
typedef ObjectRefBase<CollectionData> base_type;
public:

4
src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp
View File

@ -30,8 +30,10 @@ struct is_convertible {
static Yes &probe(To);
static No &probe(...);
static From &_from;
public:
static const bool value = sizeof(probe(declval<From>())) == sizeof(Yes);
static const bool value = sizeof(probe(_from)) == sizeof(Yes);
};
} // namespace ARDUINOJSON_NAMESPACE

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

@ -5,7 +5,6 @@
#pragma once
#include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Misc/Visitable.hpp>
#include <ArduinoJson/Numbers/arithmeticCompare.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Strings/StringAdapters.hpp>
@ -128,12 +127,10 @@ struct RawComparer : ComparerBase {
}
};
template <typename T>
struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type>
: ComparerBase {
const T *rhs; // TODO: should be a VariantConstRef
struct VariantComparer : ComparerBase {
VariantConstRef rhs;
explicit Comparer(const T &value) : rhs(&value) {}
explicit VariantComparer(VariantConstRef value) : rhs(value) {}
CompareResult visitArray(const CollectionData &lhs) {
ArrayComparer comparer(lhs);
@ -183,7 +180,7 @@ struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type>
private:
template <typename TComparer>
CompareResult accept(TComparer &comparer) {
CompareResult reversedResult = rhs->accept(comparer);
CompareResult reversedResult = rhs.accept(comparer);
switch (reversedResult) {
case COMPARE_RESULT_GREATER:
return COMPARE_RESULT_LESS;
@ -195,9 +192,17 @@ struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type>
}
};
template <typename T1, typename T2>
CompareResult compare(const T1 &lhs, const T2 &rhs) {
Comparer<T2> comparer(rhs);
template <typename T>
struct Comparer<
T, typename enable_if<is_convertible<T, VariantConstRef>::value>::type>
: VariantComparer {
explicit Comparer(const T &value)
: VariantComparer(value.operator VariantConstRef()) {}
};
template <typename T>
CompareResult compare(VariantConstRef lhs, const T &rhs) {
Comparer<T> comparer(rhs);
return lhs.accept(comparer);
}

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

@ -124,11 +124,6 @@ VariantRef::to() const {
return *this;
}
inline VariantConstRef operator|(VariantConstRef preferedValue,
VariantConstRef defaultValue) {
return preferedValue ? preferedValue : defaultValue;
}
// Out of class definition to avoid #1560
inline bool VariantRef::set(char value) const {
return set(static_cast<signed char>(value));

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

@ -4,7 +4,6 @@
#pragma once
#include <ArduinoJson/Misc/Visitable.hpp>
#include <ArduinoJson/Numbers/arithmeticCompare.hpp>
#include <ArduinoJson/Polyfills/attributes.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp>
@ -12,11 +11,16 @@
namespace ARDUINOJSON_NAMESPACE {
template <typename T1, typename T2>
CompareResult compare(const T1 &lhs, const T2 &rhs); // VariantCompare.cpp
class VariantConstRef;
template <typename T>
CompareResult compare(VariantConstRef lhs,
const T &rhs); // VariantCompare.cpp
struct VariantOperatorTag {};
template <typename TVariant>
struct VariantOperators {
struct VariantOperators : VariantOperatorTag {
// Returns the default value if the VariantRef is unbound or incompatible
//
// int operator|(JsonVariant, int)
@ -43,7 +47,7 @@ struct VariantOperators {
//
// JsonVariant operator|(JsonVariant, JsonVariant)
template <typename T>
friend typename enable_if<IsVariant<T>::value, typename T::variant_type>::type
friend typename enable_if<IsVariant<T>::value, VariantConstRef>::type
operator|(const TVariant &variant, T defaultValue) {
if (variant)
return variant;
@ -67,8 +71,9 @@ struct VariantOperators {
return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
}
template <typename T>
friend typename enable_if<!IsVisitable<T>::value, bool>::type operator==(
TVariant lhs, const T &rhs) {
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator==(TVariant lhs, const T &rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
}
@ -88,8 +93,9 @@ struct VariantOperators {
return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
}
template <typename T>
friend typename enable_if<!IsVisitable<T>::value, bool>::type operator!=(
TVariant lhs, const T &rhs) {
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator!=(TVariant lhs, const T &rhs) {
return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
}
@ -109,8 +115,9 @@ struct VariantOperators {
return compare(lhs, rhs) == COMPARE_RESULT_LESS;
}
template <typename T>
friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<(
TVariant lhs, const T &rhs) {
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator<(TVariant lhs, const T &rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_LESS;
}
@ -130,8 +137,9 @@ struct VariantOperators {
return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
}
template <typename T>
friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<=(
TVariant lhs, const T &rhs) {
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator<=(TVariant lhs, const T &rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
}
@ -151,8 +159,9 @@ struct VariantOperators {
return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
}
template <typename T>
friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>(
TVariant lhs, const T &rhs) {
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator>(TVariant lhs, const T &rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
}
@ -172,8 +181,9 @@ struct VariantOperators {
return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
template <typename T>
friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>=(
TVariant lhs, const T &rhs) {
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator>=(TVariant lhs, const T &rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
};

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

@ -8,7 +8,6 @@
#include <stdint.h> // for uint8_t
#include <ArduinoJson/Memory/MemoryPool.hpp>
#include <ArduinoJson/Misc/Visitable.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Strings/StringAdapters.hpp>
#include <ArduinoJson/Variant/Converter.hpp>
@ -66,8 +65,7 @@ class VariantRefBase : public VariantTag {
class VariantConstRef : public VariantRefBase<const VariantData>,
public VariantOperators<VariantConstRef>,
public VariantShortcuts<VariantConstRef>,
public Visitable {
public VariantShortcuts<VariantConstRef> {
typedef VariantRefBase<const VariantData> base_type;
public:
@ -180,8 +178,7 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
// - a reference to a ArrayRef or ObjectRef
class VariantRef : public VariantRefBase<VariantData>,
public VariantOperators<VariantRef>,
public VariantShortcuts<VariantRef>,
public Visitable {
public VariantShortcuts<VariantRef> {
typedef VariantRefBase<VariantData> base_type;
public: