bblanchon/ArduinoJson
1
0
Fork 1
mirror of https://github.com/bblanchon/ArduinoJson.git synced 2025-11-03 08:01:41 +01:00
Code Issues Packages Projects Releases Wiki Activity

Make ElementProxy and MemberProxy non-copyable

Browse Source
This commit is contained in:
Benoit Blanchon
2024-11-25 10:46:21 +01:00
parent 5e7653b36a
commit 57a9c50b38
10 changed files with 105 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -15,13 +15,18 @@ class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
public VariantOperators<ElementProxy<TUpstream>> {
friend class VariantAttorney;
friend class VariantRefBase<ElementProxy<TUpstream>>;
template <typename, typename>
friend class MemberProxy;
template <typename>
friend class ElementProxy;
public:
ElementProxy(TUpstream upstream, size_t index)
: upstream_(upstream), index_(index) {}
ElementProxy(const ElementProxy& src)
: upstream_(src.upstream_), index_(src.index_) {}
ElementProxy& operator=(const ElementProxy& src) {
this->set(src);
return *this;
@@ -40,6 +45,11 @@ class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
}
private:
// clang-format off
ElementProxy(const ElementProxy& src) // Error here? See https://arduinojson.org/v7/proxy-non-copyable/
: upstream_(src.upstream_), index_(src.index_) {}
// clang-format on
ResourceManager* getResourceManager() const {
return VariantAttorney::getResourceManager(upstream_);
}

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

@@ -116,7 +116,7 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
// https://arduinojson.org/v7/api/jsonarray/remove/
template <typename TVariant>
detail::enable_if_t<detail::IsVariant<TVariant>::value> remove(
TVariant variant) const {
const TVariant& variant) const {
if (variant.template is<size_t>())
remove(variant.template as<size_t>());
}
@@ -143,7 +143,7 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
detail::ElementProxy<JsonArray>>
operator[](const TVariant& variant) const {
if (variant.template is<size_t>())
return operator[](variant.template as<size_t>());
return {*this, variant.template as<size_t>()};
else
return {*this, size_t(-1)};
}

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

@@ -16,13 +16,18 @@ class MemberProxy
public VariantOperators<MemberProxy<TUpstream, AdaptedString>> {
friend class VariantAttorney;
friend class VariantRefBase<MemberProxy<TUpstream, AdaptedString>>;
template <typename, typename>
friend class MemberProxy;
template <typename>
friend class ElementProxy;
public:
MemberProxy(TUpstream upstream, AdaptedString key)
: upstream_(upstream), key_(key) {}
MemberProxy(const MemberProxy& src)
: upstream_(src.upstream_), key_(src.key_) {}
MemberProxy& operator=(const MemberProxy& src) {
this->set(src);
return *this;
@@ -41,6 +46,11 @@ class MemberProxy
}
private:
// clang-format off
MemberProxy(const MemberProxy& src) // Error here? See https://arduinojson.org/v7/proxy-non-copyable/
: upstream_(src.upstream_), key_(src.key_) {}
// clang-format on
ResourceManager* getResourceManager() const {
return VariantAttorney::getResourceManager(upstream_);
}

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

@@ -51,7 +51,7 @@ struct VariantOperators : VariantOperatorTag {
// JsonVariant operator|(JsonVariant, JsonVariant)
template <typename T>
friend enable_if_t<IsVariant<T>::value, JsonVariantConst> operator|(
const TVariant& variant, T defaultValue) {
const TVariant& variant, const T& defaultValue) {
if (variant)
return variant;
else
@@ -60,38 +60,38 @@ struct VariantOperators : VariantOperatorTag {
// value == TVariant
template <typename T>
friend bool operator==(T* lhs, TVariant rhs) {
friend bool operator==(T* lhs, const TVariant& rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
}
template <typename T>
friend bool operator==(const T& lhs, TVariant rhs) {
friend bool operator==(const T& lhs, const TVariant& rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
}
// TVariant == value
template <typename T>
friend bool operator==(TVariant lhs, T* rhs) {
friend bool operator==(const TVariant& lhs, T* rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
}
template <typename T>
friend enable_if_t<!is_base_of<VariantOperatorTag, T>::value, bool>
operator==(TVariant lhs, const T& rhs) {
operator==(const TVariant& lhs, const T& rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
}
// value != TVariant
template <typename T>
friend bool operator!=(T* lhs, TVariant rhs) {
friend bool operator!=(T* lhs, const TVariant& rhs) {
return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
}
template <typename T>
friend bool operator!=(const T& lhs, TVariant rhs) {
friend bool operator!=(const T& lhs, const TVariant& rhs) {
return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
}
// TVariant != value
template <typename T>
friend bool operator!=(TVariant lhs, T* rhs) {
friend bool operator!=(const TVariant& lhs, T* rhs) {
return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
}
template <typename T>
@@ -102,17 +102,17 @@ struct VariantOperators : VariantOperatorTag {
// value < TVariant
template <typename T>
friend bool operator<(T* lhs, TVariant rhs) {
friend bool operator<(T* lhs, const TVariant& rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
}
template <typename T>
friend bool operator<(const T& lhs, TVariant rhs) {
friend bool operator<(const T& lhs, const TVariant& rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
}
// TVariant < value
template <typename T>
friend bool operator<(TVariant lhs, T* rhs) {
friend bool operator<(const TVariant& lhs, T* rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_LESS;
}
template <typename T>
@@ -123,17 +123,17 @@ struct VariantOperators : VariantOperatorTag {
// value <= TVariant
template <typename T>
friend bool operator<=(T* lhs, TVariant rhs) {
friend bool operator<=(T* lhs, const TVariant& rhs) {
return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
template <typename T>
friend bool operator<=(const T& lhs, TVariant rhs) {
friend bool operator<=(const T& lhs, const TVariant& rhs) {
return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
// TVariant <= value
template <typename T>
friend bool operator<=(TVariant lhs, T* rhs) {
friend bool operator<=(const TVariant& lhs, T* rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
}
template <typename T>
@@ -144,17 +144,17 @@ struct VariantOperators : VariantOperatorTag {
// value > TVariant
template <typename T>
friend bool operator>(T* lhs, TVariant rhs) {
friend bool operator>(T* lhs, const TVariant& rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_LESS;
}
template <typename T>
friend bool operator>(const T& lhs, TVariant rhs) {
friend bool operator>(const T& lhs, const TVariant& rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_LESS;
}
// TVariant > value
template <typename T>
friend bool operator>(TVariant lhs, T* rhs) {
friend bool operator>(const TVariant& lhs, T* rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
}
template <typename T>
@@ -165,22 +165,22 @@ struct VariantOperators : VariantOperatorTag {
// value >= TVariant
template <typename T>
friend bool operator>=(T* lhs, TVariant rhs) {
friend bool operator>=(T* lhs, const TVariant& rhs) {
return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
}
template <typename T>
friend bool operator>=(const T& lhs, TVariant rhs) {
friend bool operator>=(const T& lhs, const TVariant& rhs) {
return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
}
// TVariant >= value
template <typename T>
friend bool operator>=(TVariant lhs, T* rhs) {
friend bool operator>=(const TVariant& lhs, T* rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
template <typename T>
friend enable_if_t<!is_base_of<VariantOperatorTag, T>::value, bool>
operator>=(TVariant lhs, const T& rhs) {
operator>=(const TVariant& lhs, const T& rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
};

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

@@ -119,7 +119,7 @@ inline bool VariantRefBase<TDerived>::is() const {
template <typename TDerived>
inline ElementProxy<TDerived> VariantRefBase<TDerived>::operator[](
size_t index) const {
return ElementProxy<TDerived>(derived(), index);
return {derived(), index};
}
template <typename TDerived>