github-mirrors/thirdparty-ArduinoJson
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-ArduinoJson.git synced 2025-11-02 08:48:27 +01:00
Code Issues Packages Projects Releases Wiki Activity

Clang-format: set DerivePointerAlignment to false

Browse Source
This commit is contained in:
Benoit Blanchon
2022-08-09 16:52:17 +02:00
parent 62e83133cd
commit 8002722f3b
53 changed files with 514 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -20,30 +20,30 @@ class VariantAttorney {
typedef char Yes[1];
typedef char No[2];
static Yes &probe(const VariantData *);
static No &probe(VariantData *);
static Yes& probe(const VariantData*);
static No& probe(VariantData*);
static TClient &client;
static TClient& client;
public:
typedef typename conditional<sizeof(probe(client.getData())) == sizeof(Yes),
const VariantData *, VariantData *>::type type;
const VariantData*, VariantData*>::type type;
};
public:
template <typename TClient>
FORCE_INLINE static MemoryPool *getPool(TClient &client) {
FORCE_INLINE static MemoryPool* getPool(TClient& client) {
return client.getPool();
}
template <typename TClient>
FORCE_INLINE static typename ResultOfGetData<TClient>::type getData(
TClient &client) {
TClient& client) {
return client.getData();
}
template <typename TClient>
FORCE_INLINE static VariantData *getOrCreateData(TClient &client) {
FORCE_INLINE static VariantData* getOrCreateData(TClient& client) {
return client.getOrCreateData();
}
};

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

@@ -26,7 +26,7 @@ struct Comparer<T, typename enable_if<IsString<T>::value>::type>
explicit Comparer(T value) : rhs(value) {}
CompareResult visitString(const char *lhs, size_t n) {
CompareResult visitString(const char* lhs, size_t n) {
int i = stringCompare(adaptString(rhs), adaptString(lhs, n));
if (i < 0)
return COMPARE_RESULT_GREATER;
@@ -83,11 +83,11 @@ struct Comparer<decltype(nullptr), void> : NullComparer {
#endif
struct ArrayComparer : ComparerBase {
const CollectionData *_rhs;
const CollectionData* _rhs;
explicit ArrayComparer(const CollectionData &rhs) : _rhs(&rhs) {}
explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {}
CompareResult visitArray(const CollectionData &lhs) {
CompareResult visitArray(const CollectionData& lhs) {
if (ArrayConstRef(&lhs) == ArrayConstRef(_rhs))
return COMPARE_RESULT_EQUAL;
else
@@ -96,11 +96,11 @@ struct ArrayComparer : ComparerBase {
};
struct ObjectComparer : ComparerBase {
const CollectionData *_rhs;
const CollectionData* _rhs;
explicit ObjectComparer(const CollectionData &rhs) : _rhs(&rhs) {}
explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {}
CompareResult visitObject(const CollectionData &lhs) {
CompareResult visitObject(const CollectionData& lhs) {
if (ObjectConstRef(&lhs) == ObjectConstRef(_rhs))
return COMPARE_RESULT_EQUAL;
else
@@ -109,13 +109,13 @@ struct ObjectComparer : ComparerBase {
};
struct RawComparer : ComparerBase {
const char *_rhsData;
const char* _rhsData;
size_t _rhsSize;
explicit RawComparer(const char *rhsData, size_t rhsSize)
explicit RawComparer(const char* rhsData, size_t rhsSize)
: _rhsData(rhsData), _rhsSize(rhsSize) {}
CompareResult visitRawJson(const char *lhsData, size_t lhsSize) {
CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
int n = memcmp(lhsData, _rhsData, size);
if (n < 0)
@@ -132,12 +132,12 @@ struct VariantComparer : ComparerBase {
explicit VariantComparer(VariantConstRef value) : rhs(value) {}
CompareResult visitArray(const CollectionData &lhs) {
CompareResult visitArray(const CollectionData& lhs) {
ArrayComparer comparer(lhs);
return accept(comparer);
}
CompareResult visitObject(const CollectionData &lhs) {
CompareResult visitObject(const CollectionData& lhs) {
ObjectComparer comparer(lhs);
return accept(comparer);
}
@@ -147,12 +147,12 @@ struct VariantComparer : ComparerBase {
return accept(comparer);
}
CompareResult visitString(const char *lhs, size_t) {
Comparer<const char *> comparer(lhs);
CompareResult visitString(const char* lhs, size_t) {
Comparer<const char*> comparer(lhs);
return accept(comparer);
}
CompareResult visitRawJson(const char *lhsData, size_t lhsSize) {
CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
RawComparer comparer(lhsData, lhsSize);
return accept(comparer);
}
@@ -179,7 +179,7 @@ struct VariantComparer : ComparerBase {
private:
template <typename TComparer>
CompareResult accept(TComparer &comparer) {
CompareResult accept(TComparer& comparer) {
CompareResult reversedResult =
variantAccept(VariantAttorney::getData(rhs), comparer);
switch (reversedResult) {
@@ -197,12 +197,12 @@ template <typename T>
struct Comparer<
T, typename enable_if<is_convertible<T, VariantConstRef>::value>::type>
: VariantComparer {
explicit Comparer(const T &value)
explicit Comparer(const T& value)
: VariantComparer(value.operator VariantConstRef()) {}
};
template <typename T>
CompareResult compare(VariantConstRef lhs, const T &rhs) {
CompareResult compare(VariantConstRef lhs, const T& rhs) {
Comparer<T> comparer(rhs);
return variantAccept(VariantAttorney::getData(lhs), comparer);
}

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

@@ -39,7 +39,7 @@ enum {
};
struct RawData {
const char *data;
const char* data;
size_t size;
};
@@ -50,7 +50,7 @@ union VariantContent {
Integer asSignedInteger;
CollectionData asCollection;
struct {
const char *data;
const char* data;
size_t size;
} asString;
};

50
src/ArduinoJson/Variant/VariantData.hpp
View File

@@ -37,13 +37,13 @@ class VariantData {
_flags = VALUE_IS_NULL;
}
void operator=(const VariantData &src) {
void operator=(const VariantData& src) {
_content = src._content;
_flags = uint8_t((_flags & OWNED_KEY_BIT) | (src._flags & ~OWNED_KEY_BIT));
}
template <typename TVisitor>
typename TVisitor::result_type accept(TVisitor &visitor) const {
typename TVisitor::result_type accept(TVisitor& visitor) const {
switch (type()) {
case VALUE_IS_FLOAT:
return visitor.visitFloat(_content.asFloat);
@@ -88,27 +88,27 @@ class VariantData {
bool asBoolean() const;
CollectionData *asArray() {
CollectionData* asArray() {
return isArray() ? &_content.asCollection : 0;
}
const CollectionData *asArray() const {
return const_cast<VariantData *>(this)->asArray();
const CollectionData* asArray() const {
return const_cast<VariantData*>(this)->asArray();
}
const CollectionData *asCollection() const {
const CollectionData* asCollection() const {
return isCollection() ? &_content.asCollection : 0;
}
CollectionData *asObject() {
CollectionData* asObject() {
return isObject() ? &_content.asCollection : 0;
}
const CollectionData *asObject() const {
return const_cast<VariantData *>(this)->asObject();
const CollectionData* asObject() const {
return const_cast<VariantData*>(this)->asObject();
}
bool copyFrom(const VariantData &src, MemoryPool *pool);
bool copyFrom(const VariantData& src, MemoryPool* pool);
bool isArray() const {
return (_flags & VALUE_IS_ARRAY) != 0;
@@ -177,7 +177,7 @@ class VariantData {
_content.asFloat = value;
}
void setLinkedRaw(SerializedValue<const char *> value) {
void setLinkedRaw(SerializedValue<const char*> value) {
if (value.data()) {
setType(VALUE_IS_LINKED_RAW);
_content.asString.data = value.data();
@@ -188,8 +188,8 @@ class VariantData {
}
template <typename T>
bool storeOwnedRaw(SerializedValue<T> value, MemoryPool *pool) {
const char *dup = pool->saveString(adaptString(value.data(), value.size()));
bool storeOwnedRaw(SerializedValue<T> value, MemoryPool* pool) {
const char* dup = pool->saveString(adaptString(value.data(), value.size()));
if (dup) {
setType(VALUE_IS_OWNED_RAW);
_content.asString.data = dup;
@@ -227,13 +227,13 @@ class VariantData {
_content.asString.size = s.size();
}
CollectionData &toArray() {
CollectionData& toArray() {
setType(VALUE_IS_ARRAY);
_content.asCollection.clear();
return _content.asCollection;
}
CollectionData &toObject() {
CollectionData& toObject() {
setType(VALUE_IS_OBJECT);
_content.asCollection.clear();
return _content.asCollection;
@@ -258,7 +258,7 @@ class VariantData {
return isCollection() ? _content.asCollection.size() : 0;
}
VariantData *addElement(MemoryPool *pool) {
VariantData* addElement(MemoryPool* pool) {
if (isNull())
toArray();
if (!isArray())
@@ -266,12 +266,12 @@ class VariantData {
return _content.asCollection.addElement(pool);
}
VariantData *getElement(size_t index) const {
const CollectionData *col = asArray();
VariantData* getElement(size_t index) const {
const CollectionData* col = asArray();
return col ? col->getElement(index) : 0;
}
VariantData *getOrAddElement(size_t index, MemoryPool *pool) {
VariantData* getOrAddElement(size_t index, MemoryPool* pool) {
if (isNull())
toArray();
if (!isArray())
@@ -280,13 +280,13 @@ class VariantData {
}
template <typename TAdaptedString>
VariantData *getMember(TAdaptedString key) const {
const CollectionData *col = asObject();
VariantData* getMember(TAdaptedString key) const {
const CollectionData* col = asObject();
return col ? col->getMember(key) : 0;
}
template <typename TAdaptedString, typename TStoragePolicy>
VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool,
VariantData* getOrAddMember(TAdaptedString key, MemoryPool* pool,
TStoragePolicy storage_policy) {
if (isNull())
toObject();
@@ -307,7 +307,7 @@ class VariantData {
}
template <typename TAdaptedString, typename TStoragePolicy>
inline bool storeString(TAdaptedString value, MemoryPool *pool,
inline bool storeString(TAdaptedString value, MemoryPool* pool,
TStoragePolicy storage) {
if (value.isNull()) {
setNull();
@@ -324,7 +324,7 @@ class VariantData {
}
struct VariantStringSetter {
VariantStringSetter(VariantData *instance) : _instance(instance) {}
VariantStringSetter(VariantData* instance) : _instance(instance) {}
template <typename TStoredString>
void operator()(TStoredString s) {
@@ -334,7 +334,7 @@ class VariantData {
_instance->setNull();
}
VariantData *_instance;
VariantData* _instance;
};
};

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

@@ -12,16 +12,16 @@
namespace ARDUINOJSON_NAMESPACE {
template <typename TVisitor>
inline typename TVisitor::result_type variantAccept(const VariantData *var,
TVisitor &visitor) {
inline typename TVisitor::result_type variantAccept(const VariantData* var,
TVisitor& visitor) {
if (var != 0)
return var->accept(visitor);
else
return visitor.visitNull();
}
inline bool variantCopyFrom(VariantData *dst, const VariantData *src,
MemoryPool *pool) {
inline bool variantCopyFrom(VariantData* dst, const VariantData* src,
MemoryPool* pool) {
if (!dst)
return false;
if (!src) {
@@ -31,51 +31,51 @@ inline bool variantCopyFrom(VariantData *dst, const VariantData *src,
return dst->copyFrom(*src, pool);
}
inline void variantSetNull(VariantData *var) {
inline void variantSetNull(VariantData* var) {
if (!var)
return;
var->setNull();
}
template <typename TAdaptedString, typename TStoragePolicy>
inline bool variantSetString(VariantData *var, TAdaptedString value,
MemoryPool *pool, TStoragePolicy storage_policy) {
inline bool variantSetString(VariantData* var, TAdaptedString value,
MemoryPool* pool, TStoragePolicy storage_policy) {
return var != 0 ? var->storeString(value, pool, storage_policy) : 0;
}
inline size_t variantSize(const VariantData *var) {
inline size_t variantSize(const VariantData* var) {
return var != 0 ? var->size() : 0;
}
inline CollectionData *variantToArray(VariantData *var) {
inline CollectionData* variantToArray(VariantData* var) {
if (!var)
return 0;
return &var->toArray();
}
inline CollectionData *variantToObject(VariantData *var) {
inline CollectionData* variantToObject(VariantData* var) {
if (!var)
return 0;
return &var->toObject();
}
inline VariantData *variantGetElement(const VariantData *var, size_t index) {
inline VariantData* variantGetElement(const VariantData* var, size_t index) {
return var != 0 ? var->getElement(index) : 0;
}
inline NO_INLINE VariantData *variantAddElement(VariantData *var,
MemoryPool *pool) {
inline NO_INLINE VariantData* variantAddElement(VariantData* var,
MemoryPool* pool) {
return var != 0 ? var->addElement(pool) : 0;
}
inline NO_INLINE VariantData *variantGetOrAddElement(VariantData *var,
inline NO_INLINE VariantData* variantGetOrAddElement(VariantData* var,
size_t index,
MemoryPool *pool) {
MemoryPool* pool) {
return var != 0 ? var->getOrAddElement(index, pool) : 0;
}
template <typename AdaptedString>
VariantData *variantGetMember(const VariantData *var, AdaptedString key) {
VariantData* variantGetMember(const VariantData* var, AdaptedString key) {
if (!var)
return 0;
return var->getMember(key);
@@ -84,8 +84,8 @@ VariantData *variantGetMember(const VariantData *var, AdaptedString key) {
// TODO: this function is inconsitent with the others:
// it should take an adapted string
template <typename TChar>
VariantData *variantGetOrAddMember(VariantData *var, TChar *key,
MemoryPool *pool) {
VariantData* variantGetOrAddMember(VariantData* var, TChar* key,
MemoryPool* pool) {
if (!var)
return 0;
return var->getOrAddMember(adaptString(key), pool,
@@ -93,28 +93,28 @@ VariantData *variantGetOrAddMember(VariantData *var, TChar *key,
}
template <typename TString>
VariantData *variantGetOrAddMember(VariantData *var, const TString &key,
MemoryPool *pool) {
VariantData* variantGetOrAddMember(VariantData* var, const TString& key,
MemoryPool* pool) {
if (!var)
return 0;
return var->getOrAddMember(adaptString(key), pool,
getStringStoragePolicy(key));
}
inline bool variantIsNull(const VariantData *var) {
inline bool variantIsNull(const VariantData* var) {
return var == 0 || var->isNull();
}
inline size_t variantNesting(const VariantData *var) {
inline size_t variantNesting(const VariantData* var) {
if (!var)
return 0;
const CollectionData *collection = var->asCollection();
const CollectionData* collection = var->asCollection();
if (!collection)
return 0;
size_t maxChildNesting = 0;
for (const VariantSlot *s = collection->head(); s; s = s->next()) {
for (const VariantSlot* s = collection->head(); s; s = s->next()) {
size_t childNesting = variantNesting(s->data());
if (childNesting > maxChildNesting)
maxChildNesting = childNesting;

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

@@ -83,7 +83,7 @@ inline String VariantData::asString() const {
}
}
inline bool VariantData::copyFrom(const VariantData &src, MemoryPool *pool) {
inline bool VariantData::copyFrom(const VariantData& src, MemoryPool* pool) {
switch (src.type()) {
case VALUE_IS_ARRAY:
return toArray().copyFrom(src._content.asCollection, pool);
@@ -131,9 +131,9 @@ inline bool VariantRef::set(char value) const {
// TODO: move somewhere else
template <typename TAdaptedString, typename TCallback>
bool CopyStringStoragePolicy::store(TAdaptedString str, MemoryPool *pool,
bool CopyStringStoragePolicy::store(TAdaptedString str, MemoryPool* pool,
TCallback callback) {
const char *copy = pool->saveString(str);
const char* copy = pool->saveString(str);
String storedString(copy, str.size(), String::Copied);
callback(storedString);
return copy != 0;

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

@@ -15,7 +15,7 @@ class VariantConstRef;
template <typename T>
CompareResult compare(VariantConstRef lhs,
const T &rhs); // VariantCompare.cpp
const T& rhs); // VariantCompare.cpp
struct VariantOperatorTag {};
@@ -29,7 +29,7 @@ struct VariantOperators : VariantOperatorTag {
template <typename T>
friend
typename enable_if<!IsVariant<T>::value && !is_array<T>::value, T>::type
operator|(const TVariant &variant, const T &defaultValue) {
operator|(const TVariant& variant, const T& defaultValue) {
if (variant.template is<T>())
return variant.template as<T>();
else
@@ -37,10 +37,10 @@ struct VariantOperators : VariantOperatorTag {
}
//
// const char* operator|(JsonVariant, const char*)
friend const char *operator|(const TVariant &variant,
const char *defaultValue) {
if (variant.template is<const char *>())
return variant.template as<const char *>();
friend const char* operator|(const TVariant& variant,
const char* defaultValue) {
if (variant.template is<const char*>())
return variant.template as<const char*>();
else
return defaultValue;
}
@@ -48,7 +48,7 @@ struct VariantOperators : VariantOperatorTag {
// JsonVariant operator|(JsonVariant, JsonVariant)
template <typename T>
friend typename enable_if<IsVariant<T>::value, VariantConstRef>::type
operator|(const TVariant &variant, T defaultValue) {
operator|(const TVariant& variant, T defaultValue) {
if (variant)
return variant;
else
@@ -57,133 +57,133 @@ struct VariantOperators : VariantOperatorTag {
// value == TVariant
template <typename T>
friend bool operator==(T *lhs, TVariant rhs) {
friend bool operator==(T* lhs, 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, TVariant rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
}
// TVariant == value
template <typename T>
friend bool operator==(TVariant lhs, T *rhs) {
friend bool operator==(TVariant lhs, T* rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
}
template <typename T>
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator==(TVariant lhs, const T &rhs) {
operator==(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, 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, TVariant rhs) {
return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
}
// TVariant != value
template <typename T>
friend bool operator!=(TVariant lhs, T *rhs) {
friend bool operator!=(TVariant lhs, T* rhs) {
return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
}
template <typename T>
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator!=(TVariant lhs, const T &rhs) {
operator!=(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, 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, TVariant rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
}
// TVariant < value
template <typename T>
friend bool operator<(TVariant lhs, T *rhs) {
friend bool operator<(TVariant lhs, T* rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_LESS;
}
template <typename T>
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator<(TVariant lhs, const T &rhs) {
operator<(TVariant lhs, const T& rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_LESS;
}
// value <= TVariant
template <typename T>
friend bool operator<=(T *lhs, TVariant rhs) {
friend bool operator<=(T* lhs, 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, 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<=(TVariant lhs, T* rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
}
template <typename T>
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator<=(TVariant lhs, const T &rhs) {
operator<=(TVariant lhs, const T& rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
}
// value > TVariant
template <typename T>
friend bool operator>(T *lhs, TVariant rhs) {
friend bool operator>(T* lhs, 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, TVariant rhs) {
return compare(rhs, lhs) == COMPARE_RESULT_LESS;
}
// TVariant > value
template <typename T>
friend bool operator>(TVariant lhs, T *rhs) {
friend bool operator>(TVariant lhs, T* rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
}
template <typename T>
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator>(TVariant lhs, const T &rhs) {
operator>(TVariant lhs, const T& rhs) {
return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
}
// value >= TVariant
template <typename T>
friend bool operator>=(T *lhs, TVariant rhs) {
friend bool operator>=(T* lhs, 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, 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>=(TVariant lhs, T* rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
template <typename T>
friend
typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
operator>=(TVariant lhs, const T &rhs) {
operator>=(TVariant lhs, const T& rhs) {
return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
}
};

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

@@ -49,8 +49,8 @@ class VariantRefBase : public VariantTag {
}
protected:
VariantRefBase(TData *data) : _data(data) {}
TData *_data;
VariantRefBase(TData* data) : _data(data) {}
TData* _data;
};
class VariantConstRef : public VariantRefBase<const VariantData>,
@@ -62,21 +62,21 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
public:
VariantConstRef() : base_type(0) {}
explicit VariantConstRef(const VariantData *data) : base_type(data) {}
explicit VariantConstRef(const VariantData* data) : base_type(data) {}
template <typename T>
FORCE_INLINE
typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
T>::type
as() const {
return Converter<T>::fromJson(*this);
}
template <typename T>
FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
as() const {
return as<const char *>();
return as<const char*>();
}
template <typename T>
@@ -89,17 +89,17 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
template <typename T>
FORCE_INLINE
typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
bool>::type
is() const {
return Converter<T>::checkJson(*this);
}
template <typename T>
FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type
FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
is() const {
return is<const char *>();
return is<const char*>();
}
template <typename T>
@@ -124,7 +124,7 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
template <typename TString>
FORCE_INLINE
typename enable_if<IsString<TString>::value, VariantConstRef>::type
operator[](const TString &key) const {
operator[](const TString& key) const {
return VariantConstRef(variantGetMember(_data, adaptString(key)));
}
@@ -133,13 +133,13 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
// operator[](const __FlashStringHelper*) const
template <typename TChar>
FORCE_INLINE
typename enable_if<IsString<TChar *>::value, VariantConstRef>::type
operator[](TChar *key) const {
typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
operator[](TChar* key) const {
return VariantConstRef(variantGetMember(_data, adaptString(key)));
}
protected:
const VariantData *getData() const {
const VariantData* getData() const {
return _data;
}
};
@@ -158,7 +158,7 @@ class VariantRef : public VariantRefBase<VariantData>,
public:
// Intenal use only
FORCE_INLINE VariantRef(MemoryPool *pool, VariantData *data)
FORCE_INLINE VariantRef(MemoryPool* pool, VariantData* data)
: base_type(data), _pool(pool) {}
// Creates an uninitialized VariantRef
@@ -169,7 +169,7 @@ class VariantRef : public VariantRefBase<VariantData>,
}
template <typename T>
FORCE_INLINE bool set(const T &value) const {
FORCE_INLINE bool set(const T& value) const {
Converter<T>::toJson(value, *this);
return _pool && !_pool->overflowed();
}
@@ -179,24 +179,24 @@ class VariantRef : public VariantRefBase<VariantData>,
set(char value) const;
template <typename T>
FORCE_INLINE bool set(T *value) const {
Converter<T *>::toJson(value, *this);
FORCE_INLINE bool set(T* value) const {
Converter<T*>::toJson(value, *this);
return _pool && !_pool->overflowed();
}
template <typename T>
FORCE_INLINE
typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
T>::type
as() const {
return Converter<T>::fromJson(*this);
}
template <typename T>
FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
as() const {
return as<const char *>();
return as<const char*>();
}
template <typename T>
@@ -209,17 +209,17 @@ class VariantRef : public VariantRefBase<VariantData>,
template <typename T>
FORCE_INLINE
typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
bool>::type
is() const {
return Converter<T>::checkJson(*this);
}
template <typename T>
FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type
FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
is() const {
return is<const char *>();
return is<const char*>();
}
template <typename T>
@@ -268,8 +268,8 @@ class VariantRef : public VariantRefBase<VariantData>,
// remove(const char*) const
// remove(const __FlashStringHelper*) const
template <typename TChar>
FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
TChar *key) const {
FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
TChar* key) const {
if (_data)
_data->remove(adaptString(key));
}
@@ -277,7 +277,7 @@ class VariantRef : public VariantRefBase<VariantData>,
// remove(const String&) const
template <typename TString>
FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
const TString &key) const {
const TString& key) const {
if (_data)
_data->remove(adaptString(key));
}
@@ -285,27 +285,27 @@ class VariantRef : public VariantRefBase<VariantData>,
inline void shallowCopy(VariantConstRef target) {
if (!_data)
return;
const VariantData *targetData = VariantAttorney::getData(target);
const VariantData* targetData = VariantAttorney::getData(target);
if (targetData)
*_data = *targetData;
else
_data->setNull();
}
MemoryPool *getPool() const {
MemoryPool* getPool() const {
return _pool;
}
VariantData *getData() const {
VariantData* getData() const {
return _data;
}
VariantData *getOrCreateData() const {
VariantData* getOrCreateData() const {
return _data;
}
private:
MemoryPool *_pool;
MemoryPool* _pool;
};
template <>
@@ -322,7 +322,7 @@ struct Converter<VariantRef> : private VariantAttorney {
VariantConstRef);
static bool checkJson(VariantRef src) {
VariantData *data = getData(src);
VariantData* data = getData(src);
return !!data;
}
@@ -342,7 +342,7 @@ struct Converter<VariantConstRef> : private VariantAttorney {
}
static bool checkJson(VariantConstRef src) {
const VariantData *data = getData(src);
const VariantData* data = getData(src);
return !!data;
}
};

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

@@ -14,7 +14,7 @@ template <typename TResult>
struct Visitor {
typedef TResult result_type;
TResult visitArray(const CollectionData &) {
TResult visitArray(const CollectionData&) {
return TResult();
}
@@ -34,7 +34,7 @@ struct Visitor {
return TResult();
}
TResult visitObject(const CollectionData &) {
TResult visitObject(const CollectionData&) {
return TResult();
}
@@ -42,11 +42,11 @@ struct Visitor {
return TResult();
}
TResult visitRawJson(const char *, size_t) {
TResult visitRawJson(const char*, size_t) {
return TResult();
}
TResult visitString(const char *, size_t) {
TResult visitString(const char*, size_t) {
return TResult();
}
};