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

Make MemberProxy and `ElementProxy similar

Browse Source
This commit is contained in:
Benoit Blanchon
2022-08-09 13:57:23 +02:00
parent f73be9cf0f
commit ffa7f8d22d
2 changed files with 115 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,51 +16,43 @@
namespace ARDUINOJSON_NAMESPACE {
template <typename TArray>
class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
public VariantShortcuts<ElementProxy<TArray> >,
public VariantTag {
typedef ElementProxy<TArray> this_type;
template <typename TUpstream>
class ElementProxy //
: public VariantOperators<ElementProxy<TUpstream> >,
public VariantShortcuts<ElementProxy<TUpstream> >,
public VariantTag {
friend class VariantAttorney;
public:
FORCE_INLINE ElementProxy(TArray array, size_t index)
: _array(array), _index(index) {}
FORCE_INLINE ElementProxy(TUpstream upstream, size_t index)
: _upstream(upstream), _index(index) {}
FORCE_INLINE ElementProxy(const ElementProxy& src)
: _array(src._array), _index(src._index) {}
: _upstream(src._upstream), _index(src._index) {}
FORCE_INLINE this_type& operator=(const this_type& src) {
getOrAddUpstreamElement().set(src.as<VariantConstRef>());
FORCE_INLINE ElementProxy& operator=(const ElementProxy& src) {
getOrAddUpstreamVariant().set(src);
return *this;
}
// Replaces the value
//
// operator=(const TValue&)
// TValue = bool, long, int, short, float, double, serialized, VariantRef,
// std::string, String, ArrayRef, ObjectRef
template <typename T>
FORCE_INLINE this_type& operator=(const T& src) {
getOrAddUpstreamElement().set(src);
FORCE_INLINE ElementProxy& operator=(const T& src) {
getOrAddUpstreamVariant().set(src);
return *this;
}
//
// operator=(TValue)
// TValue = char*, const char*, const __FlashStringHelper*
template <typename T>
FORCE_INLINE this_type& operator=(T* src) {
getOrAddUpstreamElement().set(src);
FORCE_INLINE ElementProxy& operator=(T* src) {
getOrAddUpstreamVariant().set(src);
return *this;
}
FORCE_INLINE void clear() const {
getUpstreamElement().clear();
getUpstreamVariant().clear();
}
FORCE_INLINE bool isNull() const {
return getUpstreamElementConst().isNull();
return getUpstreamVariantConst().isNull();
}
template <typename T>
@ -68,13 +60,13 @@ class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
!ConverterNeedsWriteableRef<T>::value,
T>::type
as() const {
return getUpstreamElementConst().template as<T>();
return getUpstreamVariantConst().template as<T>();
}
template <typename T>
FORCE_INLINE typename enable_if<ConverterNeedsWriteableRef<T>::value, T>::type
as() const {
return getUpstreamElement().template as<T>();
return getUpstreamVariant().template as<T>();
}
template <typename T>
@ -89,62 +81,55 @@ class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
return as<T>();
}
template <typename T>
FORCE_INLINE typename VariantTo<T>::type to() {
return getOrAddUpstreamVariant().template to<T>();
}
template <typename T>
FORCE_INLINE
typename enable_if<ConverterNeedsWriteableRef<T>::value, bool>::type
is() const {
return getUpstreamElement().template is<T>();
return getUpstreamVariant().template is<T>();
}
template <typename T>
FORCE_INLINE
typename enable_if<!ConverterNeedsWriteableRef<T>::value, bool>::type
is() const {
return getUpstreamElementConst().template is<T>();
return getUpstreamVariantConst().template is<T>();
}
FORCE_INLINE void shallowCopy(VariantConstRef value) {
getOrAddUpstreamVariant().shallowCopy(value);
}
template <typename T>
FORCE_INLINE typename VariantTo<T>::type to() const {
return getOrAddUpstreamElement().template to<T>();
FORCE_INLINE bool set(const T& value) {
return getOrAddUpstreamVariant().set(value);
}
FORCE_INLINE void shallowCopy(VariantConstRef value) const {
getOrAddUpstreamElement().shallowCopy(value);
}
// Replaces the value
//
// bool set(const TValue&)
// TValue = bool, long, int, short, float, double, serialized, VariantRef,
// std::string, String, ArrayRef, ObjectRef
template <typename TValue>
FORCE_INLINE bool set(const TValue& value) const {
return getOrAddUpstreamElement().set(value);
}
//
// bool set(TValue)
// TValue = char*, const char*, const __FlashStringHelper*
template <typename TValue>
FORCE_INLINE bool set(TValue* value) const {
return getOrAddUpstreamElement().set(value);
template <typename T>
FORCE_INLINE bool set(T* value) {
return getOrAddUpstreamVariant().set(value);
}
FORCE_INLINE size_t size() const {
return getUpstreamElementConst().size();
return getUpstreamVariantConst().size();
}
FORCE_INLINE size_t memoryUsage() const {
return getUpstreamElementConst().memoryUsage();
return getUpstreamVariantConst().memoryUsage();
}
VariantRef add() const {
return getOrAddUpstreamElement().add();
FORCE_INLINE VariantRef add() const {
return getOrAddUpstreamVariant().add();
}
using ArrayShortcuts<ElementProxy<TArray> >::add;
using ArrayShortcuts<ElementProxy<TUpstream> >::add;
FORCE_INLINE void remove(size_t index) const {
getUpstreamElement().remove(index);
getUpstreamVariant().remove(index);
}
// remove(char*) const
// remove(const char*) const
@ -152,48 +137,48 @@ class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
template <typename TChar>
FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
TChar* key) const {
getUpstreamElement().remove(key);
getUpstreamVariant().remove(key);
}
// remove(const std::string&) const
// remove(const String&) const
template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
const TString& key) const {
getUpstreamElement().remove(key);
getUpstreamVariant().remove(key);
}
protected:
FORCE_INLINE MemoryPool* getPool() const {
return VariantAttorney::getPool(_array);
return VariantAttorney::getPool(_upstream);
}
FORCE_INLINE VariantData* getData() const {
return variantGetElement(VariantAttorney::getData(_array), _index);
return variantGetElement(VariantAttorney::getData(_upstream), _index);
}
FORCE_INLINE VariantData* getOrCreateData() const {
return variantGetOrAddElement(VariantAttorney::getOrCreateData(_array),
_index, VariantAttorney::getPool(_array));
return variantGetOrAddElement(VariantAttorney::getOrCreateData(_upstream),
_index, VariantAttorney::getPool(_upstream));
}
private:
FORCE_INLINE VariantRef getUpstreamElement() const {
FORCE_INLINE VariantRef getUpstreamVariant() const {
return VariantRef(getPool(), getData());
}
FORCE_INLINE VariantConstRef getUpstreamElementConst() const {
FORCE_INLINE VariantConstRef getUpstreamVariantConst() const {
return VariantConstRef(getData());
}
FORCE_INLINE VariantRef getOrAddUpstreamElement() const {
FORCE_INLINE VariantRef getOrAddUpstreamVariant() const {
return VariantRef(getPool(), getOrCreateData());
}
friend void convertToJson(const this_type& src, VariantRef dst) {
dst.set(src.getUpstreamElementConst());
friend void convertToJson(const ElementProxy& src, VariantRef dst) {
dst.set(src.getUpstreamVariantConst());
}
TArray _array;
TUpstream _upstream;
const size_t _index;
};

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

@ -19,52 +19,43 @@
namespace ARDUINOJSON_NAMESPACE {
template <typename TObject, typename TStringRef>
class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
public VariantShortcuts<MemberProxy<TObject, TStringRef> >,
public VariantTag {
typedef MemberProxy<TObject, TStringRef> this_type;
template <typename TUpstream, typename TStringRef>
class MemberProxy //
: public VariantOperators<MemberProxy<TUpstream, TStringRef> >,
public VariantShortcuts<MemberProxy<TUpstream, TStringRef> >,
public VariantTag {
friend class VariantAttorney;
public:
FORCE_INLINE MemberProxy(TObject variant, TStringRef key)
: _object(variant), _key(key) {}
FORCE_INLINE MemberProxy(TUpstream upstream, TStringRef key)
: _upstream(upstream), _key(key) {}
FORCE_INLINE MemberProxy(const MemberProxy& src)
: _object(src._object), _key(src._key) {}
: _upstream(src._upstream), _key(src._key) {}
FORCE_INLINE operator VariantConstRef() const {
return getUpstreamMemberConst();
}
FORCE_INLINE this_type& operator=(const this_type& src) {
getOrAddUpstreamMember().set(src);
FORCE_INLINE MemberProxy& operator=(const MemberProxy& src) {
getOrAddUpstreamVariant().set(src);
return *this;
}
template <typename TValue>
FORCE_INLINE typename enable_if<!is_array<TValue>::value, this_type&>::type
operator=(const TValue& src) {
getOrAddUpstreamMember().set(src);
template <typename T>
FORCE_INLINE MemberProxy& operator=(const T& src) {
getOrAddUpstreamVariant().set(src);
return *this;
}
// operator=(char*)
// operator=(const char*)
// operator=(const __FlashStringHelper*)
template <typename TChar>
FORCE_INLINE this_type& operator=(TChar* src) {
getOrAddUpstreamMember().set(src);
template <typename T>
FORCE_INLINE MemberProxy& operator=(T* src) {
getOrAddUpstreamVariant().set(src);
return *this;
}
FORCE_INLINE void clear() const {
getUpstreamMember().clear();
getUpstreamVariant().clear();
}
FORCE_INLINE bool isNull() const {
return getUpstreamMemberConst().isNull();
return getUpstreamVariantConst().isNull();
}
template <typename T>
@ -72,13 +63,13 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
!ConverterNeedsWriteableRef<T>::value,
T>::type
as() const {
return getUpstreamMemberConst().template as<T>();
return getUpstreamVariantConst().template as<T>();
}
template <typename T>
FORCE_INLINE typename enable_if<ConverterNeedsWriteableRef<T>::value, T>::type
as() const {
return getUpstreamMember().template as<T>();
return getUpstreamVariant().template as<T>();
}
template <typename T>
@ -93,30 +84,55 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
return as<T>();
}
template <typename T>
FORCE_INLINE typename VariantTo<T>::type to() {
return getOrAddUpstreamVariant().template to<T>();
}
template <typename T>
FORCE_INLINE
typename enable_if<ConverterNeedsWriteableRef<T>::value, bool>::type
is() const {
return getUpstreamMember().template is<T>();
return getUpstreamVariant().template is<T>();
}
template <typename T>
FORCE_INLINE
typename enable_if<!ConverterNeedsWriteableRef<T>::value, bool>::type
is() const {
return getUpstreamMemberConst().template is<T>();
return getUpstreamVariantConst().template is<T>();
}
FORCE_INLINE void shallowCopy(VariantConstRef value) {
getOrAddUpstreamVariant().shallowCopy(value);
}
template <typename T>
FORCE_INLINE bool set(const T& value) {
return getOrAddUpstreamVariant().set(value);
}
template <typename T>
FORCE_INLINE bool set(T* value) {
return getOrAddUpstreamVariant().set(value);
}
FORCE_INLINE size_t size() const {
return getUpstreamMemberConst().size();
return getUpstreamVariantConst().size();
}
FORCE_INLINE size_t memoryUsage() const {
return getUpstreamMemberConst().memoryUsage();
return getUpstreamVariantConst().memoryUsage();
}
FORCE_INLINE VariantRef add() const {
return getOrAddUpstreamVariant().add();
}
using ArrayShortcuts<MemberProxy<TUpstream, TStringRef> >::add;
FORCE_INLINE void remove(size_t index) const {
getUpstreamMember().remove(index);
getUpstreamVariant().remove(index);
}
// remove(char*) const
// remove(const char*) const
@ -124,77 +140,49 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
template <typename TChar>
FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
TChar* key) const {
getUpstreamMember().remove(key);
getUpstreamVariant().remove(key);
}
// remove(const std::string&) const
// remove(const String&) const
template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
const TString& key) const {
getUpstreamMember().remove(key);
getUpstreamVariant().remove(key);
}
FORCE_INLINE void shallowCopy(VariantConstRef value) {
getOrAddUpstreamMember().shallowCopy(value);
}
template <typename TValue>
FORCE_INLINE typename VariantTo<TValue>::type to() {
return getOrAddUpstreamMember().template to<TValue>();
}
template <typename TValue>
FORCE_INLINE bool set(const TValue& value) {
return getOrAddUpstreamMember().set(value);
}
// set(char*) const
// set(const char*) const
// set(const __FlashStringHelper*) const
template <typename TChar>
FORCE_INLINE bool set(TChar* value) {
return getOrAddUpstreamMember().set(value);
}
FORCE_INLINE VariantRef add() const {
return getOrAddUpstreamMember().add();
}
using ArrayShortcuts<MemberProxy<TObject, TStringRef> >::add;
protected:
FORCE_INLINE MemoryPool* getPool() const {
return VariantAttorney::getPool(_object);
return VariantAttorney::getPool(_upstream);
}
FORCE_INLINE VariantData* getData() const {
return variantGetMember(VariantAttorney::getData(_object),
return variantGetMember(VariantAttorney::getData(_upstream),
adaptString(_key));
}
FORCE_INLINE VariantData* getOrCreateData() const {
return variantGetOrAddMember(VariantAttorney::getOrCreateData(_object),
_key, VariantAttorney::getPool(_object));
return variantGetOrAddMember(VariantAttorney::getOrCreateData(_upstream),
_key, VariantAttorney::getPool(_upstream));
}
private:
FORCE_INLINE VariantRef getUpstreamMember() const {
FORCE_INLINE VariantRef getUpstreamVariant() const {
return VariantRef(getPool(), getData());
}
FORCE_INLINE VariantConstRef getUpstreamMemberConst() const {
FORCE_INLINE VariantConstRef getUpstreamVariantConst() const {
return VariantConstRef(getData());
}
FORCE_INLINE VariantRef getOrAddUpstreamMember() const {
FORCE_INLINE VariantRef getOrAddUpstreamVariant() const {
return VariantRef(getPool(), getOrCreateData());
}
friend void convertToJson(const this_type& src, VariantRef dst) {
dst.set(src.getUpstreamMemberConst());
friend void convertToJson(const MemberProxy& src, VariantRef dst) {
dst.set(src.getUpstreamVariantConst());
}
TObject _object;
TUpstream _upstream;
TStringRef _key;
};