diff --git a/src/ArduinoJson.hpp b/src/ArduinoJson.hpp index 3d91bd86..07c1565a 100644 --- a/src/ArduinoJson.hpp +++ b/src/ArduinoJson.hpp @@ -6,19 +6,19 @@ #include "ArduinoJson/Namespace.hpp" -#include "ArduinoJson/JsonArray.hpp" -#include "ArduinoJson/JsonObject.hpp" -#include "ArduinoJson/JsonVariant.hpp" +#include "ArduinoJson/Array/ArrayRef.hpp" +#include "ArduinoJson/Object/ObjectRef.hpp" +#include "ArduinoJson/Variant/VariantRef.hpp" -#include "ArduinoJson/DynamicJsonDocument.hpp" -#include "ArduinoJson/StaticJsonDocument.hpp" +#include "ArduinoJson/Document/DynamicJsonDocument.hpp" +#include "ArduinoJson/Document/StaticJsonDocument.hpp" -#include "ArduinoJson/Data/VariantAsImpl.hpp" -#include "ArduinoJson/JsonArrayImpl.hpp" -#include "ArduinoJson/JsonArraySubscript.hpp" -#include "ArduinoJson/JsonObjectImpl.hpp" -#include "ArduinoJson/JsonObjectSubscript.hpp" -#include "ArduinoJson/JsonVariantImpl.hpp" +#include "ArduinoJson/Array/ArrayImpl.hpp" +#include "ArduinoJson/Array/ArraySubscript.hpp" +#include "ArduinoJson/Object/ObjectImpl.hpp" +#include "ArduinoJson/Object/ObjectSubscript.hpp" +#include "ArduinoJson/Variant/VariantAsImpl.hpp" +#include "ArduinoJson/Variant/VariantImpl.hpp" #include "ArduinoJson/Json/JsonDeserializer.hpp" #include "ArduinoJson/Json/JsonSerializer.hpp" @@ -27,19 +27,19 @@ #include "ArduinoJson/MsgPack/MsgPackSerializer.hpp" namespace ArduinoJson { +typedef ARDUINOJSON_NAMESPACE::ArrayRef JsonArray; +typedef ARDUINOJSON_NAMESPACE::ArrayConstRef JsonArrayConst; +typedef ARDUINOJSON_NAMESPACE::Float JsonFloat; +typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger; +typedef ARDUINOJSON_NAMESPACE::ObjectRef JsonObject; +typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst; +typedef ARDUINOJSON_NAMESPACE::Pair JsonPair; +typedef ARDUINOJSON_NAMESPACE::UInt JsonUInt; +typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant; +typedef ARDUINOJSON_NAMESPACE::VariantConstRef JsonVariantConst; using ARDUINOJSON_NAMESPACE::DeserializationError; using ARDUINOJSON_NAMESPACE::DynamicJsonDocument; -using ARDUINOJSON_NAMESPACE::JsonArray; -using ARDUINOJSON_NAMESPACE::JsonArrayConst; -using ARDUINOJSON_NAMESPACE::JsonFloat; -using ARDUINOJSON_NAMESPACE::JsonInteger; -using ARDUINOJSON_NAMESPACE::JsonKey; -using ARDUINOJSON_NAMESPACE::JsonObject; -using ARDUINOJSON_NAMESPACE::JsonObjectConst; -using ARDUINOJSON_NAMESPACE::JsonPair; -using ARDUINOJSON_NAMESPACE::JsonUInt; -using ARDUINOJSON_NAMESPACE::JsonVariant; -using ARDUINOJSON_NAMESPACE::JsonVariantConst; +using ARDUINOJSON_NAMESPACE::Key; using ARDUINOJSON_NAMESPACE::serialized; using ARDUINOJSON_NAMESPACE::StaticJsonDocument; } // namespace ArduinoJson diff --git a/src/ArduinoJson/Data/ArrayFunctions.hpp b/src/ArduinoJson/Array/ArrayFunctions.hpp similarity index 65% rename from src/ArduinoJson/Data/ArrayFunctions.hpp rename to src/ArduinoJson/Array/ArrayFunctions.hpp index 77789c6b..266da3fe 100644 --- a/src/ArduinoJson/Data/ArrayFunctions.hpp +++ b/src/ArduinoJson/Array/ArrayFunctions.hpp @@ -4,12 +4,12 @@ #pragma once -#include "JsonVariantData.hpp" -#include "SlotFunctions.hpp" +#include "../Variant/SlotFunctions.hpp" +#include "../Variant/VariantData.hpp" namespace ARDUINOJSON_NAMESPACE { -inline JsonVariantData* arrayAdd(JsonArrayData* arr, MemoryPool* pool) { +inline VariantData* arrayAdd(ArrayData* arr, MemoryPool* pool) { if (!arr) return 0; VariantSlot* slot = pool->allocVariant(); @@ -31,17 +31,17 @@ inline JsonVariantData* arrayAdd(JsonArrayData* arr, MemoryPool* pool) { return &slot->value; } -inline VariantSlot* arrayGetSlot(const JsonArrayData* arr, size_t index) { +inline VariantSlot* arrayGetSlot(const ArrayData* arr, size_t index) { if (!arr) return 0; return arr->head->getNext(index); } -inline JsonVariantData* arrayGet(const JsonArrayData* arr, size_t index) { +inline VariantData* arrayGet(const ArrayData* arr, size_t index) { VariantSlot* slot = arrayGetSlot(arr, index); return slot ? &slot->value : 0; } -inline void arrayRemove(JsonArrayData* arr, VariantSlot* slot) { +inline void arrayRemove(ArrayData* arr, VariantSlot* slot) { if (!arr || !slot) return; if (slot->prev) @@ -54,20 +54,19 @@ inline void arrayRemove(JsonArrayData* arr, VariantSlot* slot) { arr->tail = slot->getPrev(); } -inline void arrayRemove(JsonArrayData* arr, size_t index) { +inline void arrayRemove(ArrayData* arr, size_t index) { arrayRemove(arr, arrayGetSlot(arr, index)); } -inline void arrayClear(JsonArrayData* arr) { +inline void arrayClear(ArrayData* arr) { if (!arr) return; arr->head = 0; arr->tail = 0; } -bool variantCopy(JsonVariantData*, const JsonVariantData*, MemoryPool*); +bool variantCopy(VariantData*, const VariantData*, MemoryPool*); -inline bool arrayCopy(JsonArrayData* dst, const JsonArrayData* src, - MemoryPool* pool) { +inline bool arrayCopy(ArrayData* dst, const ArrayData* src, MemoryPool* pool) { if (!dst || !src) return false; arrayClear(dst); for (VariantSlot* s = src->head; s; s = s->getNext()) { @@ -76,9 +75,9 @@ inline bool arrayCopy(JsonArrayData* dst, const JsonArrayData* src, return true; } -bool variantEquals(const JsonVariantData*, const JsonVariantData*); +bool variantEquals(const VariantData*, const VariantData*); -inline bool arrayEquals(const JsonArrayData* a1, const JsonArrayData* a2) { +inline bool arrayEquals(const ArrayData* a1, const ArrayData* a2) { if (a1 == a2) return true; if (!a1 || !a2) return false; VariantSlot* s1 = a1->head; @@ -92,7 +91,7 @@ inline bool arrayEquals(const JsonArrayData* a1, const JsonArrayData* a2) { } } -inline size_t arraySize(const JsonArrayData* arr) { +inline size_t arraySize(const ArrayData* arr) { if (!arr) return 0; return slotSize(arr->head); } diff --git a/src/ArduinoJson/Array/ArrayImpl.hpp b/src/ArduinoJson/Array/ArrayImpl.hpp new file mode 100644 index 00000000..c4fab360 --- /dev/null +++ b/src/ArduinoJson/Array/ArrayImpl.hpp @@ -0,0 +1,19 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "../Object/ObjectRef.hpp" +#include "ArrayRef.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +inline ArrayRef ArrayRef::createNestedArray() const { + return add().to(); +} + +inline ObjectRef ArrayRef::createNestedObject() const { + return add().to(); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Array/ArrayIterator.hpp b/src/ArduinoJson/Array/ArrayIterator.hpp new file mode 100644 index 00000000..e91e25c2 --- /dev/null +++ b/src/ArduinoJson/Array/ArrayIterator.hpp @@ -0,0 +1,122 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "../Variant/SlotFunctions.hpp" +#include "../Variant/VariantRef.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +class VariantPtr { + public: + VariantPtr(MemoryPool *memoryPool, VariantData *data) + : _variant(memoryPool, data) {} + + VariantRef *operator->() { + return &_variant; + } + + VariantRef &operator*() { + return _variant; + } + + private: + VariantRef _variant; +}; + +class ArrayIterator { + public: + ArrayIterator() : _slot(0) {} + explicit ArrayIterator(MemoryPool *memoryPool, VariantSlot *slot) + : _memoryPool(memoryPool), _slot(slot) {} + + VariantRef operator*() const { + return VariantRef(_memoryPool, &_slot->value); + } + VariantPtr operator->() { + return VariantPtr(_memoryPool, &_slot->value); + } + + bool operator==(const ArrayIterator &other) const { + return _slot == other._slot; + } + + bool operator!=(const ArrayIterator &other) const { + return _slot != other._slot; + } + + ArrayIterator &operator++() { + _slot = _slot->getNext(); + return *this; + } + + ArrayIterator &operator+=(size_t distance) { + _slot = _slot->getNext(distance); + return *this; + } + + VariantSlot *internal() { + return _slot; + } + + private: + MemoryPool *_memoryPool; + VariantSlot *_slot; +}; + +class VariantConstPtr { + public: + VariantConstPtr(const VariantData *data) : _variant(data) {} + + VariantConstRef *operator->() { + return &_variant; + } + + VariantConstRef &operator*() { + return _variant; + } + + private: + VariantConstRef _variant; +}; + +class ArrayConstRefIterator { + public: + ArrayConstRefIterator() : _slot(0) {} + explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {} + + VariantConstRef operator*() const { + return VariantConstRef(&_slot->value); + } + VariantConstPtr operator->() { + return VariantConstPtr(&_slot->value); + } + + bool operator==(const ArrayConstRefIterator &other) const { + return _slot == other._slot; + } + + bool operator!=(const ArrayConstRefIterator &other) const { + return _slot != other._slot; + } + + ArrayConstRefIterator &operator++() { + _slot = _slot->getNext(); + return *this; + } + + ArrayConstRefIterator &operator+=(size_t distance) { + _slot = _slot->getNext(distance); + return *this; + } + + const VariantSlot *internal() { + return _slot; + } + + private: + const VariantSlot *_slot; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonArray.hpp b/src/ArduinoJson/Array/ArrayRef.hpp similarity index 64% rename from src/ArduinoJson/JsonArray.hpp rename to src/ArduinoJson/Array/ArrayRef.hpp index 55617786..2fc6695c 100644 --- a/src/ArduinoJson/JsonArray.hpp +++ b/src/ArduinoJson/Array/ArrayRef.hpp @@ -4,9 +4,9 @@ #pragma once -#include "Data/ArrayFunctions.hpp" -#include "Data/JsonVariantData.hpp" -#include "JsonArrayIterator.hpp" +#include "../Variant/VariantData.hpp" +#include "ArrayFunctions.hpp" +#include "ArrayIterator.hpp" // Returns the size (in bytes) of an array with n elements. // Can be very handy to determine the size of a StaticMemoryPool. @@ -15,18 +15,18 @@ namespace ARDUINOJSON_NAMESPACE { -class JsonObject; -class JsonArraySubscript; +class ObjectRef; +class ArraySubscript; template -class JsonArrayProxy { +class ArrayRefBase { public: FORCE_INLINE bool isNull() const { return _data == 0; } - FORCE_INLINE JsonVariantConst operator[](size_t index) const { - return JsonVariantConst(arrayGet(_data, index)); + FORCE_INLINE VariantConstRef operator[](size_t index) const { + return VariantConstRef(arrayGet(_data, index)); } FORCE_INLINE size_t size() const { @@ -34,17 +34,16 @@ class JsonArrayProxy { } protected: - JsonArrayProxy(TData* data) : _data(data) {} + ArrayRefBase(TData* data) : _data(data) {} TData* _data; }; -class JsonArrayConst : public JsonArrayProxy, - public Visitable { - friend class JsonArray; - typedef JsonArrayProxy proxy_type; +class ArrayConstRef : public ArrayRefBase, public Visitable { + friend class ArrayRef; + typedef ArrayRefBase base_type; public: - typedef JsonArrayConstIterator iterator; + typedef ArrayConstRefIterator iterator; template FORCE_INLINE void accept(Visitor& visitor) const { @@ -63,43 +62,43 @@ class JsonArrayConst : public JsonArrayProxy, return iterator(); } - FORCE_INLINE JsonArrayConst() : proxy_type(0) {} - FORCE_INLINE JsonArrayConst(const JsonArrayData* data) : proxy_type(data) {} + FORCE_INLINE ArrayConstRef() : base_type(0) {} + FORCE_INLINE ArrayConstRef(const ArrayData* data) : base_type(data) {} - FORCE_INLINE bool operator==(JsonArrayConst rhs) const { + FORCE_INLINE bool operator==(ArrayConstRef rhs) const { return arrayEquals(_data, rhs._data); } }; -class JsonArray : public JsonArrayProxy, public Visitable { - typedef JsonArrayProxy proxy_type; +class ArrayRef : public ArrayRefBase, public Visitable { + typedef ArrayRefBase base_type; public: - typedef JsonArrayIterator iterator; + typedef ArrayIterator iterator; - FORCE_INLINE JsonArray() : proxy_type(0), _memoryPool(0) {} - FORCE_INLINE JsonArray(MemoryPool* pool, JsonArrayData* data) - : proxy_type(data), _memoryPool(pool) {} + FORCE_INLINE ArrayRef() : base_type(0), _memoryPool(0) {} + FORCE_INLINE ArrayRef(MemoryPool* pool, ArrayData* data) + : base_type(data), _memoryPool(pool) {} - operator JsonVariant() { - return JsonVariant(_memoryPool, getVariantData(_data)); + operator VariantRef() { + return VariantRef(_memoryPool, getVariantData(_data)); } - operator JsonArrayConst() const { - return JsonArrayConst(_data); + operator ArrayConstRef() const { + return ArrayConstRef(_data); } // Adds the specified value at the end of the array. // // bool add(TValue); - // TValue = bool, long, int, short, float, double, serialized, JsonVariant, - // std::string, String, JsonObject + // TValue = bool, long, int, short, float, double, serialized, VariantRef, + // std::string, String, ObjectRef template FORCE_INLINE bool add(const T& value) const { return add().set(value); } // Adds the specified value at the end of the array. - FORCE_INLINE bool add(JsonArray value) const { + FORCE_INLINE bool add(ArrayRef value) const { return add().set(value); } // @@ -110,8 +109,8 @@ class JsonArray : public JsonArrayProxy, public Visitable { return add().set(value); } - JsonVariant add() const { - return JsonVariant(_memoryPool, arrayAdd(_data, _memoryPool)); + VariantRef add() const { + return VariantRef(_memoryPool, arrayAdd(_data, _memoryPool)); } FORCE_INLINE iterator begin() const { @@ -144,7 +143,7 @@ class JsonArray : public JsonArrayProxy, public Visitable { bool copyFrom(T (&array)[N1][N2]) const { bool ok = true; for (size_t i = 0; i < N1; i++) { - JsonArray nestedArray = createNestedArray(); + ArrayRef nestedArray = createNestedArray(); for (size_t j = 0; j < N2; j++) { ok &= nestedArray.add(array[i][j]); } @@ -152,8 +151,8 @@ class JsonArray : public JsonArrayProxy, public Visitable { return ok; } - // Copy a JsonArray - FORCE_INLINE bool copyFrom(JsonArray src) const { + // Copy a ArrayRef + FORCE_INLINE bool copyFrom(ArrayRef src) const { return arrayCopy(_data, src._data, _memoryPool); } @@ -177,22 +176,22 @@ class JsonArray : public JsonArrayProxy, public Visitable { if (!_data) return; size_t i = 0; for (iterator it = begin(); it != end() && i < N1; ++it) { - it->as().copyTo(array[i++]); + it->as().copyTo(array[i++]); } } - FORCE_INLINE JsonArray createNestedArray() const; - FORCE_INLINE JsonObject createNestedObject() const; + FORCE_INLINE ArrayRef createNestedArray() const; + FORCE_INLINE ObjectRef createNestedObject() const; - FORCE_INLINE JsonArraySubscript operator[](size_t index) const; + FORCE_INLINE ArraySubscript operator[](size_t index) const; - FORCE_INLINE bool operator==(JsonArray rhs) const { + FORCE_INLINE bool operator==(ArrayRef rhs) const { return arrayEquals(_data, rhs._data); } // Gets the value at the specified index. - FORCE_INLINE JsonVariant get(size_t index) const { - return JsonVariant(_memoryPool, arrayGet(_data, index)); + FORCE_INLINE VariantRef get(size_t index) const { + return VariantRef(_memoryPool, arrayGet(_data, index)); } // Removes element at specified position. @@ -207,7 +206,7 @@ class JsonArray : public JsonArrayProxy, public Visitable { template FORCE_INLINE void accept(Visitor& visitor) const { - JsonArrayConst(_data).accept(visitor); + ArrayConstRef(_data).accept(visitor); } private: diff --git a/src/ArduinoJson/JsonArraySubscript.hpp b/src/ArduinoJson/Array/ArraySubscript.hpp similarity index 62% rename from src/ArduinoJson/JsonArraySubscript.hpp rename to src/ArduinoJson/Array/ArraySubscript.hpp index acfa1cdf..8fe71f78 100644 --- a/src/ArduinoJson/JsonArraySubscript.hpp +++ b/src/ArduinoJson/Array/ArraySubscript.hpp @@ -4,8 +4,8 @@ #pragma once -#include "Configuration.hpp" -#include "JsonVariantBase.hpp" +#include "../Configuration.hpp" +#include "../Operators/VariantOperators.hpp" #ifdef _MSC_VER #pragma warning(push) @@ -13,24 +13,24 @@ #endif namespace ARDUINOJSON_NAMESPACE { -class JsonArraySubscript : public JsonVariantBase, - public Visitable { +class ArraySubscript : public VariantOperators, + public Visitable { public: - FORCE_INLINE JsonArraySubscript(JsonArray array, size_t index) + FORCE_INLINE ArraySubscript(ArrayRef array, size_t index) : _array(array), _index(index) {} - FORCE_INLINE JsonArraySubscript& operator=(const JsonArraySubscript& src) { - get_impl().set(src.as()); + FORCE_INLINE ArraySubscript& operator=(const ArraySubscript& src) { + get_impl().set(src.as()); return *this; } // Replaces the value // // operator=(const TValue&) - // TValue = bool, long, int, short, float, double, serialized, JsonVariant, - // std::string, String, JsonArray, JsonObject + // TValue = bool, long, int, short, float, double, serialized, VariantRef, + // std::string, String, ArrayRef, ObjectRef template - FORCE_INLINE JsonArraySubscript& operator=(const T& src) { + FORCE_INLINE ArraySubscript& operator=(const T& src) { get_impl().set(src); return *this; } @@ -38,7 +38,7 @@ class JsonArraySubscript : public JsonVariantBase, // operator=(TValue) // TValue = char*, const char*, const FlashStringHelper* template - FORCE_INLINE JsonArraySubscript& operator=(T* src) { + FORCE_INLINE ArraySubscript& operator=(T* src) { get_impl().set(src); return *this; } @@ -48,7 +48,7 @@ class JsonArraySubscript : public JsonVariantBase, } template - FORCE_INLINE typename JsonVariantAs::type as() const { + FORCE_INLINE typename VariantAs::type as() const { return get_impl().as(); } @@ -58,15 +58,15 @@ class JsonArraySubscript : public JsonVariantBase, } template - FORCE_INLINE typename JsonVariantTo::type to() const { + FORCE_INLINE typename VariantTo::type to() const { return get_impl().to(); } // Replaces the value // // bool set(const TValue&) - // TValue = bool, long, int, short, float, double, serialized, JsonVariant, - // std::string, String, JsonArray, JsonObject + // TValue = bool, long, int, short, float, double, serialized, VariantRef, + // std::string, String, ArrayRef, ObjectRef template FORCE_INLINE bool set(const TValue& value) const { return get_impl().set(value); @@ -89,22 +89,21 @@ class JsonArraySubscript : public JsonVariantBase, } private: - FORCE_INLINE JsonVariant get_impl() const { + FORCE_INLINE VariantRef get_impl() const { return _array.get(_index); } - JsonArray _array; + ArrayRef _array; const size_t _index; }; template -inline JsonArraySubscript JsonVariantSubscripts::operator[]( - size_t index) const { - return impl()->template as()[index]; +inline ArraySubscript VariantSubscripts::operator[](size_t index) const { + return impl()->template as()[index]; } -inline JsonArraySubscript JsonArray::operator[](size_t index) const { - return JsonArraySubscript(*this, index); +inline ArraySubscript ArrayRef::operator[](size_t index) const { + return ArraySubscript(*this, index); } } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Data/JsonVariantAs.hpp b/src/ArduinoJson/Data/JsonVariantAs.hpp deleted file mode 100644 index 2d0738da..00000000 --- a/src/ArduinoJson/Data/JsonVariantAs.hpp +++ /dev/null @@ -1,49 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -namespace ARDUINOJSON_NAMESPACE { - -class JsonArray; -class JsonArrayConst; -class JsonObject; -class JsonObjectConst; -class JsonVariant; -class JsonVariantConst; - -// A metafunction that returns the type of the value returned by -// JsonVariant::as() -template -struct JsonVariantAs { - typedef T type; -}; - -template <> -struct JsonVariantAs { - typedef const char* type; -}; - -// A metafunction that returns the type of the value returned by -// JsonVariant::as() -template -struct JsonVariantConstAs { - typedef typename JsonVariantAs::type type; -}; - -template <> -struct JsonVariantConstAs { - typedef JsonVariantConst type; -}; - -template <> -struct JsonVariantConstAs { - typedef JsonObjectConst type; -}; - -template <> -struct JsonVariantConstAs { - typedef JsonArrayConst type; -}; -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Data/JsonVariantData.hpp b/src/ArduinoJson/Data/JsonVariantData.hpp deleted file mode 100644 index 757b743b..00000000 --- a/src/ArduinoJson/Data/JsonVariantData.hpp +++ /dev/null @@ -1,79 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include // ptrdiff_t, size_t - -#include "JsonFloat.hpp" -#include "JsonInteger.hpp" - -namespace ARDUINOJSON_NAMESPACE { - -enum JsonVariantType { - JSON_NULL, - JSON_LINKED_RAW, - JSON_OWNED_RAW, - JSON_LINKED_STRING, - JSON_OWNED_STRING, - JSON_BOOLEAN, - JSON_POSITIVE_INTEGER, - JSON_NEGATIVE_INTEGER, - JSON_ARRAY, - JSON_OBJECT, - JSON_FLOAT -}; - -struct JsonObjectData { - struct VariantSlot *head; - struct VariantSlot *tail; -}; - -struct JsonArrayData { - struct VariantSlot *head; - struct VariantSlot *tail; -}; - -struct RawData { - const char *data; - size_t size; -}; - -// A union that defines the actual content of a JsonVariantData. -// The enum JsonVariantType determines which member is in use. -union JsonVariantContent { - JsonFloat asFloat; - JsonUInt asInteger; - JsonArrayData asArray; - JsonObjectData asObject; - const char *asString; - struct { - const char *data; - size_t size; - } asRaw; -}; - -// this struct must be a POD type to prevent error calling offsetof on clang -struct JsonVariantData { - bool keyIsOwned : 1; - JsonVariantType type : 7; - JsonVariantContent content; -}; - -inline JsonVariantData *getVariantData(JsonArrayData *arr) { - const ptrdiff_t offset = offsetof(JsonVariantData, content) - - offsetof(JsonVariantContent, asArray); - if (!arr) return 0; - return reinterpret_cast(reinterpret_cast(arr) - - offset); -} - -inline JsonVariantData *getVariantData(JsonObjectData *obj) { - const ptrdiff_t offset = offsetof(JsonVariantData, content) - - offsetof(JsonVariantContent, asObject); - if (!obj) return 0; - return reinterpret_cast(reinterpret_cast(obj) - - offset); -} -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Data/VariantAs.hpp b/src/ArduinoJson/Data/VariantAs.hpp deleted file mode 100644 index 9f3de6ee..00000000 --- a/src/ArduinoJson/Data/VariantAs.hpp +++ /dev/null @@ -1,48 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "../Serialization/DynamicStringWriter.hpp" -#include "VariantFunctions.hpp" - -namespace ARDUINOJSON_NAMESPACE { - -class JsonVariantConst; - -template -inline typename enable_if::value, T>::type variantAs( - const JsonVariantData* _data) { - return variantAsIntegral(_data); -} - -template -inline typename enable_if::value, T>::type variantAs( - const JsonVariantData* _data) { - return variantAsBoolean(_data); -} - -template -inline typename enable_if::value, T>::type variantAs( - const JsonVariantData* _data) { - return variantAsFloat(_data); -} - -template -inline typename enable_if::value || - is_same::value, - const char*>::type -variantAs(const JsonVariantData* _data) { - return variantAsString(_data); -} - -template -inline typename enable_if::value, T>::type -variantAs(const JsonVariantData* _data); - -template -inline typename enable_if::value, T>::type variantAs( - const JsonVariantData* _data); - -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Deserialization/deserialize.hpp b/src/ArduinoJson/Deserialization/deserialize.hpp index fedea7f4..d2d16da5 100644 --- a/src/ArduinoJson/Deserialization/deserialize.hpp +++ b/src/ArduinoJson/Deserialization/deserialize.hpp @@ -33,7 +33,7 @@ deserialize(TDocument &doc, const TString &input) { return makeDeserializer( doc.memoryPool(), makeReader(input), makeStringStorage(doc.memoryPool(), input), doc.nestingLimit) - .parse(doc.template to()); + .parse(doc.template to()); } // // DeserializationError deserialize(TDocument& doc, TChar* input); @@ -45,7 +45,7 @@ DeserializationError deserialize(TDocument &doc, TChar *input) { return makeDeserializer( doc.memoryPool(), makeReader(input), makeStringStorage(doc.memoryPool(), input), doc.nestingLimit) - .parse(doc.template to()); + .parse(doc.template to()); } // // DeserializationError deserialize(TDocument& doc, TChar* input, size_t @@ -59,7 +59,7 @@ DeserializationError deserialize(TDocument &doc, TChar *input, return makeDeserializer( doc.memoryPool(), makeReader(input, inputSize), makeStringStorage(doc.memoryPool(), input), doc.nestingLimit) - .parse(doc.template to()); + .parse(doc.template to()); } // // DeserializationError deserialize(TDocument& doc, TStream input); @@ -71,6 +71,6 @@ DeserializationError deserialize(TDocument &doc, TStream &input) { return makeDeserializer( doc.memoryPool(), makeReader(input), makeStringStorage(doc.memoryPool(), input), doc.nestingLimit) - .parse(doc.template to()); + .parse(doc.template to()); } } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/DynamicJsonDocument.hpp b/src/ArduinoJson/Document/DynamicJsonDocument.hpp similarity index 100% rename from src/ArduinoJson/DynamicJsonDocument.hpp rename to src/ArduinoJson/Document/DynamicJsonDocument.hpp diff --git a/src/ArduinoJson/JsonDocument.hpp b/src/ArduinoJson/Document/JsonDocument.hpp similarity index 72% rename from src/ArduinoJson/JsonDocument.hpp rename to src/ArduinoJson/Document/JsonDocument.hpp index db2f6610..8e003156 100644 --- a/src/ArduinoJson/JsonDocument.hpp +++ b/src/ArduinoJson/Document/JsonDocument.hpp @@ -4,9 +4,9 @@ #pragma once -#include "Data/JsonVariantTo.hpp" -#include "JsonVariant.hpp" -#include "Memory/MemoryPool.hpp" +#include "../Memory/MemoryPool.hpp" +#include "../Variant/VariantRef.hpp" +#include "../Variant/VariantTo.hpp" namespace ARDUINOJSON_NAMESPACE { @@ -20,12 +20,12 @@ class JsonDocument : public Visitable { } template - typename JsonVariantAs::type as() { + typename VariantAs::type as() { return getVariant().template as(); } template - typename JsonVariantConstAs::type as() const { + typename VariantConstAs::type as() const { return getVariant().template as(); } @@ -53,7 +53,7 @@ class JsonDocument : public Visitable { } template - typename JsonVariantTo::type to() { + typename VariantTo::type to() { clear(); return getVariant().template to(); } @@ -65,20 +65,20 @@ class JsonDocument : public Visitable { void copy(const JsonDocument& src) { nestingLimit = src.nestingLimit; - to().set(src.as()); + to().set(src.as()); } private: - JsonVariant getVariant() { - return JsonVariant(&_memoryPool, &_rootData); + VariantRef getVariant() { + return VariantRef(&_memoryPool, &_rootData); } - JsonVariantConst getVariant() const { - return JsonVariantConst(&_rootData); + VariantConstRef getVariant() const { + return VariantConstRef(&_rootData); } MemoryPool _memoryPool; - JsonVariantData _rootData; + VariantData _rootData; }; } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/StaticJsonDocument.hpp b/src/ArduinoJson/Document/StaticJsonDocument.hpp similarity index 100% rename from src/ArduinoJson/StaticJsonDocument.hpp rename to src/ArduinoJson/Document/StaticJsonDocument.hpp diff --git a/src/ArduinoJson/Json/JsonDeserializer.hpp b/src/ArduinoJson/Json/JsonDeserializer.hpp index d11bc162..a1d14956 100644 --- a/src/ArduinoJson/Json/JsonDeserializer.hpp +++ b/src/ArduinoJson/Json/JsonDeserializer.hpp @@ -5,12 +5,12 @@ #pragma once #include "../Deserialization/deserialize.hpp" -#include "../JsonVariant.hpp" #include "../Memory/MemoryPool.hpp" #include "../Numbers/isFloat.hpp" #include "../Numbers/isInteger.hpp" #include "../Polyfills/type_traits.hpp" -#include "./EscapeSequence.hpp" +#include "../Variant/VariantRef.hpp" +#include "EscapeSequence.hpp" namespace ARDUINOJSON_NAMESPACE { @@ -28,7 +28,7 @@ class JsonDeserializer { _stringStorage(stringStorage), _nestingLimit(nestingLimit), _loaded(false) {} - DeserializationError parse(JsonVariant variant) { + DeserializationError parse(VariantRef variant) { DeserializationError err = skipSpacesAndComments(); if (err) return err; @@ -68,10 +68,10 @@ class JsonDeserializer { return true; } - DeserializationError parseArray(JsonVariant variant) { + DeserializationError parseArray(VariantRef variant) { if (_nestingLimit == 0) return DeserializationError::TooDeep; - JsonArray array = variant.to(); + ArrayRef array = variant.to(); if (array.isNull()) return DeserializationError::NoMemory; // Check opening braket @@ -87,7 +87,7 @@ class JsonDeserializer { // Read each value for (;;) { // Allocate slot in array - JsonVariant value = array.add(); + VariantRef value = array.add(); if (value.isInvalid()) return DeserializationError::NoMemory; // 1 - Parse value @@ -106,10 +106,10 @@ class JsonDeserializer { } } - DeserializationError parseObject(JsonVariant variant) { + DeserializationError parseObject(VariantRef variant) { if (_nestingLimit == 0) return DeserializationError::TooDeep; - JsonObject object = variant.to(); + ObjectRef object = variant.to(); if (object.isNull()) return DeserializationError::NoMemory; // Check opening brace @@ -135,7 +135,7 @@ class JsonDeserializer { if (!eat(':')) return DeserializationError::InvalidInput; // Allocate slot in object - JsonVariant value = object.set(key); + VariantRef value = object.set(key); if (value.isInvalid()) return DeserializationError::NoMemory; // Parse value @@ -158,7 +158,7 @@ class JsonDeserializer { } } - DeserializationError parseValue(JsonVariant variant) { + DeserializationError parseValue(VariantRef variant) { if (isQuote(current())) { return parseStringValue(variant); } else { @@ -174,7 +174,7 @@ class JsonDeserializer { } } - DeserializationError parseStringValue(JsonVariant variant) { + DeserializationError parseStringValue(VariantRef variant) { StringType value; DeserializationError err = parseQuotedString(value); if (err) return err; @@ -233,7 +233,7 @@ class JsonDeserializer { return DeserializationError::Ok; } - DeserializationError parseNumericValue(JsonVariant result) { + DeserializationError parseNumericValue(VariantRef result) { char buffer[64]; uint8_t n = 0; @@ -246,9 +246,9 @@ class JsonDeserializer { buffer[n] = 0; if (isInteger(buffer)) { - result.set(parseInteger(buffer)); + result.set(parseInteger(buffer)); } else if (isFloat(buffer)) { - result.set(parseFloat(buffer)); + result.set(parseFloat(buffer)); } else if (!strcmp(buffer, "true")) { result.set(true); } else if (!strcmp(buffer, "false")) { diff --git a/src/ArduinoJson/Json/JsonSerializer.hpp b/src/ArduinoJson/Json/JsonSerializer.hpp index a4894bbe..4b90957f 100644 --- a/src/ArduinoJson/Json/JsonSerializer.hpp +++ b/src/ArduinoJson/Json/JsonSerializer.hpp @@ -4,9 +4,9 @@ #pragma once +#include "../Misc/Visitable.hpp" #include "../Serialization/measure.hpp" #include "../Serialization/serialize.hpp" -#include "../Visitable.hpp" #include "JsonWriter.hpp" namespace ARDUINOJSON_NAMESPACE { @@ -16,14 +16,14 @@ class JsonSerializer { public: JsonSerializer(TWriter &writer) : _writer(writer) {} - void visitFloat(JsonFloat value) { + void visitFloat(Float value) { _writer.writeFloat(value); } - void visitArray(JsonArrayConst array) { + void visitArray(ArrayConstRef array) { _writer.beginArray(); - JsonArrayConst::iterator it = array.begin(); + ArrayConstRef::iterator it = array.begin(); while (it != array.end()) { it->accept(*this); @@ -36,10 +36,10 @@ class JsonSerializer { _writer.endArray(); } - void visitObject(JsonObjectConst object) { + void visitObject(ObjectConstRef object) { _writer.beginObject(); - JsonObjectConst::iterator it = object.begin(); + ObjectConstRef::iterator it = object.begin(); while (it != object.end()) { _writer.writeString(it->key()); _writer.writeColon(); @@ -63,12 +63,12 @@ class JsonSerializer { for (size_t i = 0; i < n; i++) _writer.writeRaw(data[i]); } - void visitNegativeInteger(JsonUInt value) { + void visitNegativeInteger(UInt value) { _writer.writeRaw('-'); _writer.writeInteger(value); } - void visitPositiveInteger(JsonUInt value) { + void visitPositiveInteger(UInt value) { _writer.writeInteger(value); } diff --git a/src/ArduinoJson/Json/JsonWriter.hpp b/src/ArduinoJson/Json/JsonWriter.hpp index ecbc5691..a1e57759 100644 --- a/src/ArduinoJson/Json/JsonWriter.hpp +++ b/src/ArduinoJson/Json/JsonWriter.hpp @@ -6,10 +6,10 @@ #include #include // for strlen -#include "../Data/JsonInteger.hpp" #include "../Numbers/FloatParts.hpp" +#include "../Numbers/Integer.hpp" #include "../Polyfills/attributes.hpp" -#include "./EscapeSequence.hpp" +#include "EscapeSequence.hpp" namespace ARDUINOJSON_NAMESPACE { @@ -71,8 +71,8 @@ class JsonWriter { } } - template - void writeFloat(TFloat value) { + template + void writeFloat(T value) { if (isnan(value)) return writeRaw("NaN"); if (value < 0.0) { @@ -82,7 +82,7 @@ class JsonWriter { if (isinf(value)) return writeRaw("Infinity"); - FloatParts parts(value); + FloatParts parts(value); writeInteger(parts.integral); if (parts.decimalPlaces) writeDecimals(parts.decimal, parts.decimalPlaces); @@ -98,8 +98,8 @@ class JsonWriter { } } - template - void writeInteger(UInt value) { + template + void writeInteger(T value) { char buffer[22]; char *end = buffer + sizeof(buffer); char *begin = end; @@ -107,7 +107,7 @@ class JsonWriter { // write the string in reverse order do { *--begin = char(value % 10 + '0'); - value = UInt(value / 10); + value = T(value / 10); } while (value); // and dump it in the right order diff --git a/src/ArduinoJson/JsonArrayImpl.hpp b/src/ArduinoJson/JsonArrayImpl.hpp deleted file mode 100644 index 02b2a60c..00000000 --- a/src/ArduinoJson/JsonArrayImpl.hpp +++ /dev/null @@ -1,19 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "JsonArray.hpp" -#include "JsonObject.hpp" - -namespace ARDUINOJSON_NAMESPACE { - -inline JsonArray JsonArray::createNestedArray() const { - return add().to(); -} - -inline JsonObject JsonArray::createNestedObject() const { - return add().to(); -} -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonArrayIterator.hpp b/src/ArduinoJson/JsonArrayIterator.hpp deleted file mode 100644 index 7f5b07d9..00000000 --- a/src/ArduinoJson/JsonArrayIterator.hpp +++ /dev/null @@ -1,122 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "Data/SlotFunctions.hpp" -#include "JsonVariant.hpp" - -namespace ARDUINOJSON_NAMESPACE { - -class JsonVariantPtr { - public: - JsonVariantPtr(MemoryPool *memoryPool, JsonVariantData *data) - : _variant(memoryPool, data) {} - - JsonVariant *operator->() { - return &_variant; - } - - JsonVariant &operator*() { - return _variant; - } - - private: - JsonVariant _variant; -}; - -class JsonArrayIterator { - public: - JsonArrayIterator() : _slot(0) {} - explicit JsonArrayIterator(MemoryPool *memoryPool, VariantSlot *slot) - : _memoryPool(memoryPool), _slot(slot) {} - - JsonVariant operator*() const { - return JsonVariant(_memoryPool, &_slot->value); - } - JsonVariantPtr operator->() { - return JsonVariantPtr(_memoryPool, &_slot->value); - } - - bool operator==(const JsonArrayIterator &other) const { - return _slot == other._slot; - } - - bool operator!=(const JsonArrayIterator &other) const { - return _slot != other._slot; - } - - JsonArrayIterator &operator++() { - _slot = _slot->getNext(); - return *this; - } - - JsonArrayIterator &operator+=(size_t distance) { - _slot = _slot->getNext(distance); - return *this; - } - - VariantSlot *internal() { - return _slot; - } - - private: - MemoryPool *_memoryPool; - VariantSlot *_slot; -}; - -class JsonVariantConstPtr { - public: - JsonVariantConstPtr(const JsonVariantData *data) : _variant(data) {} - - JsonVariantConst *operator->() { - return &_variant; - } - - JsonVariantConst &operator*() { - return _variant; - } - - private: - JsonVariantConst _variant; -}; - -class JsonArrayConstIterator { - public: - JsonArrayConstIterator() : _slot(0) {} - explicit JsonArrayConstIterator(const VariantSlot *slot) : _slot(slot) {} - - JsonVariantConst operator*() const { - return JsonVariantConst(&_slot->value); - } - JsonVariantConstPtr operator->() { - return JsonVariantConstPtr(&_slot->value); - } - - bool operator==(const JsonArrayConstIterator &other) const { - return _slot == other._slot; - } - - bool operator!=(const JsonArrayConstIterator &other) const { - return _slot != other._slot; - } - - JsonArrayConstIterator &operator++() { - _slot = _slot->getNext(); - return *this; - } - - JsonArrayConstIterator &operator+=(size_t distance) { - _slot = _slot->getNext(distance); - return *this; - } - - const VariantSlot *internal() { - return _slot; - } - - private: - const VariantSlot *_slot; -}; -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonObjectImpl.hpp b/src/ArduinoJson/JsonObjectImpl.hpp deleted file mode 100644 index 73eb5a10..00000000 --- a/src/ArduinoJson/JsonObjectImpl.hpp +++ /dev/null @@ -1,21 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "JsonArray.hpp" -#include "JsonObject.hpp" - -namespace ARDUINOJSON_NAMESPACE { - -template -inline JsonArray JsonObject::createNestedArray(const TString& key) const { - return set(key).template to(); -} - -template -inline JsonArray JsonObject::createNestedArray(TString* key) const { - return set(key).template to(); -} -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonObjectIterator.hpp b/src/ArduinoJson/JsonObjectIterator.hpp deleted file mode 100644 index eae6ae14..00000000 --- a/src/ArduinoJson/JsonObjectIterator.hpp +++ /dev/null @@ -1,124 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "Data/SlotFunctions.hpp" -#include "JsonPair.hpp" - -namespace ARDUINOJSON_NAMESPACE { - -class JsonPairPtr { - public: - JsonPairPtr(MemoryPool *memoryPool, VariantSlot *slot) - : _pair(memoryPool, slot) {} - - const JsonPair *operator->() const { - return &_pair; - } - - const JsonPair &operator*() const { - return _pair; - } - - private: - JsonPair _pair; -}; - -class JsonObjectIterator { - public: - JsonObjectIterator() : _slot(0) {} - - explicit JsonObjectIterator(MemoryPool *memoryPool, VariantSlot *slot) - : _memoryPool(memoryPool), _slot(slot) {} - - JsonPair operator*() const { - return JsonPair(_memoryPool, _slot); - } - JsonPairPtr operator->() { - return JsonPairPtr(_memoryPool, _slot); - } - - bool operator==(const JsonObjectIterator &other) const { - return _slot == other._slot; - } - - bool operator!=(const JsonObjectIterator &other) const { - return _slot != other._slot; - } - - JsonObjectIterator &operator++() { - _slot = _slot->getNext(); - return *this; - } - - JsonObjectIterator &operator+=(size_t distance) { - _slot = _slot->getNext(distance); - return *this; - } - - VariantSlot *internal() { - return _slot; - } - - private: - MemoryPool *_memoryPool; - VariantSlot *_slot; -}; - -class JsonPairConstPtr { - public: - JsonPairConstPtr(const VariantSlot *slot) : _pair(slot) {} - - const JsonPairConst *operator->() const { - return &_pair; - } - - const JsonPairConst &operator*() const { - return _pair; - } - - private: - JsonPairConst _pair; -}; - -class JsonObjectConstIterator { - public: - JsonObjectConstIterator() : _slot(0) {} - - explicit JsonObjectConstIterator(const VariantSlot *slot) : _slot(slot) {} - - JsonPairConst operator*() const { - return JsonPairConst(_slot); - } - JsonPairConstPtr operator->() { - return JsonPairConstPtr(_slot); - } - - bool operator==(const JsonObjectConstIterator &other) const { - return _slot == other._slot; - } - - bool operator!=(const JsonObjectConstIterator &other) const { - return _slot != other._slot; - } - - JsonObjectConstIterator &operator++() { - _slot = _slot->getNext(); - return *this; - } - - JsonObjectConstIterator &operator+=(size_t distance) { - _slot = _slot->getNext(distance); - return *this; - } - - const VariantSlot *internal() { - return _slot; - } - - private: - const VariantSlot *_slot; -}; -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonPair.hpp b/src/ArduinoJson/JsonPair.hpp deleted file mode 100644 index b9abc4ff..00000000 --- a/src/ArduinoJson/JsonPair.hpp +++ /dev/null @@ -1,53 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "JsonKey.hpp" -#include "JsonVariant.hpp" - -namespace ARDUINOJSON_NAMESPACE { -// A key value pair for JsonObjectData. -class JsonPair { - public: - JsonPair(MemoryPool* memoryPool, VariantSlot* slot) : _key(slot) { - if (slot) { - _value = JsonVariant(memoryPool, &slot->value); - } - } - - JsonKey key() const { - return _key; - } - - JsonVariant value() const { - return _value; - } - - private: - JsonKey _key; - JsonVariant _value; -}; - -class JsonPairConst { - public: - JsonPairConst(const VariantSlot* slot) : _key(slot) { - if (slot) { - _value = JsonVariantConst(&slot->value); - } - } - - JsonKey key() const { - return _key; - } - - JsonVariantConst value() const { - return _value; - } - - private: - JsonKey _key; - JsonVariantConst _value; -}; -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonVariantBase.hpp b/src/ArduinoJson/JsonVariantBase.hpp deleted file mode 100644 index b18e9276..00000000 --- a/src/ArduinoJson/JsonVariantBase.hpp +++ /dev/null @@ -1,19 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "JsonVariantCasts.hpp" -#include "JsonVariantComparisons.hpp" -#include "JsonVariantOr.hpp" -#include "JsonVariantSubscripts.hpp" - -namespace ARDUINOJSON_NAMESPACE { - -template -class JsonVariantBase : public JsonVariantCasts, - public JsonVariantComparisons, - public JsonVariantOr, - public JsonVariantSubscripts {}; -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonVariantImpl.hpp b/src/ArduinoJson/JsonVariantImpl.hpp deleted file mode 100644 index fa32a6e5..00000000 --- a/src/ArduinoJson/JsonVariantImpl.hpp +++ /dev/null @@ -1,118 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include "Configuration.hpp" -#include "JsonVariant.hpp" -#include "Numbers/parseFloat.hpp" -#include "Numbers/parseInteger.hpp" - -#include // for strcmp - -namespace ARDUINOJSON_NAMESPACE { - -inline bool JsonVariant::set(JsonArray array) const { - return to().copyFrom(array); -} - -inline bool JsonVariant::set(const JsonArraySubscript& value) const { - return set(value.as()); -} - -inline bool JsonVariant::set(JsonObject object) const { - return to().copyFrom(object); -} - -template -inline bool JsonVariant::set(const JsonObjectSubscript& value) const { - return set(value.template as()); -} - -inline bool JsonVariant::set(JsonVariantConst value) const { - return variantCopy(_data, value._data, _memoryPool); -} - -inline bool JsonVariant::set(JsonVariant value) const { - return variantCopy(_data, value._data, _memoryPool); -} - -template -inline typename enable_if::value, T>::type -JsonVariant::as() const { - return JsonArray(_memoryPool, variantAsArray(_data)); -} - -template -inline typename enable_if::value, T>::type -JsonVariant::as() const { - return JsonObject(_memoryPool, variantAsObject(_data)); -} - -template -inline typename enable_if::value, JsonArray>::type -JsonVariant::to() const { - return JsonArray(_memoryPool, variantToArray(_data)); -} - -template -typename enable_if::value, JsonObject>::type -JsonVariant::to() const { - return JsonObject(_memoryPool, variantToObject(_data)); -} - -template -typename enable_if::value, JsonVariant>::type -JsonVariant::to() const { - variantSetNull(_data); - return *this; -} - -template -inline void JsonVariant::accept(Visitor& visitor) const { - return JsonVariantConst(_data).accept(visitor); -} - -template -inline void JsonVariantConst::accept(Visitor& visitor) const { - if (!_data) return visitor.visitNull(); - - switch (_data->type) { - case JSON_FLOAT: - return visitor.visitFloat(_data->content.asFloat); - - case JSON_ARRAY: - return visitor.visitArray(JsonArrayConst(&_data->content.asArray)); - - case JSON_OBJECT: - return visitor.visitObject(JsonObjectConst(&_data->content.asObject)); - - case JSON_LINKED_STRING: - case JSON_OWNED_STRING: - return visitor.visitString(_data->content.asString); - - case JSON_OWNED_RAW: - case JSON_LINKED_RAW: - return visitor.visitRawJson(_data->content.asRaw.data, - _data->content.asRaw.size); - - case JSON_NEGATIVE_INTEGER: - return visitor.visitNegativeInteger(_data->content.asInteger); - - case JSON_POSITIVE_INTEGER: - return visitor.visitPositiveInteger(_data->content.asInteger); - - case JSON_BOOLEAN: - return visitor.visitBoolean(_data->content.asInteger != 0); - - default: - return visitor.visitNull(); - } -} - -inline JsonVariantConst JsonVariantConst::operator[](size_t index) const { - return JsonArrayConst(variantAsArray(_data))[index]; -} - -} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Memory/MemoryPool.hpp b/src/ArduinoJson/Memory/MemoryPool.hpp index b77d9537..d894bc55 100644 --- a/src/ArduinoJson/Memory/MemoryPool.hpp +++ b/src/ArduinoJson/Memory/MemoryPool.hpp @@ -7,10 +7,10 @@ #include "../Polyfills/assert.hpp" #include "../Polyfills/mpl/max.hpp" #include "../Strings/StringInMemoryPool.hpp" +#include "../Variant/VariantSlot.hpp" #include "Alignment.hpp" #include "MemoryPool.hpp" #include "StringSlot.hpp" -#include "VariantSlot.hpp" namespace ARDUINOJSON_NAMESPACE { diff --git a/src/ArduinoJson/SerializedValue.hpp b/src/ArduinoJson/Misc/SerializedValue.hpp similarity index 97% rename from src/ArduinoJson/SerializedValue.hpp rename to src/ArduinoJson/Misc/SerializedValue.hpp index 2553d680..570b3dac 100644 --- a/src/ArduinoJson/SerializedValue.hpp +++ b/src/ArduinoJson/Misc/SerializedValue.hpp @@ -4,7 +4,7 @@ #pragma once -#include "Strings/StringTypes.hpp" +#include "../Strings/StringTypes.hpp" namespace ARDUINOJSON_NAMESPACE { diff --git a/src/ArduinoJson/Visitable.hpp b/src/ArduinoJson/Misc/Visitable.hpp similarity index 89% rename from src/ArduinoJson/Visitable.hpp rename to src/ArduinoJson/Misc/Visitable.hpp index f7a47686..58437692 100644 --- a/src/ArduinoJson/Visitable.hpp +++ b/src/ArduinoJson/Misc/Visitable.hpp @@ -4,7 +4,7 @@ #pragma once -#include "Polyfills/type_traits.hpp" +#include "../Polyfills/type_traits.hpp" namespace ARDUINOJSON_NAMESPACE { diff --git a/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp b/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp index 1e18f23b..7095259e 100644 --- a/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp +++ b/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp @@ -5,11 +5,11 @@ #pragma once #include "../Deserialization/deserialize.hpp" -#include "../JsonVariant.hpp" #include "../Memory/MemoryPool.hpp" #include "../Polyfills/type_traits.hpp" -#include "./endianess.hpp" -#include "./ieee754.hpp" +#include "../Variant/VariantRef.hpp" +#include "endianess.hpp" +#include "ieee754.hpp" namespace ARDUINOJSON_NAMESPACE { @@ -27,7 +27,7 @@ class MsgPackDeserializer { _stringStorage(stringStorage), _nestingLimit(nestingLimit) {} - DeserializationError parse(JsonVariant variant) { + DeserializationError parse(VariantRef variant) { uint8_t code; if (!readByte(code)) return DeserializationError::IncompleteInput; @@ -174,7 +174,7 @@ class MsgPackDeserializer { } template - DeserializationError readInteger(JsonVariant variant) { + DeserializationError readInteger(VariantRef variant) { T value; if (!readInteger(value)) return DeserializationError::IncompleteInput; variant.set(value); @@ -183,7 +183,7 @@ class MsgPackDeserializer { template typename enable_if::type readFloat( - JsonVariant variant) { + VariantRef variant) { T value; if (!readBytes(value)) return DeserializationError::IncompleteInput; fixEndianess(value); @@ -193,7 +193,7 @@ class MsgPackDeserializer { template typename enable_if::type readDouble( - JsonVariant variant) { + VariantRef variant) { T value; if (!readBytes(value)) return DeserializationError::IncompleteInput; fixEndianess(value); @@ -203,7 +203,7 @@ class MsgPackDeserializer { template typename enable_if::type readDouble( - JsonVariant variant) { + VariantRef variant) { uint8_t i[8]; // input is 8 bytes T value; // output is 4 bytes uint8_t *o = reinterpret_cast(&value); @@ -215,7 +215,7 @@ class MsgPackDeserializer { } template - DeserializationError readString(JsonVariant variant) { + DeserializationError readString(VariantRef variant) { T size; if (!readInteger(size)) return DeserializationError::IncompleteInput; return readString(variant, size); @@ -228,7 +228,7 @@ class MsgPackDeserializer { return readString(str, size); } - DeserializationError readString(JsonVariant variant, size_t n) { + DeserializationError readString(VariantRef variant, size_t n) { StringType s; DeserializationError err = readString(s, n); if (!err) variant.set(s); @@ -248,23 +248,23 @@ class MsgPackDeserializer { } template - DeserializationError readArray(JsonVariant variant) { + DeserializationError readArray(VariantRef variant) { TSize size; if (!readInteger(size)) return DeserializationError::IncompleteInput; return readArray(variant, size); } - DeserializationError readArray(JsonVariant variant, size_t n) { - JsonArray array = variant.to(); + DeserializationError readArray(VariantRef variant, size_t n) { + ArrayRef array = variant.to(); if (array.isNull()) return DeserializationError::NoMemory; return readArray(array, n); } - DeserializationError readArray(JsonArray array, size_t n) { + DeserializationError readArray(ArrayRef array, size_t n) { if (_nestingLimit == 0) return DeserializationError::TooDeep; --_nestingLimit; for (; n; --n) { - JsonVariant value = array.add(); + VariantRef value = array.add(); if (value.isInvalid()) return DeserializationError::NoMemory; DeserializationError err = parse(value); @@ -275,20 +275,20 @@ class MsgPackDeserializer { } template - DeserializationError readObject(JsonVariant variant) { + DeserializationError readObject(VariantRef variant) { TSize size; if (!readInteger(size)) return DeserializationError::IncompleteInput; return readObject(variant, size); } - DeserializationError readObject(JsonVariant variant, size_t n) { - JsonObject object = variant.to(); + DeserializationError readObject(VariantRef variant, size_t n) { + ObjectRef object = variant.to(); if (object.isNull()) return DeserializationError::NoMemory; return readObject(object, n); } - DeserializationError readObject(JsonObject object, size_t n) { + DeserializationError readObject(ObjectRef object, size_t n) { if (_nestingLimit == 0) return DeserializationError::TooDeep; --_nestingLimit; for (; n; --n) { @@ -296,7 +296,7 @@ class MsgPackDeserializer { DeserializationError err = parseKey(key); if (err) return err; - JsonVariant value = object.set(key); + VariantRef value = object.set(key); if (value.isInvalid()) return DeserializationError::NoMemory; err = parse(value); diff --git a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp index 7d9ba70b..d9fca84d 100644 --- a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp +++ b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp @@ -4,11 +4,11 @@ #pragma once -#include "../JsonVariant.hpp" #include "../Polyfills/type_traits.hpp" #include "../Serialization/measure.hpp" #include "../Serialization/serialize.hpp" -#include "./endianess.hpp" +#include "../Variant/VariantRef.hpp" +#include "endianess.hpp" namespace ARDUINOJSON_NAMESPACE { @@ -35,7 +35,7 @@ class MsgPackSerializer { } } - void visitArray(JsonArrayConst array) { + void visitArray(ArrayConstRef array) { size_t n = array.size(); if (n < 0x10) { writeByte(uint8_t(0x90 + array.size())); @@ -46,12 +46,12 @@ class MsgPackSerializer { writeByte(0xDD); writeInteger(uint32_t(n)); } - for (JsonArrayConst::iterator it = array.begin(); it != array.end(); ++it) { + for (ArrayConstRef::iterator it = array.begin(); it != array.end(); ++it) { it->accept(*this); } } - void visitObject(JsonObjectConst object) { + void visitObject(ObjectConstRef object) { size_t n = object.size(); if (n < 0x10) { writeByte(uint8_t(0x80 + n)); @@ -62,7 +62,7 @@ class MsgPackSerializer { writeByte(0xDF); writeInteger(uint32_t(n)); } - for (JsonObjectConst::iterator it = object.begin(); it != object.end(); + for (ObjectConstRef::iterator it = object.begin(); it != object.end(); ++it) { visitString(it->key()); it->value().accept(*this); @@ -93,8 +93,8 @@ class MsgPackSerializer { writeBytes(reinterpret_cast(data), size); } - void visitNegativeInteger(JsonUInt value) { - JsonUInt negated = JsonUInt(~value + 1); + void visitNegativeInteger(UInt value) { + UInt negated = UInt(~value + 1); if (value <= 0x20) { writeInteger(int8_t(negated)); } else if (value <= 0x80) { @@ -115,7 +115,7 @@ class MsgPackSerializer { #endif } - void visitPositiveInteger(JsonUInt value) { + void visitPositiveInteger(UInt value) { if (value <= 0x7F) { writeInteger(uint8_t(value)); } else if (value <= 0xFF) { diff --git a/src/ArduinoJson/Data/JsonFloat.hpp b/src/ArduinoJson/Numbers/Float.hpp similarity index 82% rename from src/ArduinoJson/Data/JsonFloat.hpp rename to src/ArduinoJson/Numbers/Float.hpp index 2f6e9570..8bcfd700 100644 --- a/src/ArduinoJson/Data/JsonFloat.hpp +++ b/src/ArduinoJson/Numbers/Float.hpp @@ -9,8 +9,8 @@ namespace ARDUINOJSON_NAMESPACE { #if ARDUINOJSON_USE_DOUBLE -typedef double JsonFloat; +typedef double Float; #else -typedef float JsonFloat; +typedef float Float; #endif } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Data/JsonInteger.hpp b/src/ArduinoJson/Numbers/Integer.hpp similarity index 71% rename from src/ArduinoJson/Data/JsonInteger.hpp rename to src/ArduinoJson/Numbers/Integer.hpp index 9848b5b2..1f66dbf6 100644 --- a/src/ArduinoJson/Data/JsonInteger.hpp +++ b/src/ArduinoJson/Numbers/Integer.hpp @@ -11,10 +11,10 @@ namespace ARDUINOJSON_NAMESPACE { #if ARDUINOJSON_USE_LONG_LONG -typedef int64_t JsonInteger; -typedef uint64_t JsonUInt; +typedef int64_t Integer; +typedef uint64_t UInt; #else -typedef long JsonInteger; -typedef unsigned long JsonUInt; +typedef long Integer; +typedef unsigned long UInt; #endif } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonKey.hpp b/src/ArduinoJson/Object/Key.hpp similarity index 80% rename from src/ArduinoJson/JsonKey.hpp rename to src/ArduinoJson/Object/Key.hpp index aa833cc5..2e2a6924 100644 --- a/src/ArduinoJson/JsonKey.hpp +++ b/src/ArduinoJson/Object/Key.hpp @@ -6,9 +6,9 @@ namespace ARDUINOJSON_NAMESPACE { -class JsonKey { +class Key { public: - JsonKey(const VariantSlot* slot) : _slot(slot) {} + Key(const VariantSlot* slot) : _slot(slot) {} operator const char*() const { return c_str(); @@ -22,7 +22,7 @@ class JsonKey { return _slot == 0 || _slot->key == 0; } - friend bool operator==(JsonKey lhs, const char* rhs) { + friend bool operator==(Key lhs, const char* rhs) { if (lhs.isNull()) return rhs == 0; return rhs ? !strcmp(lhs, rhs) : false; } diff --git a/src/ArduinoJson/Data/ObjectFunctions.hpp b/src/ArduinoJson/Object/ObjectFunctions.hpp similarity index 67% rename from src/ArduinoJson/Data/ObjectFunctions.hpp rename to src/ArduinoJson/Object/ObjectFunctions.hpp index cc271447..8e69303c 100644 --- a/src/ArduinoJson/Data/ObjectFunctions.hpp +++ b/src/ArduinoJson/Object/ObjectFunctions.hpp @@ -5,13 +5,13 @@ #pragma once #include "../Memory/MemoryPool.hpp" -#include "JsonVariantData.hpp" -#include "SlotFunctions.hpp" +#include "../Variant/SlotFunctions.hpp" +#include "../Variant/VariantData.hpp" namespace ARDUINOJSON_NAMESPACE { template -inline VariantSlot* objectFindSlot(const JsonObjectData* obj, TKey key) { +inline VariantSlot* objectFindSlot(const ObjectData* obj, TKey key) { if (!obj) return 0; VariantSlot* slot = obj->head; while (slot) { @@ -22,13 +22,12 @@ inline VariantSlot* objectFindSlot(const JsonObjectData* obj, TKey key) { } template -inline bool objectContainsKey(const JsonObjectData* obj, const TKey& key) { +inline bool objectContainsKey(const ObjectData* obj, const TKey& key) { return objectFindSlot(obj, key) != 0; } template -inline JsonVariantData* objectAdd(JsonObjectData* obj, TKey key, - MemoryPool* pool) { +inline VariantData* objectAdd(ObjectData* obj, TKey key, MemoryPool* pool) { VariantSlot* slot = pool->allocVariant(); if (!slot) return 0; @@ -49,8 +48,7 @@ inline JsonVariantData* objectAdd(JsonObjectData* obj, TKey key, } template -inline JsonVariantData* objectSet(JsonObjectData* obj, TKey key, - MemoryPool* pool) { +inline VariantData* objectSet(ObjectData* obj, TKey key, MemoryPool* pool) { if (!obj) return 0; // ignore null key @@ -64,18 +62,18 @@ inline JsonVariantData* objectSet(JsonObjectData* obj, TKey key, } template -inline JsonVariantData* objectGet(const JsonObjectData* obj, TKey key) { +inline VariantData* objectGet(const ObjectData* obj, TKey key) { VariantSlot* slot = objectFindSlot(obj, key); return slot ? &slot->value : 0; } -inline void objectClear(JsonObjectData* obj) { +inline void objectClear(ObjectData* obj) { if (!obj) return; obj->head = 0; obj->tail = 0; } -inline void objectRemove(JsonObjectData* obj, VariantSlot* slot) { +inline void objectRemove(ObjectData* obj, VariantSlot* slot) { if (!obj) return; if (!slot) return; VariantSlot* prev = slot->getPrev(); @@ -90,19 +88,19 @@ inline void objectRemove(JsonObjectData* obj, VariantSlot* slot) { obj->tail = prev; } -inline size_t objectSize(const JsonObjectData* obj) { +inline size_t objectSize(const ObjectData* obj) { if (!obj) return 0; return slotSize(obj->head); } -// bool variantCopy(JsonVariantData*, const JsonVariantData*, MemoryPool*); +// bool variantCopy(VariantData*, const VariantData*, MemoryPool*); -inline bool objectCopy(JsonObjectData* dst, const JsonObjectData* src, +inline bool objectCopy(ObjectData* dst, const ObjectData* src, MemoryPool* pool) { if (!dst || !src) return false; objectClear(dst); for (VariantSlot* s = src->head; s; s = s->getNext()) { - JsonVariantData* var; + VariantData* var; if (s->value.keyIsOwned) var = objectAdd(dst, ZeroTerminatedRamString(s->key), pool); else @@ -112,13 +110,13 @@ inline bool objectCopy(JsonObjectData* dst, const JsonObjectData* src, return true; } -inline bool objectEquals(const JsonObjectData* o1, const JsonObjectData* o2) { +inline bool objectEquals(const ObjectData* o1, const ObjectData* o2) { if (o1 == o2) return true; if (!o1 || !o2) return false; for (VariantSlot* s = o1->head; s; s = s->getNext()) { - JsonVariantData* v1 = &s->value; - JsonVariantData* v2 = objectGet(o2, makeString(slotGetKey(s))); + VariantData* v1 = &s->value; + VariantData* v2 = objectGet(o2, makeString(slotGetKey(s))); if (!variantEquals(v1, v2)) return false; } return true; diff --git a/src/ArduinoJson/Object/ObjectImpl.hpp b/src/ArduinoJson/Object/ObjectImpl.hpp new file mode 100644 index 00000000..791b90eb --- /dev/null +++ b/src/ArduinoJson/Object/ObjectImpl.hpp @@ -0,0 +1,21 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "../Array/ArrayRef.hpp" +#include "ObjectRef.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template +inline ArrayRef ObjectRef::createNestedArray(const TString& key) const { + return set(key).template to(); +} + +template +inline ArrayRef ObjectRef::createNestedArray(TString* key) const { + return set(key).template to(); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Object/ObjectIterator.hpp b/src/ArduinoJson/Object/ObjectIterator.hpp new file mode 100644 index 00000000..4d776e64 --- /dev/null +++ b/src/ArduinoJson/Object/ObjectIterator.hpp @@ -0,0 +1,124 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "../Variant/SlotFunctions.hpp" +#include "Pair.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +class PairPtr { + public: + PairPtr(MemoryPool *memoryPool, VariantSlot *slot) + : _pair(memoryPool, slot) {} + + const Pair *operator->() const { + return &_pair; + } + + const Pair &operator*() const { + return _pair; + } + + private: + Pair _pair; +}; + +class ObjectIterator { + public: + ObjectIterator() : _slot(0) {} + + explicit ObjectIterator(MemoryPool *memoryPool, VariantSlot *slot) + : _memoryPool(memoryPool), _slot(slot) {} + + Pair operator*() const { + return Pair(_memoryPool, _slot); + } + PairPtr operator->() { + return PairPtr(_memoryPool, _slot); + } + + bool operator==(const ObjectIterator &other) const { + return _slot == other._slot; + } + + bool operator!=(const ObjectIterator &other) const { + return _slot != other._slot; + } + + ObjectIterator &operator++() { + _slot = _slot->getNext(); + return *this; + } + + ObjectIterator &operator+=(size_t distance) { + _slot = _slot->getNext(distance); + return *this; + } + + VariantSlot *internal() { + return _slot; + } + + private: + MemoryPool *_memoryPool; + VariantSlot *_slot; +}; + +class PairConstPtr { + public: + PairConstPtr(const VariantSlot *slot) : _pair(slot) {} + + const PairConst *operator->() const { + return &_pair; + } + + const PairConst &operator*() const { + return _pair; + } + + private: + PairConst _pair; +}; + +class ObjectConstIterator { + public: + ObjectConstIterator() : _slot(0) {} + + explicit ObjectConstIterator(const VariantSlot *slot) : _slot(slot) {} + + PairConst operator*() const { + return PairConst(_slot); + } + PairConstPtr operator->() { + return PairConstPtr(_slot); + } + + bool operator==(const ObjectConstIterator &other) const { + return _slot == other._slot; + } + + bool operator!=(const ObjectConstIterator &other) const { + return _slot != other._slot; + } + + ObjectConstIterator &operator++() { + _slot = _slot->getNext(); + return *this; + } + + ObjectConstIterator &operator+=(size_t distance) { + _slot = _slot->getNext(distance); + return *this; + } + + const VariantSlot *internal() { + return _slot; + } + + private: + const VariantSlot *_slot; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonObject.hpp b/src/ArduinoJson/Object/ObjectRef.hpp similarity index 59% rename from src/ArduinoJson/JsonObject.hpp rename to src/ArduinoJson/Object/ObjectRef.hpp index dad1174f..019d15c7 100644 --- a/src/ArduinoJson/JsonObject.hpp +++ b/src/ArduinoJson/Object/ObjectRef.hpp @@ -4,8 +4,8 @@ #pragma once -#include "Data/ObjectFunctions.hpp" -#include "JsonObjectIterator.hpp" +#include "ObjectFunctions.hpp" +#include "ObjectIterator.hpp" // Returns the size (in bytes) of an object with n elements. // Can be very handy to determine the size of a StaticMemoryPool. @@ -15,7 +15,7 @@ namespace ARDUINOJSON_NAMESPACE { template -class JsonObjectProxy { +class ObjectRefBase { public: // Tells weither the specified key is present and associated with a value. // @@ -42,20 +42,20 @@ class JsonObjectProxy { } protected: - JsonObjectProxy(TData* data) : _data(data) {} + ObjectRefBase(TData* data) : _data(data) {} TData* _data; }; -class JsonObjectConst : public JsonObjectProxy, - public Visitable { - friend class JsonObject; - typedef JsonObjectProxy proxy_type; +class ObjectConstRef : public ObjectRefBase, + public Visitable { + friend class ObjectRef; + typedef ObjectRefBase base_type; public: - typedef JsonObjectConstIterator iterator; + typedef ObjectConstIterator iterator; - JsonObjectConst() : proxy_type(0) {} - JsonObjectConst(const JsonObjectData* data) : proxy_type(data) {} + ObjectConstRef() : base_type(0) {} + ObjectConstRef(const ObjectData* data) : base_type(data) {} template FORCE_INLINE void accept(Visitor& visitor) const { @@ -79,66 +79,65 @@ class JsonObjectConst : public JsonObjectProxy, // TValue get(TKey) const; // TKey = const std::string&, const String& // TValue = bool, char, long, int, short, float, double, - // std::string, String, JsonArrayConst, JsonObjectConst + // std::string, String, ArrayConstRef, ObjectConstRef template - FORCE_INLINE JsonVariantConst get(const TKey& key) const { + FORCE_INLINE VariantConstRef get(const TKey& key) const { return get_impl(makeString(key)); } // // TValue get(TKey) const; // TKey = char*, const char*, const FlashStringHelper* // TValue = bool, char, long, int, short, float, double, - // std::string, String, JsonArrayConst, JsonObjectConst + // std::string, String, ArrayConstRef, ObjectConstRef template - FORCE_INLINE JsonVariantConst get(TKey* key) const { + FORCE_INLINE VariantConstRef get(TKey* key) const { return get_impl(makeString(key)); } // - // JsonVariantConst operator[](TKey) const; + // VariantConstRef operator[](TKey) const; // TKey = const std::string&, const String& template - FORCE_INLINE typename enable_if::value, JsonVariantConst>::type + FORCE_INLINE typename enable_if::value, VariantConstRef>::type operator[](const TKey& key) const { return get_impl(makeString(key)); } // - // JsonVariantConst operator[](TKey) const; + // VariantConstRef operator[](TKey) const; // TKey = const char*, const char[N], const FlashStringHelper* template - FORCE_INLINE - typename enable_if::value, JsonVariantConst>::type - operator[](TKey* key) const { + FORCE_INLINE typename enable_if::value, VariantConstRef>::type + operator[](TKey* key) const { return get_impl(makeString(key)); } - FORCE_INLINE bool operator==(JsonObjectConst rhs) const { + FORCE_INLINE bool operator==(ObjectConstRef rhs) const { return objectEquals(_data, rhs._data); } private: template - FORCE_INLINE JsonVariantConst get_impl(TKey key) const { - return JsonVariantConst(objectGet(_data, key)); + FORCE_INLINE VariantConstRef get_impl(TKey key) const { + return VariantConstRef(objectGet(_data, key)); } }; -class JsonObject : public JsonObjectProxy, public Visitable { - typedef JsonObjectProxy proxy_type; +class ObjectRef : public ObjectRefBase, public Visitable { + typedef ObjectRefBase base_type; public: - typedef JsonObjectIterator iterator; + typedef ObjectIterator iterator; - FORCE_INLINE JsonObject() : proxy_type(0), _memoryPool(0) {} - FORCE_INLINE JsonObject(MemoryPool* buf, JsonObjectData* data) - : proxy_type(data), _memoryPool(buf) {} + FORCE_INLINE ObjectRef() : base_type(0), _memoryPool(0) {} + FORCE_INLINE ObjectRef(MemoryPool* buf, ObjectData* data) + : base_type(data), _memoryPool(buf) {} - operator JsonVariant() const { - return JsonVariant(_memoryPool, getVariantData(_data)); + operator VariantRef() const { + return VariantRef(_memoryPool, getVariantData(_data)); } - operator JsonObjectConst() const { - return JsonObjectConst(_data); + operator ObjectConstRef() const { + return ObjectConstRef(_data); } FORCE_INLINE iterator begin() const { @@ -154,35 +153,35 @@ class JsonObject : public JsonObjectProxy, public Visitable { objectClear(_data); } - FORCE_INLINE bool copyFrom(JsonObjectConst src) { + FORCE_INLINE bool copyFrom(ObjectConstRef src) { return objectCopy(_data, src._data, _memoryPool); } - // Creates and adds a JsonArray. + // Creates and adds a ArrayRef. // - // JsonArray createNestedArray(TKey); + // ArrayRef createNestedArray(TKey); // TKey = const std::string&, const String& template - FORCE_INLINE JsonArray createNestedArray(const TKey& key) const; - // JsonArray createNestedArray(TKey); + FORCE_INLINE ArrayRef createNestedArray(const TKey& key) const; + // ArrayRef createNestedArray(TKey); // TKey = char*, const char*, char[], const char[], const FlashStringHelper* template - FORCE_INLINE JsonArray createNestedArray(TKey* key) const; + FORCE_INLINE ArrayRef createNestedArray(TKey* key) const; - // Creates and adds a JsonObject. + // Creates and adds a ObjectRef. // - // JsonObject createNestedObject(TKey); + // ObjectRef createNestedObject(TKey); // TKey = const std::string&, const String& template - FORCE_INLINE JsonObject createNestedObject(const TKey& key) const { - return set(key).template to(); + FORCE_INLINE ObjectRef createNestedObject(const TKey& key) const { + return set(key).template to(); } // - // JsonObject createNestedObject(TKey); + // ObjectRef createNestedObject(TKey); // TKey = char*, const char*, char[], const char[], const FlashStringHelper* template - FORCE_INLINE JsonObject createNestedObject(TKey* key) const { - return set(key).template to(); + FORCE_INLINE ObjectRef createNestedObject(TKey* key) const { + return set(key).template to(); } // Gets the value associated with the specified key. @@ -190,39 +189,38 @@ class JsonObject : public JsonObjectProxy, public Visitable { // TValue get(TKey) const; // TKey = const std::string&, const String& // TValue = bool, char, long, int, short, float, double, - // std::string, String, JsonArray, JsonObject + // std::string, String, ArrayRef, ObjectRef template - FORCE_INLINE JsonVariant get(const TKey& key) const { + FORCE_INLINE VariantRef get(const TKey& key) const { return get_impl(makeString(key)); } // // TValue get(TKey) const; // TKey = char*, const char*, const FlashStringHelper* // TValue = bool, char, long, int, short, float, double, - // std::string, String, JsonArray, JsonObject + // std::string, String, ArrayRef, ObjectRef template - FORCE_INLINE JsonVariant get(TKey* key) const { + FORCE_INLINE VariantRef get(TKey* key) const { return get_impl(makeString(key)); } // Gets or sets the value associated with the specified key. // - // JsonObjectSubscript operator[](TKey) + // ObjectSubscript operator[](TKey) // TKey = const std::string&, const String& template - FORCE_INLINE JsonObjectSubscript operator[]( - const TKey& key) const { - return JsonObjectSubscript(*this, key); + FORCE_INLINE ObjectSubscript operator[](const TKey& key) const { + return ObjectSubscript(*this, key); } // - // JsonObjectSubscript operator[](TKey) + // ObjectSubscript operator[](TKey) // TKey = char*, const char*, char[], const char[N], const FlashStringHelper* template - FORCE_INLINE JsonObjectSubscript operator[](TKey* key) const { - return JsonObjectSubscript(*this, key); + FORCE_INLINE ObjectSubscript operator[](TKey* key) const { + return ObjectSubscript(*this, key); } - FORCE_INLINE bool operator==(JsonObject rhs) const { + FORCE_INLINE bool operator==(ObjectRef rhs) const { return objectEquals(_data, rhs._data); } @@ -247,37 +245,37 @@ class JsonObject : public JsonObjectProxy, public Visitable { } template - FORCE_INLINE JsonVariant set(TKey* key) const { + FORCE_INLINE VariantRef set(TKey* key) const { return set_impl(makeString(key)); } template - FORCE_INLINE JsonVariant set(const TKey& key) const { + FORCE_INLINE VariantRef set(const TKey& key) const { return set_impl(makeString(key)); } - FORCE_INLINE JsonVariant set(StringInMemoryPool key) const { + FORCE_INLINE VariantRef set(StringInMemoryPool key) const { return set_impl(key); } - FORCE_INLINE JsonVariant set(ZeroTerminatedRamStringConst key) const { + FORCE_INLINE VariantRef set(ZeroTerminatedRamStringConst key) const { return set_impl(key); } template FORCE_INLINE void accept(Visitor& visitor) const { - JsonObjectConst(_data).accept(visitor); + ObjectConstRef(_data).accept(visitor); } private: template - FORCE_INLINE JsonVariant get_impl(TStringRef key) const { - return JsonVariant(_memoryPool, objectGet(_data, key)); + FORCE_INLINE VariantRef get_impl(TStringRef key) const { + return VariantRef(_memoryPool, objectGet(_data, key)); } template - FORCE_INLINE JsonVariant set_impl(TKey key) const { - return JsonVariant(_memoryPool, objectSet(_data, key, _memoryPool)); + FORCE_INLINE VariantRef set_impl(TKey key) const { + return VariantRef(_memoryPool, objectSet(_data, key, _memoryPool)); } template diff --git a/src/ArduinoJson/JsonObjectSubscript.hpp b/src/ArduinoJson/Object/ObjectSubscript.hpp similarity index 67% rename from src/ArduinoJson/JsonObjectSubscript.hpp rename to src/ArduinoJson/Object/ObjectSubscript.hpp index ad557be1..f7361cb5 100644 --- a/src/ArduinoJson/JsonObjectSubscript.hpp +++ b/src/ArduinoJson/Object/ObjectSubscript.hpp @@ -4,9 +4,9 @@ #pragma once -#include "Configuration.hpp" -#include "JsonVariantBase.hpp" -#include "Polyfills/type_traits.hpp" +#include "../Configuration.hpp" +#include "../Operators/VariantOperators.hpp" +#include "../Polyfills/type_traits.hpp" #ifdef _MSC_VER #pragma warning(push) @@ -16,16 +16,15 @@ namespace ARDUINOJSON_NAMESPACE { template -class JsonObjectSubscript - : public JsonVariantBase >, - public Visitable { - typedef JsonObjectSubscript this_type; +class ObjectSubscript : public VariantOperators >, + public Visitable { + typedef ObjectSubscript this_type; public: - FORCE_INLINE JsonObjectSubscript(JsonObject object, TStringRef key) + FORCE_INLINE ObjectSubscript(ObjectRef object, TStringRef key) : _object(object), _key(key) {} - operator JsonVariantConst() const { + operator VariantConstRef() const { return get_impl(); } @@ -38,7 +37,7 @@ class JsonObjectSubscript // // operator=(const TValue&); // TValue = bool, char, long, int, short, float, double, - // std::string, String, JsonArray, JsonObject + // std::string, String, ArrayRef, ObjectRef template FORCE_INLINE typename enable_if::value, this_type &>::type operator=(const TValue &src) { @@ -59,7 +58,7 @@ class JsonObjectSubscript } template - FORCE_INLINE typename JsonVariantAs::type as() const { + FORCE_INLINE typename VariantAs::type as() const { return get_impl().template as(); } @@ -69,7 +68,7 @@ class JsonObjectSubscript } template - FORCE_INLINE typename JsonVariantTo::type to() { + FORCE_INLINE typename VariantTo::type to() { return set_impl().template to(); } @@ -77,8 +76,8 @@ class JsonObjectSubscript // // bool set(const TValue&); // TValue = bool, char, long, int, short, float, double, serialized, - // JsonVariant, - // std::string, String, JsonArray, JsonObject + // VariantRef, + // std::string, String, ArrayRef, ObjectRef template FORCE_INLINE typename enable_if::value, bool>::type set( const TValue &value) { @@ -98,32 +97,32 @@ class JsonObjectSubscript } private: - FORCE_INLINE JsonVariant get_impl() const { + FORCE_INLINE VariantRef get_impl() const { return _object.get(_key); } - FORCE_INLINE JsonVariant set_impl() const { + FORCE_INLINE VariantRef set_impl() const { return _object.set(_key); } - JsonObject _object; + ObjectRef _object; TStringRef _key; }; template template inline typename enable_if::value, - JsonObjectSubscript >::type - JsonVariantSubscripts::operator[](const TString &key) const { - return impl()->template as()[key]; + ObjectSubscript >::type + VariantSubscripts::operator[](const TString &key) const { + return impl()->template as()[key]; } template template inline typename enable_if::value, - JsonObjectSubscript >::type - JsonVariantSubscripts::operator[](TString *key) const { - return impl()->template as()[key]; + ObjectSubscript >::type + VariantSubscripts::operator[](TString *key) const { + return impl()->template as()[key]; } } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Object/Pair.hpp b/src/ArduinoJson/Object/Pair.hpp new file mode 100644 index 00000000..265522df --- /dev/null +++ b/src/ArduinoJson/Object/Pair.hpp @@ -0,0 +1,53 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "../Variant/VariantRef.hpp" +#include "Key.hpp" + +namespace ARDUINOJSON_NAMESPACE { +// A key value pair for ObjectData. +class Pair { + public: + Pair(MemoryPool* memoryPool, VariantSlot* slot) : _key(slot) { + if (slot) { + _value = VariantRef(memoryPool, &slot->value); + } + } + + Key key() const { + return _key; + } + + VariantRef value() const { + return _value; + } + + private: + Key _key; + VariantRef _value; +}; + +class PairConst { + public: + PairConst(const VariantSlot* slot) : _key(slot) { + if (slot) { + _value = VariantConstRef(&slot->value); + } + } + + Key key() const { + return _key; + } + + VariantConstRef value() const { + return _value; + } + + private: + Key _key; + VariantConstRef _value; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonVariantCasts.hpp b/src/ArduinoJson/Operators/VariantCasts.hpp similarity index 81% rename from src/ArduinoJson/JsonVariantCasts.hpp rename to src/ArduinoJson/Operators/VariantCasts.hpp index 04d64d37..33c2358a 100644 --- a/src/ArduinoJson/JsonVariantCasts.hpp +++ b/src/ArduinoJson/Operators/VariantCasts.hpp @@ -4,13 +4,12 @@ #pragma once -#include "Data/JsonVariantAs.hpp" -#include "Polyfills/attributes.hpp" +#include "../Polyfills/attributes.hpp" namespace ARDUINOJSON_NAMESPACE { template -class JsonVariantCasts { +class VariantCasts { public: template FORCE_INLINE operator T() const { diff --git a/src/ArduinoJson/JsonVariantComparisons.hpp b/src/ArduinoJson/Operators/VariantComparisons.hpp similarity index 98% rename from src/ArduinoJson/JsonVariantComparisons.hpp rename to src/ArduinoJson/Operators/VariantComparisons.hpp index 622da0eb..3a16e86b 100644 --- a/src/ArduinoJson/JsonVariantComparisons.hpp +++ b/src/ArduinoJson/Operators/VariantComparisons.hpp @@ -4,7 +4,7 @@ #pragma once -#include "JsonVariant.hpp" +#include "../Variant/VariantRef.hpp" namespace ARDUINOJSON_NAMESPACE { template @@ -15,7 +15,7 @@ struct is_simple_value { }; template -class JsonVariantComparisons { +class VariantComparisons { public: // const char* == TVariant template diff --git a/src/ArduinoJson/Operators/VariantOperators.hpp b/src/ArduinoJson/Operators/VariantOperators.hpp new file mode 100644 index 00000000..15adeb42 --- /dev/null +++ b/src/ArduinoJson/Operators/VariantOperators.hpp @@ -0,0 +1,19 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "VariantCasts.hpp" +#include "VariantComparisons.hpp" +#include "VariantOr.hpp" +#include "VariantSubscripts.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template +class VariantOperators : public VariantCasts, + public VariantComparisons, + public VariantOr, + public VariantSubscripts {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonVariantOr.hpp b/src/ArduinoJson/Operators/VariantOr.hpp similarity index 74% rename from src/ArduinoJson/JsonVariantOr.hpp rename to src/ArduinoJson/Operators/VariantOr.hpp index 0cdd3064..83c063bc 100644 --- a/src/ArduinoJson/JsonVariantOr.hpp +++ b/src/ArduinoJson/Operators/VariantOr.hpp @@ -4,16 +4,16 @@ #pragma once -#include "Data/JsonVariantAs.hpp" -#include "Polyfills/attributes.hpp" -#include "Polyfills/type_traits.hpp" +#include "../Polyfills/attributes.hpp" +#include "../Polyfills/type_traits.hpp" +#include "../Variant/VariantAs.hpp" namespace ARDUINOJSON_NAMESPACE { template -class JsonVariantOr { +class VariantOr { public: - // Returns the default value if the JsonVariant is undefined of incompatible + // Returns the default value if the VariantRef is undefined of incompatible template typename enable_if::value, T>::type operator|( const T &defaultValue) const { @@ -23,14 +23,14 @@ class JsonVariantOr { return defaultValue; } - // Returns the default value if the JsonVariant is undefined of incompatible + // Returns the default value if the VariantRef is undefined of incompatible // Special case for string: null is treated as undefined const char *operator|(const char *defaultValue) const { const char *value = impl()->template as(); return value ? value : defaultValue; } - // Returns the default value if the JsonVariant is undefined of incompatible + // Returns the default value if the VariantRef is undefined of incompatible // Special case for integers: we also accept double template typename enable_if::value, Integer>::type operator|( diff --git a/src/ArduinoJson/JsonVariantSubscripts.hpp b/src/ArduinoJson/Operators/VariantSubscripts.hpp similarity index 62% rename from src/ArduinoJson/JsonVariantSubscripts.hpp rename to src/ArduinoJson/Operators/VariantSubscripts.hpp index 720404fa..799fb1bc 100644 --- a/src/ArduinoJson/JsonVariantSubscripts.hpp +++ b/src/ArduinoJson/Operators/VariantSubscripts.hpp @@ -4,43 +4,43 @@ #pragma once -#include "Data/JsonVariantAs.hpp" -#include "Polyfills/attributes.hpp" -#include "Polyfills/type_traits.hpp" -#include "Strings/StringTypes.hpp" +#include "../Polyfills/attributes.hpp" +#include "../Polyfills/type_traits.hpp" +#include "../Strings/StringTypes.hpp" +#include "../Variant/VariantAs.hpp" namespace ARDUINOJSON_NAMESPACE { -class JsonArray; -class JsonObject; +class ArrayRef; +class ObjectRef; // Forward declarations. -class JsonArraySubscript; +class ArraySubscript; template -class JsonObjectSubscript; +class ObjectSubscript; template -class JsonVariantSubscripts { +class VariantSubscripts { public: // Mimics an array. // Returns the element at specified index if the variant is an array. - FORCE_INLINE JsonArraySubscript operator[](size_t index) const; + FORCE_INLINE ArraySubscript operator[](size_t index) const; // Mimics an object. // Returns the value associated with the specified key if the variant is // an object. // - // JsonObjectSubscript operator[](TKey) const; + // ObjectSubscript operator[](TKey) const; // TKey = const std::string&, const String& template FORCE_INLINE typename enable_if::value, - JsonObjectSubscript >::type + ObjectSubscript >::type operator[](const TString &key) const; // - // JsonObjectSubscript operator[](TKey) const; + // ObjectSubscript operator[](TKey) const; // TKey = const char*, const char[N], const FlashStringHelper* template FORCE_INLINE typename enable_if::value, - JsonObjectSubscript >::type + ObjectSubscript >::type operator[](TString *key) const; private: diff --git a/src/ArduinoJson/Data/SlotFunctions.hpp b/src/ArduinoJson/Variant/SlotFunctions.hpp similarity index 97% rename from src/ArduinoJson/Data/SlotFunctions.hpp rename to src/ArduinoJson/Variant/SlotFunctions.hpp index 95c25dbd..fc0499b8 100644 --- a/src/ArduinoJson/Data/SlotFunctions.hpp +++ b/src/ArduinoJson/Variant/SlotFunctions.hpp @@ -7,7 +7,7 @@ #include "../Memory/MemoryPool.hpp" #include "../Polyfills/assert.hpp" #include "../Strings/StringTypes.hpp" -#include "JsonVariantData.hpp" +#include "VariantData.hpp" namespace ARDUINOJSON_NAMESPACE { diff --git a/src/ArduinoJson/Variant/VariantAs.hpp b/src/ArduinoJson/Variant/VariantAs.hpp new file mode 100644 index 00000000..d5d3dfb3 --- /dev/null +++ b/src/ArduinoJson/Variant/VariantAs.hpp @@ -0,0 +1,89 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "../Serialization/DynamicStringWriter.hpp" +#include "VariantFunctions.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +class ArrayRef; +class ArrayConstRef; +class ObjectRef; +class ObjectConstRef; +class VariantRef; +class VariantConstRef; + +// A metafunction that returns the type of the value returned by +// VariantRef::as() +template +struct VariantAs { + typedef T type; +}; + +template <> +struct VariantAs { + typedef const char* type; +}; + +// A metafunction that returns the type of the value returned by +// VariantRef::as() +template +struct VariantConstAs { + typedef typename VariantAs::type type; +}; + +template <> +struct VariantConstAs { + typedef VariantConstRef type; +}; + +template <> +struct VariantConstAs { + typedef ObjectConstRef type; +}; + +template <> +struct VariantConstAs { + typedef ArrayConstRef type; +}; + +// --- + +template +inline typename enable_if::value, T>::type variantAs( + const VariantData* _data) { + return variantAsIntegral(_data); +} + +template +inline typename enable_if::value, T>::type variantAs( + const VariantData* _data) { + return variantAsBoolean(_data); +} + +template +inline typename enable_if::value, T>::type variantAs( + const VariantData* _data) { + return variantAsFloat(_data); +} + +template +inline typename enable_if::value || + is_same::value, + const char*>::type +variantAs(const VariantData* _data) { + return variantAsString(_data); +} + +template +inline typename enable_if::value, T>::type +variantAs(const VariantData* _data); + +template +inline typename enable_if::value, T>::type variantAs( + const VariantData* _data); + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Data/VariantAsImpl.hpp b/src/ArduinoJson/Variant/VariantAsImpl.hpp similarity index 64% rename from src/ArduinoJson/Data/VariantAsImpl.hpp rename to src/ArduinoJson/Variant/VariantAsImpl.hpp index 64471607..72230f2c 100644 --- a/src/ArduinoJson/Data/VariantAsImpl.hpp +++ b/src/ArduinoJson/Variant/VariantAsImpl.hpp @@ -4,25 +4,25 @@ #pragma once -#include "../JsonVariant.hpp" #include "../Serialization/DynamicStringWriter.hpp" #include "VariantFunctions.hpp" +#include "VariantRef.hpp" namespace ARDUINOJSON_NAMESPACE { template -inline typename enable_if::value, T>::type -variantAs(const JsonVariantData* _data) { - return JsonVariantConst(_data); +inline typename enable_if::value, T>::type +variantAs(const VariantData* _data) { + return VariantConstRef(_data); } template inline typename enable_if::value, T>::type variantAs( - const JsonVariantData* _data) { + const VariantData* _data) { const char* cstr = variantAsString(_data); if (cstr) return T(cstr); T s; - serializeJson(JsonVariantConst(_data), s); + serializeJson(VariantConstRef(_data), s); return s; } diff --git a/src/ArduinoJson/Variant/VariantData.hpp b/src/ArduinoJson/Variant/VariantData.hpp new file mode 100644 index 00000000..de7016e2 --- /dev/null +++ b/src/ArduinoJson/Variant/VariantData.hpp @@ -0,0 +1,79 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include // ptrdiff_t, size_t + +#include "../Numbers/Float.hpp" +#include "../Numbers/Integer.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +enum VariantType { + JSON_NULL, + JSON_LINKED_RAW, + JSON_OWNED_RAW, + JSON_LINKED_STRING, + JSON_OWNED_STRING, + JSON_BOOLEAN, + JSON_POSITIVE_INTEGER, + JSON_NEGATIVE_INTEGER, + JSON_ARRAY, + JSON_OBJECT, + JSON_FLOAT +}; + +struct ObjectData { + struct VariantSlot *head; + struct VariantSlot *tail; +}; + +struct ArrayData { + struct VariantSlot *head; + struct VariantSlot *tail; +}; + +struct RawData { + const char *data; + size_t size; +}; + +// A union that defines the actual content of a VariantData. +// The enum VariantType determines which member is in use. +union VariantContent { + Float asFloat; + UInt asInteger; + ArrayData asArray; + ObjectData asObject; + const char *asString; + struct { + const char *data; + size_t size; + } asRaw; +}; + +// this struct must be a POD type to prevent error calling offsetof on clang +struct VariantData { + bool keyIsOwned : 1; + VariantType type : 7; + VariantContent content; +}; + +inline VariantData *getVariantData(ArrayData *arr) { + const ptrdiff_t offset = + offsetof(VariantData, content) - offsetof(VariantContent, asArray); + if (!arr) return 0; + return reinterpret_cast(reinterpret_cast(arr) - + offset); +} + +inline VariantData *getVariantData(ObjectData *obj) { + const ptrdiff_t offset = + offsetof(VariantData, content) - offsetof(VariantContent, asObject); + if (!obj) return 0; + return reinterpret_cast(reinterpret_cast(obj) - + offset); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Data/VariantFunctions.hpp b/src/ArduinoJson/Variant/VariantFunctions.hpp similarity index 72% rename from src/ArduinoJson/Data/VariantFunctions.hpp rename to src/ArduinoJson/Variant/VariantFunctions.hpp index 3b880b73..7d85c617 100644 --- a/src/ArduinoJson/Data/VariantFunctions.hpp +++ b/src/ArduinoJson/Variant/VariantFunctions.hpp @@ -4,16 +4,16 @@ #pragma once +#include "../Array/ArrayFunctions.hpp" +#include "../Misc/SerializedValue.hpp" #include "../Numbers/parseFloat.hpp" #include "../Numbers/parseInteger.hpp" -#include "../SerializedValue.hpp" -#include "ArrayFunctions.hpp" -#include "JsonVariantData.hpp" -#include "ObjectFunctions.hpp" +#include "../Object/ObjectFunctions.hpp" +#include "VariantData.hpp" namespace ARDUINOJSON_NAMESPACE { template -inline T variantAsIntegral(const JsonVariantData* var) { +inline T variantAsIntegral(const VariantData* var) { if (!var) return 0; switch (var->type) { case JSON_POSITIVE_INTEGER: @@ -31,13 +31,13 @@ inline T variantAsIntegral(const JsonVariantData* var) { } } -inline bool variantAsBoolean(const JsonVariantData* var) { +inline bool variantAsBoolean(const VariantData* var) { return variantAsIntegral(var) != 0; } // T = float/double template -inline T variantAsFloat(const JsonVariantData* var) { +inline T variantAsFloat(const VariantData* var) { if (!var) return 0; switch (var->type) { case JSON_POSITIVE_INTEGER: @@ -55,7 +55,7 @@ inline T variantAsFloat(const JsonVariantData* var) { } } -inline const char* variantAsString(const JsonVariantData* var) { +inline const char* variantAsString(const VariantData* var) { if (!var) return 0; switch (var->type) { case JSON_LINKED_STRING: @@ -66,42 +66,42 @@ inline const char* variantAsString(const JsonVariantData* var) { } } -inline JsonArrayData* variantAsArray(JsonVariantData* var) { +inline ArrayData* variantAsArray(VariantData* var) { if (var && var->type == JSON_ARRAY) return &var->content.asArray; else return 0; } -inline const JsonArrayData* variantAsArray(const JsonVariantData* var) { +inline const ArrayData* variantAsArray(const VariantData* var) { if (var && var->type == JSON_ARRAY) return &var->content.asArray; else return 0; } -inline JsonObjectData* variantAsObject(JsonVariantData* var) { +inline ObjectData* variantAsObject(VariantData* var) { if (var && var->type == JSON_OBJECT) return &var->content.asObject; else return 0; } -inline const JsonObjectData* variantAsObject(const JsonVariantData* var) { +inline const ObjectData* variantAsObject(const VariantData* var) { if (var && var->type == JSON_OBJECT) return &var->content.asObject; else return 0; } -inline bool variantSetBoolean(JsonVariantData* var, bool value) { +inline bool variantSetBoolean(VariantData* var, bool value) { if (!var) return false; var->type = JSON_BOOLEAN; - var->content.asInteger = static_cast(value); + var->content.asInteger = static_cast(value); return true; } -inline bool variantSetFloat(JsonVariantData* var, JsonFloat value) { +inline bool variantSetFloat(VariantData* var, Float value) { if (!var) return false; var->type = JSON_FLOAT; var->content.asFloat = value; @@ -109,26 +109,26 @@ inline bool variantSetFloat(JsonVariantData* var, JsonFloat value) { } template -inline bool variantSetSignedInteger(JsonVariantData* var, T value) { +inline bool variantSetSignedInteger(VariantData* var, T value) { if (!var) return false; if (value >= 0) { var->type = JSON_POSITIVE_INTEGER; - var->content.asInteger = static_cast(value); + var->content.asInteger = static_cast(value); } else { var->type = JSON_NEGATIVE_INTEGER; - var->content.asInteger = ~static_cast(value) + 1; + var->content.asInteger = ~static_cast(value) + 1; } return true; } -inline bool variantSetUnsignedInteger(JsonVariantData* var, JsonUInt value) { +inline bool variantSetUnsignedInteger(VariantData* var, UInt value) { if (!var) return false; var->type = JSON_POSITIVE_INTEGER; - var->content.asInteger = static_cast(value); + var->content.asInteger = static_cast(value); return true; } -inline bool variantSetLinkedRaw(JsonVariantData* var, +inline bool variantSetLinkedRaw(VariantData* var, SerializedValue value) { if (!var) return false; var->type = JSON_LINKED_RAW; @@ -138,7 +138,7 @@ inline bool variantSetLinkedRaw(JsonVariantData* var, } template -inline bool variantSetOwnedRaw(JsonVariantData* var, SerializedValue value, +inline bool variantSetOwnedRaw(VariantData* var, SerializedValue value, MemoryPool* pool) { if (!var) return false; char* dup = makeString(value.data(), value.size()).save(pool); @@ -154,7 +154,7 @@ inline bool variantSetOwnedRaw(JsonVariantData* var, SerializedValue value, } template -inline bool variantSetString(JsonVariantData* var, T value, MemoryPool* pool) { +inline bool variantSetString(VariantData* var, T value, MemoryPool* pool) { if (!var) return false; char* dup = value.save(pool); if (dup) { @@ -167,26 +167,26 @@ inline bool variantSetString(JsonVariantData* var, T value, MemoryPool* pool) { } } -inline bool variantSetOwnedString(JsonVariantData* var, char* s) { +inline bool variantSetOwnedString(VariantData* var, char* s) { if (!var) return false; var->type = JSON_OWNED_STRING; var->content.asString = s; return true; } -inline bool variantSetString(JsonVariantData* var, const char* value) { +inline bool variantSetString(VariantData* var, const char* value) { if (!var) return false; var->type = JSON_LINKED_STRING; var->content.asString = value; return true; } -inline void variantSetNull(JsonVariantData* var) { +inline void variantSetNull(VariantData* var) { if (!var) return; var->type = JSON_NULL; } -inline JsonArrayData* variantToArray(JsonVariantData* var) { +inline ArrayData* variantToArray(VariantData* var) { if (!var) return 0; var->type = JSON_ARRAY; var->content.asArray.head = 0; @@ -194,7 +194,7 @@ inline JsonArrayData* variantToArray(JsonVariantData* var) { return &var->content.asArray; } -inline JsonObjectData* variantToObject(JsonVariantData* var) { +inline ObjectData* variantToObject(VariantData* var) { if (!var) return 0; var->type = JSON_OBJECT; var->content.asObject.head = 0; @@ -202,7 +202,7 @@ inline JsonObjectData* variantToObject(JsonVariantData* var) { return &var->content.asObject; } -inline bool variantCopy(JsonVariantData* dst, const JsonVariantData* src, +inline bool variantCopy(VariantData* dst, const VariantData* src, MemoryPool* pool) { if (!dst) return false; if (!src) { @@ -229,35 +229,35 @@ inline bool variantCopy(JsonVariantData* dst, const JsonVariantData* src, } } -inline bool variantIsInteger(const JsonVariantData* var) { +inline bool variantIsInteger(const VariantData* var) { return var && (var->type == JSON_POSITIVE_INTEGER || var->type == JSON_NEGATIVE_INTEGER); } -inline bool variantIsFloat(const JsonVariantData* var) { +inline bool variantIsFloat(const VariantData* var) { return var && (var->type == JSON_FLOAT || var->type == JSON_POSITIVE_INTEGER || var->type == JSON_NEGATIVE_INTEGER); } -inline bool variantIsString(const JsonVariantData* var) { +inline bool variantIsString(const VariantData* var) { return var && (var->type == JSON_LINKED_STRING || var->type == JSON_OWNED_STRING); } -inline bool variantIsArray(const JsonVariantData* var) { +inline bool variantIsArray(const VariantData* var) { return var && var->type == JSON_ARRAY; } -inline bool variantIsObject(const JsonVariantData* var) { +inline bool variantIsObject(const VariantData* var) { return var && var->type == JSON_OBJECT; } -inline bool variantIsNull(const JsonVariantData* var) { +inline bool variantIsNull(const VariantData* var) { return var == 0 || var->type == JSON_NULL; } -inline bool variantEquals(const JsonVariantData* a, const JsonVariantData* b) { +inline bool variantEquals(const VariantData* a, const VariantData* b) { if (a == b) return true; if (!a || !b) return false; if (a->type != b->type) return false; diff --git a/src/ArduinoJson/Variant/VariantImpl.hpp b/src/ArduinoJson/Variant/VariantImpl.hpp new file mode 100644 index 00000000..d808bf22 --- /dev/null +++ b/src/ArduinoJson/Variant/VariantImpl.hpp @@ -0,0 +1,118 @@ +// ArduinoJson - arduinojson.org +// Copyright Benoit Blanchon 2014-2018 +// MIT License + +#pragma once + +#include "../Configuration.hpp" +#include "../Numbers/parseFloat.hpp" +#include "../Numbers/parseInteger.hpp" +#include "VariantRef.hpp" + +#include // for strcmp + +namespace ARDUINOJSON_NAMESPACE { + +inline bool VariantRef::set(ArrayRef array) const { + return to().copyFrom(array); +} + +inline bool VariantRef::set(const ArraySubscript& value) const { + return set(value.as()); +} + +inline bool VariantRef::set(ObjectRef object) const { + return to().copyFrom(object); +} + +template +inline bool VariantRef::set(const ObjectSubscript& value) const { + return set(value.template as()); +} + +inline bool VariantRef::set(VariantConstRef value) const { + return variantCopy(_data, value._data, _memoryPool); +} + +inline bool VariantRef::set(VariantRef value) const { + return variantCopy(_data, value._data, _memoryPool); +} + +template +inline typename enable_if::value, T>::type VariantRef::as() + const { + return ArrayRef(_memoryPool, variantAsArray(_data)); +} + +template +inline typename enable_if::value, T>::type +VariantRef::as() const { + return ObjectRef(_memoryPool, variantAsObject(_data)); +} + +template +inline typename enable_if::value, ArrayRef>::type +VariantRef::to() const { + return ArrayRef(_memoryPool, variantToArray(_data)); +} + +template +typename enable_if::value, ObjectRef>::type +VariantRef::to() const { + return ObjectRef(_memoryPool, variantToObject(_data)); +} + +template +typename enable_if::value, VariantRef>::type +VariantRef::to() const { + variantSetNull(_data); + return *this; +} + +template +inline void VariantRef::accept(Visitor& visitor) const { + return VariantConstRef(_data).accept(visitor); +} + +template +inline void VariantConstRef::accept(Visitor& visitor) const { + if (!_data) return visitor.visitNull(); + + switch (_data->type) { + case JSON_FLOAT: + return visitor.visitFloat(_data->content.asFloat); + + case JSON_ARRAY: + return visitor.visitArray(ArrayConstRef(&_data->content.asArray)); + + case JSON_OBJECT: + return visitor.visitObject(ObjectConstRef(&_data->content.asObject)); + + case JSON_LINKED_STRING: + case JSON_OWNED_STRING: + return visitor.visitString(_data->content.asString); + + case JSON_OWNED_RAW: + case JSON_LINKED_RAW: + return visitor.visitRawJson(_data->content.asRaw.data, + _data->content.asRaw.size); + + case JSON_NEGATIVE_INTEGER: + return visitor.visitNegativeInteger(_data->content.asInteger); + + case JSON_POSITIVE_INTEGER: + return visitor.visitPositiveInteger(_data->content.asInteger); + + case JSON_BOOLEAN: + return visitor.visitBoolean(_data->content.asInteger != 0); + + default: + return visitor.visitNull(); + } +} + +inline VariantConstRef VariantConstRef::operator[](size_t index) const { + return ArrayConstRef(variantAsArray(_data))[index]; +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/JsonVariant.hpp b/src/ArduinoJson/Variant/VariantRef.hpp similarity index 60% rename from src/ArduinoJson/JsonVariant.hpp rename to src/ArduinoJson/Variant/VariantRef.hpp index 930ea2fb..77a768af 100644 --- a/src/ArduinoJson/JsonVariant.hpp +++ b/src/ArduinoJson/Variant/VariantRef.hpp @@ -7,26 +7,26 @@ #include #include // for uint8_t -#include "Data/JsonVariantData.hpp" -#include "Data/VariantAs.hpp" -#include "Data/VariantFunctions.hpp" -#include "JsonVariant.hpp" -#include "JsonVariantBase.hpp" -#include "Memory/MemoryPool.hpp" -#include "Numbers/parseFloat.hpp" -#include "Numbers/parseInteger.hpp" -#include "Polyfills/type_traits.hpp" -#include "Visitable.hpp" +#include "../Memory/MemoryPool.hpp" +#include "../Misc/Visitable.hpp" +#include "../Numbers/parseFloat.hpp" +#include "../Numbers/parseInteger.hpp" +#include "../Operators/VariantOperators.hpp" +#include "../Polyfills/type_traits.hpp" +#include "VariantAs.hpp" +#include "VariantData.hpp" +#include "VariantFunctions.hpp" +#include "VariantRef.hpp" namespace ARDUINOJSON_NAMESPACE { // Forward declarations. -class JsonArray; -class JsonObject; +class ArrayRef; +class ObjectRef; -// Contains the methods shared by JsonVariant and JsonVariantConst +// Contains the methods shared by VariantRef and VariantConstRef template -class JsonVariantProxy { +class VariantRefBase { public: // Tells wether the variant has the specified type. // Returns true if the variant has type type T, false otherwise. @@ -74,20 +74,20 @@ class JsonVariantProxy { return variantIsString(_data); } // - // bool is const; - // bool is const; + // bool is const; + // bool is const; template FORCE_INLINE typename enable_if< - is_same::type, JsonArray>::value, bool>::type + is_same::type, ArrayRef>::value, bool>::type is() const { return variantIsArray(_data); } // - // bool is const; - // bool is const; + // bool is const; + // bool is const; template FORCE_INLINE typename enable_if< - is_same::type, JsonObject>::value, bool>::type + is_same::type, ObjectRef>::value, bool>::type is() const { return variantIsObject(_data); } @@ -106,7 +106,7 @@ class JsonVariantProxy { } protected: - JsonVariantProxy(TData *data) : _data(data) {} + VariantRefBase(TData *data) : _data(data) {} TData *_data; }; @@ -116,20 +116,20 @@ class JsonVariantProxy { // - a boolean // - a char, short, int or a long (signed or unsigned) // - a string (const char*) -// - a reference to a JsonArray or JsonObject -class JsonVariant : public JsonVariantProxy, - public JsonVariantBase, - public Visitable { - typedef JsonVariantProxy proxy_type; - friend class JsonVariantConst; +// - a reference to a ArrayRef or ObjectRef +class VariantRef : public VariantRefBase, + public VariantOperators, + public Visitable { + typedef VariantRefBase base_type; + friend class VariantConstRef; public: // Intenal use only - FORCE_INLINE JsonVariant(MemoryPool *memoryPool, JsonVariantData *data) - : proxy_type(data), _memoryPool(memoryPool) {} + FORCE_INLINE VariantRef(MemoryPool *memoryPool, VariantData *data) + : base_type(data), _memoryPool(memoryPool) {} - // Creates an uninitialized JsonVariant - FORCE_INLINE JsonVariant() : proxy_type(0), _memoryPool(0) {} + // Creates an uninitialized VariantRef + FORCE_INLINE VariantRef() : base_type(0), _memoryPool(0) {} // set(bool value) FORCE_INLINE bool set(bool value) const { @@ -142,7 +142,7 @@ class JsonVariant : public JsonVariantProxy, FORCE_INLINE bool set( T value, typename enable_if::value>::type * = 0) const { - return variantSetFloat(_data, static_cast(value)); + return variantSetFloat(_data, static_cast(value)); } // set(char) @@ -165,7 +165,7 @@ class JsonVariant : public JsonVariantProxy, FORCE_INLINE bool set( T value, typename enable_if::value && is_unsigned::value>::type * = 0) const { - return variantSetUnsignedInteger(_data, static_cast(value)); + return variantSetUnsignedInteger(_data, static_cast(value)); } // set(SerializedValue) @@ -213,43 +213,43 @@ class JsonVariant : public JsonVariantProxy, return variantSetString(_data, value.c_str()); } - bool set(JsonVariantConst value) const; - bool set(JsonVariant value) const; + bool set(VariantConstRef value) const; + bool set(VariantRef value) const; - FORCE_INLINE bool set(JsonArray array) const; - FORCE_INLINE bool set(const JsonArraySubscript &) const; - FORCE_INLINE bool set(JsonObject object) const; + FORCE_INLINE bool set(ArrayRef array) const; + FORCE_INLINE bool set(const ArraySubscript &) const; + FORCE_INLINE bool set(ObjectRef object) const; template - FORCE_INLINE bool set(const JsonObjectSubscript &) const; + FORCE_INLINE bool set(const ObjectSubscript &) const; // Get the variant as the specified type. // // std::string as() const; // String as() const; template - FORCE_INLINE typename enable_if::value && - !is_same::value && - !is_same::value, - typename JsonVariantAs::type>::type + FORCE_INLINE typename enable_if::value && + !is_same::value && + !is_same::value, + typename VariantAs::type>::type as() const { return variantAs(_data); } // - // JsonArray as() const; - // const JsonArray as() const; + // ArrayRef as() const; + // const ArrayRef as() const; template - FORCE_INLINE typename enable_if::value, T>::type as() + FORCE_INLINE typename enable_if::value, T>::type as() const; // - // JsonObject as() const; - // const JsonObject as() const; + // ObjectRef as() const; + // const ObjectRef as() const; template - FORCE_INLINE typename enable_if::value, T>::type as() + FORCE_INLINE typename enable_if::value, T>::type as() const; // - // JsonVariant as const; + // VariantRef as const; template - FORCE_INLINE typename enable_if::value, T>::type as() + FORCE_INLINE typename enable_if::value, T>::type as() const { return *this; } @@ -257,44 +257,43 @@ class JsonVariant : public JsonVariantProxy, template void accept(Visitor &visitor) const; - FORCE_INLINE bool operator==(JsonVariant lhs) const { + FORCE_INLINE bool operator==(VariantRef lhs) const { return variantEquals(_data, lhs._data); } - FORCE_INLINE bool operator!=(JsonVariant lhs) const { + FORCE_INLINE bool operator!=(VariantRef lhs) const { return !variantEquals(_data, lhs._data); } // Change the type of the variant // - // JsonArray to() + // ArrayRef to() template - typename enable_if::value, JsonArray>::type to() const; + typename enable_if::value, ArrayRef>::type to() const; // - // JsonObject to() + // ObjectRef to() template - typename enable_if::value, JsonObject>::type to() - const; + typename enable_if::value, ObjectRef>::type to() const; // - // JsonObject to() + // ObjectRef to() template - typename enable_if::value, JsonVariant>::type to() + typename enable_if::value, VariantRef>::type to() const; private: MemoryPool *_memoryPool; }; -class JsonVariantConst : public JsonVariantProxy, - public JsonVariantBase, - public Visitable { - typedef JsonVariantProxy proxy_type; - friend class JsonVariant; +class VariantConstRef : public VariantRefBase, + public VariantOperators, + public Visitable { + typedef VariantRefBase base_type; + friend class VariantRef; public: - JsonVariantConst() : proxy_type(0) {} - JsonVariantConst(const JsonVariantData *data) : proxy_type(data) {} - JsonVariantConst(JsonVariant var) : proxy_type(var._data) {} + VariantConstRef() : base_type(0) {} + VariantConstRef(const VariantData *data) : base_type(data) {} + VariantConstRef(VariantRef var) : base_type(var._data) {} template void accept(Visitor &visitor) const; @@ -302,29 +301,29 @@ class JsonVariantConst : public JsonVariantProxy, // Get the variant as the specified type. // template - FORCE_INLINE typename JsonVariantConstAs::type as() const { - return variantAs::type>(_data); + FORCE_INLINE typename VariantConstAs::type as() const { + return variantAs::type>(_data); } - FORCE_INLINE JsonVariantConst operator[](size_t index) const; + FORCE_INLINE VariantConstRef operator[](size_t index) const; // - // const JsonVariantConst operator[](TKey) const; + // const VariantConstRef operator[](TKey) const; // TKey = const std::string&, const String& template FORCE_INLINE - typename enable_if::value, JsonVariantConst>::type + typename enable_if::value, VariantConstRef>::type operator[](const TString &key) const { - return JsonVariantConst(objectGet(variantAsObject(_data), makeString(key))); + return VariantConstRef(objectGet(variantAsObject(_data), makeString(key))); } // - // JsonVariantConst operator[](TKey); + // VariantConstRef operator[](TKey); // TKey = const char*, const char[N], const FlashStringHelper* template FORCE_INLINE - typename enable_if::value, JsonVariantConst>::type + typename enable_if::value, VariantConstRef>::type operator[](TString *key) const { - return JsonVariantConst(objectGet(variantAsObject(_data), makeString(key))); + return VariantConstRef(objectGet(variantAsObject(_data), makeString(key))); } }; } // namespace ARDUINOJSON_NAMESPACE diff --git a/src/ArduinoJson/Memory/VariantSlot.hpp b/src/ArduinoJson/Variant/VariantSlot.hpp similarity index 95% rename from src/ArduinoJson/Memory/VariantSlot.hpp rename to src/ArduinoJson/Variant/VariantSlot.hpp index 9f408fe3..1512764a 100644 --- a/src/ArduinoJson/Memory/VariantSlot.hpp +++ b/src/ArduinoJson/Variant/VariantSlot.hpp @@ -4,15 +4,15 @@ #pragma once -#include "../Data/JsonVariantData.hpp" #include "../Polyfills/type_traits.hpp" +#include "../Variant/VariantData.hpp" namespace ARDUINOJSON_NAMESPACE { typedef conditional::type VariantSlotDiff; struct VariantSlot { - JsonVariantData value; + VariantData value; VariantSlotDiff next; VariantSlotDiff prev; const char* key; diff --git a/src/ArduinoJson/Data/JsonVariantTo.hpp b/src/ArduinoJson/Variant/VariantTo.hpp similarity index 51% rename from src/ArduinoJson/Data/JsonVariantTo.hpp rename to src/ArduinoJson/Variant/VariantTo.hpp index 5b5d4f0a..24bd0e94 100644 --- a/src/ArduinoJson/Data/JsonVariantTo.hpp +++ b/src/ArduinoJson/Variant/VariantTo.hpp @@ -5,26 +5,26 @@ #pragma once namespace ARDUINOJSON_NAMESPACE { -class JsonArray; -class JsonObject; -class JsonVariant; +class ArrayRef; +class ObjectRef; +class VariantRef; // A metafunction that returns the type of the value returned by -// JsonVariant::to() +// VariantRef::to() template -struct JsonVariantTo {}; +struct VariantTo {}; template <> -struct JsonVariantTo { - typedef JsonArray type; +struct VariantTo { + typedef ArrayRef type; }; template <> -struct JsonVariantTo { - typedef JsonObject type; +struct VariantTo { + typedef ObjectRef type; }; template <> -struct JsonVariantTo { - typedef JsonVariant type; +struct VariantTo { + typedef VariantRef type; }; } // namespace ARDUINOJSON_NAMESPACE diff --git a/test/Misc/TypeTraits.cpp b/test/Misc/TypeTraits.cpp index 5bd84c84..99b2abf3 100644 --- a/test/Misc/TypeTraits.cpp +++ b/test/Misc/TypeTraits.cpp @@ -13,9 +13,6 @@ TEST_CASE("Polyfills/type_traits") { static_cast(is_base_of::value)); REQUIRE( static_cast(is_base_of::value)); - REQUIRE(static_cast( - is_base_of >, - JsonObjectSubscript >::value)); } SECTION("is_array") { @@ -54,14 +51,14 @@ TEST_CASE("Polyfills/type_traits") { SECTION("IsVisitable") { CHECK(IsVisitable::value == false); CHECK(IsVisitable::value == false); - CHECK(IsVisitable::value == true); - CHECK(IsVisitable::value == true); - CHECK(IsVisitable::value == true); - CHECK(IsVisitable::value == true); - CHECK(IsVisitable::value == true); - CHECK(IsVisitable::value == true); - CHECK(IsVisitable >::value == true); - CHECK(IsVisitable::value == true); + CHECK(IsVisitable::value == true); + CHECK(IsVisitable::value == true); + CHECK(IsVisitable::value == true); + CHECK(IsVisitable::value == true); + CHECK(IsVisitable::value == true); + CHECK(IsVisitable::value == true); + CHECK(IsVisitable >::value == true); + CHECK(IsVisitable::value == true); CHECK(IsVisitable::value == true); CHECK(IsVisitable >::value == true); }