diff options
Diffstat (limited to 'include')
136 files changed, 10934 insertions, 0 deletions
diff --git a/include/lib/ArduinoJson.h b/include/lib/ArduinoJson.h new file mode 100644 index 0000000..28d42ee --- /dev/null +++ b/include/lib/ArduinoJson.h @@ -0,0 +1,73 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "ArduinoJson/Configuration.hpp" + +#if !ARDUINOJSON_DEBUG +#ifdef __clang__ +#pragma clang system_header +#elif defined __GNUC__ +#pragma GCC system_header +#endif +#endif + +#include "ArduinoJson/Array/ArrayRef.hpp" +#include "ArduinoJson/Object/ObjectRef.hpp" +#include "ArduinoJson/Variant/VariantRef.hpp" + +#include "ArduinoJson/Document/DynamicJsonDocument.hpp" +#include "ArduinoJson/Document/StaticJsonDocument.hpp" + +#include "ArduinoJson/Array/ArrayImpl.hpp" +#include "ArduinoJson/Array/ElementProxy.hpp" +#include "ArduinoJson/Array/Utilities.hpp" +#include "ArduinoJson/Collection/CollectionImpl.hpp" +#include "ArduinoJson/Object/MemberProxy.hpp" +#include "ArduinoJson/Object/ObjectImpl.hpp" +#include "ArduinoJson/Variant/ConverterImpl.hpp" +#include "ArduinoJson/Variant/VariantCompare.hpp" +#include "ArduinoJson/Variant/VariantImpl.hpp" + +#include "ArduinoJson/Json/JsonDeserializer.hpp" +#include "ArduinoJson/Json/JsonSerializer.hpp" +#include "ArduinoJson/Json/PrettyJsonSerializer.hpp" +#include "ArduinoJson/MsgPack/MsgPackDeserializer.hpp" +#include "ArduinoJson/MsgPack/MsgPackSerializer.hpp" + +#include "ArduinoJson/compatibility.hpp" + +namespace ArduinoJson { +typedef ARDUINOJSON_NAMESPACE::ArrayConstRef JsonArrayConst; +typedef ARDUINOJSON_NAMESPACE::ArrayRef JsonArray; +typedef ARDUINOJSON_NAMESPACE::Float JsonFloat; +typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger; +typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst; +typedef ARDUINOJSON_NAMESPACE::ObjectRef JsonObject; +typedef ARDUINOJSON_NAMESPACE::Pair JsonPair; +typedef ARDUINOJSON_NAMESPACE::PairConst JsonPairConst; +typedef ARDUINOJSON_NAMESPACE::String JsonString; +typedef ARDUINOJSON_NAMESPACE::UInt JsonUInt; +typedef ARDUINOJSON_NAMESPACE::VariantConstRef JsonVariantConst; +typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant; +using ARDUINOJSON_NAMESPACE::BasicJsonDocument; +using ARDUINOJSON_NAMESPACE::copyArray; +using ARDUINOJSON_NAMESPACE::DeserializationError; +using ARDUINOJSON_NAMESPACE::deserializeJson; +using ARDUINOJSON_NAMESPACE::deserializeMsgPack; +using ARDUINOJSON_NAMESPACE::DynamicJsonDocument; +using ARDUINOJSON_NAMESPACE::JsonDocument; +using ARDUINOJSON_NAMESPACE::measureJson; +using ARDUINOJSON_NAMESPACE::serialized; +using ARDUINOJSON_NAMESPACE::serializeJson; +using ARDUINOJSON_NAMESPACE::serializeJsonPretty; +using ARDUINOJSON_NAMESPACE::serializeMsgPack; +using ARDUINOJSON_NAMESPACE::StaticJsonDocument; + +namespace DeserializationOption { +using ARDUINOJSON_NAMESPACE::Filter; +using ARDUINOJSON_NAMESPACE::NestingLimit; +} // namespace DeserializationOption +} // namespace ArduinoJson diff --git a/include/lib/ArduinoJson/Array/ArrayFunctions.hpp b/include/lib/ArduinoJson/Array/ArrayFunctions.hpp new file mode 100644 index 0000000..e7cdc4c --- /dev/null +++ b/include/lib/ArduinoJson/Array/ArrayFunctions.hpp @@ -0,0 +1,31 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Collection/CollectionData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) { + return arr ? arr->addElement(pool) : 0; +} + +template <typename TVisitor> +inline typename TVisitor::result_type arrayAccept(const CollectionData *arr, + TVisitor &visitor) { + if (arr) + return visitor.visitArray(*arr); + else + return visitor.visitNull(); +} + +inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) { + if (lhs == rhs) + return true; + if (!lhs || !rhs) + return false; + return lhs->equalsArray(*rhs); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Array/ArrayImpl.hpp b/include/lib/ArduinoJson/Array/ArrayImpl.hpp new file mode 100644 index 0000000..ae06b20 --- /dev/null +++ b/include/lib/ArduinoJson/Array/ArrayImpl.hpp @@ -0,0 +1,28 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Array/ArrayRef.hpp> +#include <ArduinoJson/Object/ObjectRef.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TArray> +inline ArrayRef ArrayShortcuts<TArray>::createNestedArray() const { + return impl()->addElement().template to<ArrayRef>(); +} + +template <typename TArray> +inline ObjectRef ArrayShortcuts<TArray>::createNestedObject() const { + return impl()->addElement().template to<ObjectRef>(); +} + +template <typename TArray> +inline ElementProxy<TArray> ArrayShortcuts<TArray>::operator[]( + size_t index) const { + return ElementProxy<TArray>(*impl(), index); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Array/ArrayIterator.hpp b/include/lib/ArduinoJson/Array/ArrayIterator.hpp new file mode 100644 index 0000000..fcacc6b --- /dev/null +++ b/include/lib/ArduinoJson/Array/ArrayIterator.hpp @@ -0,0 +1,121 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Variant/SlotFunctions.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class VariantPtr { + public: + VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {} + + VariantRef *operator->() { + return &_variant; + } + + VariantRef &operator*() { + return _variant; + } + + private: + VariantRef _variant; +}; + +class ArrayIterator { + public: + ArrayIterator() : _slot(0) {} + explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot) + : _pool(pool), _slot(slot) {} + + VariantRef operator*() const { + return VariantRef(_pool, _slot->data()); + } + VariantPtr operator->() { + return VariantPtr(_pool, _slot->data()); + } + + bool operator==(const ArrayIterator &other) const { + return _slot == other._slot; + } + + bool operator!=(const ArrayIterator &other) const { + return _slot != other._slot; + } + + ArrayIterator &operator++() { + _slot = _slot->next(); + return *this; + } + + ArrayIterator &operator+=(size_t distance) { + _slot = _slot->next(distance); + return *this; + } + + VariantSlot *internal() { + return _slot; + } + + private: + MemoryPool *_pool; + 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->data()); + } + VariantConstPtr operator->() { + return VariantConstPtr(_slot->data()); + } + + bool operator==(const ArrayConstRefIterator &other) const { + return _slot == other._slot; + } + + bool operator!=(const ArrayConstRefIterator &other) const { + return _slot != other._slot; + } + + ArrayConstRefIterator &operator++() { + _slot = _slot->next(); + return *this; + } + + ArrayConstRefIterator &operator+=(size_t distance) { + _slot = _slot->next(distance); + return *this; + } + + const VariantSlot *internal() { + return _slot; + } + + private: + const VariantSlot *_slot; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Array/ArrayRef.hpp b/include/lib/ArduinoJson/Array/ArrayRef.hpp new file mode 100644 index 0000000..a991db0 --- /dev/null +++ b/include/lib/ArduinoJson/Array/ArrayRef.hpp @@ -0,0 +1,205 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Array/ArrayFunctions.hpp> +#include <ArduinoJson/Array/ArrayIterator.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +// Returns the size (in bytes) of an array with n elements. +// Can be very handy to determine the size of a StaticMemoryPool. +#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \ + ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot)) + +namespace ARDUINOJSON_NAMESPACE { + +class ObjectRef; +template <typename> +class ElementProxy; + +template <typename TData> +class ArrayRefBase { + public: + operator VariantConstRef() const { + const void* data = _data; // prevent warning cast-align + return VariantConstRef(reinterpret_cast<const VariantData*>(data)); + } + + template <typename TVisitor> + FORCE_INLINE typename TVisitor::result_type accept(TVisitor& visitor) const { + return arrayAccept(_data, visitor); + } + + FORCE_INLINE bool isNull() const { + return _data == 0; + } + + FORCE_INLINE operator bool() const { + return _data != 0; + } + + FORCE_INLINE size_t memoryUsage() const { + return _data ? _data->memoryUsage() : 0; + } + + FORCE_INLINE size_t nesting() const { + return _data ? _data->nesting() : 0; + } + + FORCE_INLINE size_t size() const { + return _data ? _data->size() : 0; + } + + protected: + ArrayRefBase(TData* data) : _data(data) {} + TData* _data; +}; + +class ArrayConstRef : public ArrayRefBase<const CollectionData>, + public Visitable { + friend class ArrayRef; + typedef ArrayRefBase<const CollectionData> base_type; + + public: + typedef ArrayConstRefIterator iterator; + + FORCE_INLINE iterator begin() const { + if (!_data) + return iterator(); + return iterator(_data->head()); + } + + FORCE_INLINE iterator end() const { + return iterator(); + } + + FORCE_INLINE ArrayConstRef() : base_type(0) {} + FORCE_INLINE ArrayConstRef(const CollectionData* data) : base_type(data) {} + + FORCE_INLINE bool operator==(ArrayConstRef rhs) const { + return arrayEquals(_data, rhs._data); + } + + FORCE_INLINE VariantConstRef operator[](size_t index) const { + return getElement(index); + } + + FORCE_INLINE VariantConstRef getElement(size_t index) const { + return VariantConstRef(_data ? _data->getElement(index) : 0); + } +}; + +class ArrayRef : public ArrayRefBase<CollectionData>, + public ArrayShortcuts<ArrayRef>, + public Visitable { + typedef ArrayRefBase<CollectionData> base_type; + + public: + typedef ArrayIterator iterator; + + FORCE_INLINE ArrayRef() : base_type(0), _pool(0) {} + FORCE_INLINE ArrayRef(MemoryPool* pool, CollectionData* data) + : base_type(data), _pool(pool) {} + + operator VariantRef() { + void* data = _data; // prevent warning cast-align + return VariantRef(_pool, reinterpret_cast<VariantData*>(data)); + } + + operator ArrayConstRef() const { + return ArrayConstRef(_data); + } + + VariantRef addElement() const { + return VariantRef(_pool, arrayAdd(_data, _pool)); + } + + FORCE_INLINE iterator begin() const { + if (!_data) + return iterator(); + return iterator(_pool, _data->head()); + } + + FORCE_INLINE iterator end() const { + return iterator(); + } + + // Copy a ArrayRef + FORCE_INLINE bool set(ArrayConstRef src) const { + if (!_data || !src._data) + return false; + return _data->copyFrom(*src._data, _pool); + } + + FORCE_INLINE bool operator==(ArrayRef rhs) const { + return arrayEquals(_data, rhs._data); + } + + // Internal use + FORCE_INLINE VariantRef getOrAddElement(size_t index) const { + return VariantRef(_pool, _data ? _data->getOrAddElement(index, _pool) : 0); + } + + // Gets the value at the specified index. + FORCE_INLINE VariantRef getElement(size_t index) const { + return VariantRef(_pool, _data ? _data->getElement(index) : 0); + } + + // Removes element at specified position. + FORCE_INLINE void remove(iterator it) const { + if (!_data) + return; + _data->removeSlot(it.internal()); + } + + // Removes element at specified index. + FORCE_INLINE void remove(size_t index) const { + if (!_data) + return; + _data->removeElement(index); + } + + private: + MemoryPool* _pool; +}; + +template <> +struct Converter<ArrayConstRef> { + static bool toJson(VariantConstRef src, VariantRef dst) { + return variantCopyFrom(getData(dst), getData(src), getPool(dst)); + } + + static ArrayConstRef fromJson(VariantConstRef src) { + return ArrayConstRef(variantAsArray(getData(src))); + } + + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data && data->isArray(); + } +}; + +template <> +struct Converter<ArrayRef> { + static bool toJson(VariantConstRef src, VariantRef dst) { + return variantCopyFrom(getData(dst), getData(src), getPool(dst)); + } + + static ArrayRef fromJson(VariantRef src) { + VariantData* data = getData(src); + MemoryPool* pool = getPool(src); + return ArrayRef(pool, data != 0 ? data->asArray() : 0); + } + + static bool checkJson(VariantConstRef) { + return false; + } + + static bool checkJson(VariantRef src) { + VariantData* data = getData(src); + return data && data->isArray(); + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Array/ArrayShortcuts.hpp b/include/lib/ArduinoJson/Array/ArrayShortcuts.hpp new file mode 100644 index 0000000..fd26d04 --- /dev/null +++ b/include/lib/ArduinoJson/Array/ArrayShortcuts.hpp @@ -0,0 +1,49 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/attributes.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> + +namespace ARDUINOJSON_NAMESPACE { +// Forward declarations. +class ArrayRef; +class ObjectRef; +template <typename> +class ElementProxy; + +template <typename TArray> +class ArrayShortcuts { + public: + // Returns the element at specified index if the variant is an array. + FORCE_INLINE ElementProxy<TArray> operator[](size_t index) const; + + FORCE_INLINE ObjectRef createNestedObject() const; + + FORCE_INLINE ArrayRef createNestedArray() const; + + // Adds the specified value at the end of the array. + // + // bool add(TValue); + // TValue = bool, long, int, short, float, double, serialized, VariantRef, + // std::string, String, ObjectRef + template <typename T> + FORCE_INLINE bool add(const T &value) const { + return impl()->addElement().set(value); + } + // + // bool add(TValue); + // TValue = char*, const char*, const __FlashStringHelper* + template <typename T> + FORCE_INLINE bool add(T *value) const { + return impl()->addElement().set(value); + } + + private: + const TArray *impl() const { + return static_cast<const TArray *>(this); + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Array/ElementProxy.hpp b/include/lib/ArduinoJson/Array/ElementProxy.hpp new file mode 100644 index 0000000..c6062e4 --- /dev/null +++ b/include/lib/ArduinoJson/Array/ElementProxy.hpp @@ -0,0 +1,193 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Variant/VariantOperators.hpp> +#include <ArduinoJson/Variant/VariantShortcuts.hpp> +#include <ArduinoJson/Variant/VariantTo.hpp> + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4522) +#endif + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TArray> +class ElementProxy : public VariantOperators<ElementProxy<TArray> >, + public VariantShortcuts<ElementProxy<TArray> >, + public Visitable, + public VariantTag { + typedef ElementProxy<TArray> this_type; + + public: + typedef VariantRef variant_type; + + FORCE_INLINE ElementProxy(TArray array, size_t index) + : _array(array), _index(index) {} + + FORCE_INLINE ElementProxy(const ElementProxy& src) + : _array(src._array), _index(src._index) {} + + FORCE_INLINE this_type& operator=(const this_type& src) { + getOrAddUpstreamElement().set(src.as<VariantConstRef>()); + return *this; + } + + // Replaces the value + // + // operator=(const TValue&) + // TValue = bool, long, int, short, float, double, serialized, VariantRef, + // std::string, String, ArrayRef, ObjectRef + template <typename T> + FORCE_INLINE this_type& operator=(const T& src) { + getOrAddUpstreamElement().set(src); + return *this; + } + // + // operator=(TValue) + // TValue = char*, const char*, const __FlashStringHelper* + template <typename T> + FORCE_INLINE this_type& operator=(T* src) { + getOrAddUpstreamElement().set(src); + return *this; + } + + FORCE_INLINE void clear() const { + getUpstreamElement().clear(); + } + + FORCE_INLINE bool isNull() const { + return getUpstreamElement().isNull(); + } + + template <typename T> + FORCE_INLINE typename enable_if<!is_same<T, char*>::value, T>::type as() + const { + return getUpstreamElement().template as<T>(); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type + ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()") + as() const { + return as<const char*>(); + } + + template <typename T> + FORCE_INLINE operator T() const { + return getUpstreamElement(); + } + + template <typename T> + FORCE_INLINE bool is() const { + return getUpstreamElement().template is<T>(); + } + + template <typename T> + FORCE_INLINE typename VariantTo<T>::type to() const { + return getOrAddUpstreamElement().template to<T>(); + } + + // Replaces the value + // + // bool set(const TValue&) + // TValue = bool, long, int, short, float, double, serialized, VariantRef, + // std::string, String, ArrayRef, ObjectRef + template <typename TValue> + FORCE_INLINE bool set(const TValue& value) const { + return getOrAddUpstreamElement().set(value); + } + // + // bool set(TValue) + // TValue = char*, const char*, const __FlashStringHelper* + template <typename TValue> + FORCE_INLINE bool set(TValue* value) const { + return getOrAddUpstreamElement().set(value); + } + + template <typename TVisitor> + typename TVisitor::result_type accept(TVisitor& visitor) const { + return getUpstreamElement().accept(visitor); + } + + FORCE_INLINE size_t size() const { + return getUpstreamElement().size(); + } + + template <typename TNestedKey> + VariantRef getMember(TNestedKey* key) const { + return getUpstreamElement().getMember(key); + } + + template <typename TNestedKey> + VariantRef getMember(const TNestedKey& key) const { + return getUpstreamElement().getMember(key); + } + + template <typename TNestedKey> + VariantRef getOrAddMember(TNestedKey* key) const { + return getOrAddUpstreamElement().getOrAddMember(key); + } + + template <typename TNestedKey> + VariantRef getOrAddMember(const TNestedKey& key) const { + return getOrAddUpstreamElement().getOrAddMember(key); + } + + VariantRef addElement() const { + return getOrAddUpstreamElement().addElement(); + } + + VariantRef getElement(size_t index) const { + return getOrAddUpstreamElement().getElement(index); + } + + VariantRef getOrAddElement(size_t index) const { + return getOrAddUpstreamElement().getOrAddElement(index); + } + + FORCE_INLINE void remove(size_t index) const { + getUpstreamElement().remove(index); + } + // remove(char*) const + // remove(const char*) const + // remove(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove( + TChar* key) const { + getUpstreamElement().remove(key); + } + // remove(const std::string&) const + // remove(const String&) const + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove( + const TString& key) const { + getUpstreamElement().remove(key); + } + + private: + FORCE_INLINE VariantRef getUpstreamElement() const { + return _array.getElement(_index); + } + + FORCE_INLINE VariantRef getOrAddUpstreamElement() const { + return _array.getOrAddElement(_index); + } + + friend bool convertToJson(const this_type& src, VariantRef dst) { + return dst.set(src.getUpstreamElement()); + } + + TArray _array; + const size_t _index; +}; + +} // namespace ARDUINOJSON_NAMESPACE + +#ifdef _MSC_VER +#pragma warning(pop) +#endif diff --git a/include/lib/ArduinoJson/Array/Utilities.hpp b/include/lib/ArduinoJson/Array/Utilities.hpp new file mode 100644 index 0000000..619b91d --- /dev/null +++ b/include/lib/ArduinoJson/Array/Utilities.hpp @@ -0,0 +1,133 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Array/ArrayRef.hpp> +#include <ArduinoJson/Document/JsonDocument.hpp> +#include <ArduinoJson/Variant/Visitor.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// Copy a 1D array to a JsonArray +template <typename T, size_t N, typename TDestination> +inline typename enable_if<!is_array<T>::value && + !is_base_of<JsonDocument, TDestination>::value, + bool>::type +copyArray(T (&src)[N], const TDestination& dst) { + return copyArray(src, N, dst); +} + +// Copy a 1D array to a JsonDocument +template <typename T, size_t N> +inline bool copyArray(T (&src)[N], JsonDocument& dst) { + return copyArray(src, dst.to<ArrayRef>()); +} + +// Copy a 1D array to a JsonArray +template <typename T, typename TDestination> +inline typename enable_if<!is_array<T>::value && + !is_base_of<JsonDocument, TDestination>::value, + bool>::type +copyArray(T* src, size_t len, const TDestination& dst) { + bool ok = true; + for (size_t i = 0; i < len; i++) { + ok &= dst.add(src[i]); + } + return ok; +} + +// Copy a 1D array to a JsonDocument +template <typename T> +inline bool copyArray(T* src, size_t len, JsonDocument& dst) { + return copyArray(src, len, dst.to<ArrayRef>()); +} + +// Copy a 2D array to a JsonArray +template <typename T, size_t N1, size_t N2, typename TDestination> +inline typename enable_if<!is_base_of<JsonDocument, TDestination>::value, + bool>::type +copyArray(T (&src)[N1][N2], const TDestination& dst) { + bool ok = true; + for (size_t i = 0; i < N1; i++) { + ArrayRef nestedArray = dst.createNestedArray(); + for (size_t j = 0; j < N2; j++) { + ok &= nestedArray.add(src[i][j]); + } + } + return ok; +} + +// Copy a 2D array to a JsonDocument +template <typename T, size_t N1, size_t N2> +inline bool copyArray(T (&src)[N1][N2], JsonDocument& dst) { + return copyArray(src, dst.to<ArrayRef>()); +} + +template <typename T> +class ArrayCopier1D : public Visitor<size_t> { + public: + ArrayCopier1D(T* destination, size_t capacity) + : _destination(destination), _capacity(capacity) {} + + size_t visitArray(const CollectionData& array) { + size_t size = 0; + VariantSlot* slot = array.head(); + + while (slot != 0 && size < _capacity) { + _destination[size++] = + Converter<T>::fromJson(VariantConstRef(slot->data())); + slot = slot->next(); + } + return size; + } + + private: + T* _destination; + size_t _capacity; +}; + +template <typename T, size_t N1, size_t N2> +class ArrayCopier2D : public Visitor<void> { + public: + ArrayCopier2D(T (*destination)[N1][N2]) : _destination(destination) {} + + void visitArray(const CollectionData& array) { + VariantSlot* slot = array.head(); + size_t n = 0; + while (slot != 0 && n < N1) { + ArrayCopier1D<T> copier((*_destination)[n++], N2); + variantAccept(slot->data(), copier); + slot = slot->next(); + } + } + + private: + T (*_destination)[N1][N2]; + size_t _capacity1, _capacity2; +}; + +// Copy a JsonArray to a 1D array +template <typename TSource, typename T, size_t N> +inline typename enable_if<!is_array<T>::value, size_t>::type copyArray( + const TSource& src, T (&dst)[N]) { + return copyArray(src, dst, N); +} + +// Copy a JsonArray to a 1D array +template <typename TSource, typename T> +inline size_t copyArray(const TSource& src, T* dst, size_t len) { + ArrayCopier1D<T> copier(dst, len); + + return src.accept(copier); +} + +// Copy a JsonArray to a 2D array +template <typename TSource, typename T, size_t N1, size_t N2> +inline void copyArray(const TSource& src, T (&dst)[N1][N2]) { + ArrayCopier2D<T, N1, N2> copier(&dst); + src.accept(copier); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Collection/CollectionData.hpp b/include/lib/ArduinoJson/Collection/CollectionData.hpp new file mode 100644 index 0000000..d2bca45 --- /dev/null +++ b/include/lib/ArduinoJson/Collection/CollectionData.hpp @@ -0,0 +1,88 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> + +#include <stddef.h> // size_t + +namespace ARDUINOJSON_NAMESPACE { + +class MemoryPool; +class VariantData; +class VariantSlot; + +class CollectionData { + VariantSlot *_head; + VariantSlot *_tail; + + public: + // Must be a POD! + // - no constructor + // - no destructor + // - no virtual + // - no inheritance + + // Array only + + VariantData *addElement(MemoryPool *pool); + + VariantData *getElement(size_t index) const; + + VariantData *getOrAddElement(size_t index, MemoryPool *pool); + + void removeElement(size_t index); + + bool equalsArray(const CollectionData &other) const; + + // Object only + + template <typename TAdaptedString> + VariantData *addMember(TAdaptedString key, MemoryPool *pool); + + template <typename TAdaptedString> + VariantData *getMember(TAdaptedString key) const; + + template <typename TAdaptedString> + VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool); + + template <typename TAdaptedString> + void removeMember(TAdaptedString key) { + removeSlot(getSlot(key)); + } + + template <typename TAdaptedString> + bool containsKey(const TAdaptedString &key) const; + + bool equalsObject(const CollectionData &other) const; + + // Generic + + void clear(); + size_t memoryUsage() const; + size_t nesting() const; + size_t size() const; + + VariantSlot *addSlot(MemoryPool *); + void removeSlot(VariantSlot *slot); + + bool copyFrom(const CollectionData &src, MemoryPool *pool); + + VariantSlot *head() const { + return _head; + } + + void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance); + + private: + VariantSlot *getSlot(size_t index) const; + + template <typename TAdaptedString> + VariantSlot *getSlot(TAdaptedString key) const; + + VariantSlot *getPreviousSlot(VariantSlot *) const; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Collection/CollectionImpl.hpp b/include/lib/ArduinoJson/Collection/CollectionImpl.hpp new file mode 100644 index 0000000..49a24be --- /dev/null +++ b/include/lib/ArduinoJson/Collection/CollectionImpl.hpp @@ -0,0 +1,234 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Collection/CollectionData.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +inline bool variantEquals(const VariantData* a, const VariantData* b) { + return variantCompare(a, b) == COMPARE_RESULT_EQUAL; +} + +inline VariantSlot* CollectionData::addSlot(MemoryPool* pool) { + VariantSlot* slot = pool->allocVariant(); + if (!slot) + return 0; + + if (_tail) { + _tail->setNextNotNull(slot); + _tail = slot; + } else { + _head = slot; + _tail = slot; + } + + slot->clear(); + return slot; +} + +inline VariantData* CollectionData::addElement(MemoryPool* pool) { + return slotData(addSlot(pool)); +} + +template <typename TAdaptedString> +inline VariantData* CollectionData::addMember(TAdaptedString key, + MemoryPool* pool) { + VariantSlot* slot = addSlot(pool); + if (!slotSetKey(slot, key, pool)) { + removeSlot(slot); + return 0; + } + return slot->data(); +} + +inline void CollectionData::clear() { + _head = 0; + _tail = 0; +} + +template <typename TAdaptedString> +inline bool CollectionData::containsKey(const TAdaptedString& key) const { + return getSlot(key) != 0; +} + +inline bool CollectionData::copyFrom(const CollectionData& src, + MemoryPool* pool) { + clear(); + for (VariantSlot* s = src._head; s; s = s->next()) { + VariantData* var; + if (s->key() != 0) { + if (s->ownsKey()) + var = addMember(RamStringAdapter(s->key()), pool); + else + var = addMember(ConstRamStringAdapter(s->key()), pool); + } else { + var = addElement(pool); + } + if (!var) + return false; + if (!var->copyFrom(*s->data(), pool)) + return false; + } + return true; +} + +inline bool CollectionData::equalsObject(const CollectionData& other) const { + size_t count = 0; + for (VariantSlot* slot = _head; slot; slot = slot->next()) { + VariantData* v1 = slot->data(); + VariantData* v2 = other.getMember(adaptString(slot->key())); + if (!variantEquals(v1, v2)) + return false; + count++; + } + return count == other.size(); +} + +inline bool CollectionData::equalsArray(const CollectionData& other) const { + VariantSlot* s1 = _head; + VariantSlot* s2 = other._head; + for (;;) { + if (s1 == s2) + return true; + if (!s1 || !s2) + return false; + if (!variantEquals(s1->data(), s2->data())) + return false; + s1 = s1->next(); + s2 = s2->next(); + } +} + +template <typename TAdaptedString> +inline VariantSlot* CollectionData::getSlot(TAdaptedString key) const { + VariantSlot* slot = _head; + while (slot) { + if (key.equals(slot->key())) + break; + slot = slot->next(); + } + return slot; +} + +inline VariantSlot* CollectionData::getSlot(size_t index) const { + if (!_head) + return 0; + return _head->next(index); +} + +inline VariantSlot* CollectionData::getPreviousSlot(VariantSlot* target) const { + VariantSlot* current = _head; + while (current) { + VariantSlot* next = current->next(); + if (next == target) + return current; + current = next; + } + return 0; +} + +template <typename TAdaptedString> +inline VariantData* CollectionData::getMember(TAdaptedString key) const { + VariantSlot* slot = getSlot(key); + return slot ? slot->data() : 0; +} + +template <typename TAdaptedString> +inline VariantData* CollectionData::getOrAddMember(TAdaptedString key, + MemoryPool* pool) { + // ignore null key + if (key.isNull()) + return 0; + + // search a matching key + VariantSlot* slot = getSlot(key); + if (slot) + return slot->data(); + + return addMember(key, pool); +} + +inline VariantData* CollectionData::getElement(size_t index) const { + VariantSlot* slot = getSlot(index); + return slot ? slot->data() : 0; +} + +inline VariantData* CollectionData::getOrAddElement(size_t index, + MemoryPool* pool) { + VariantSlot* slot = _head; + while (slot && index > 0) { + slot = slot->next(); + index--; + } + if (!slot) + index++; + while (index > 0) { + slot = addSlot(pool); + index--; + } + return slotData(slot); +} + +inline void CollectionData::removeSlot(VariantSlot* slot) { + if (!slot) + return; + VariantSlot* prev = getPreviousSlot(slot); + VariantSlot* next = slot->next(); + if (prev) + prev->setNext(next); + else + _head = next; + if (!next) + _tail = prev; +} + +inline void CollectionData::removeElement(size_t index) { + removeSlot(getSlot(index)); +} + +inline size_t CollectionData::memoryUsage() const { + size_t total = 0; + for (VariantSlot* s = _head; s; s = s->next()) { + total += sizeof(VariantSlot) + s->data()->memoryUsage(); + if (s->ownsKey()) + total += strlen(s->key()) + 1; + } + return total; +} + +inline size_t CollectionData::nesting() const { + size_t maxChildNesting = 0; + for (VariantSlot* s = _head; s; s = s->next()) { + size_t childNesting = s->data()->nesting(); + if (childNesting > maxChildNesting) + maxChildNesting = childNesting; + } + return maxChildNesting + 1; +} + +inline size_t CollectionData::size() const { + return slotSize(_head); +} + +template <typename T> +inline void movePointer(T*& p, ptrdiff_t offset) { + if (!p) + return; + p = reinterpret_cast<T*>( + reinterpret_cast<void*>(reinterpret_cast<char*>(p) + offset)); + ARDUINOJSON_ASSERT(isAligned(p)); +} + +inline void CollectionData::movePointers(ptrdiff_t stringDistance, + ptrdiff_t variantDistance) { + movePointer(_head, variantDistance); + movePointer(_tail, variantDistance); + for (VariantSlot* slot = _head; slot; slot = slot->next()) + slot->movePointers(stringDistance, variantDistance); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Configuration.hpp b/include/lib/ArduinoJson/Configuration.hpp new file mode 100644 index 0000000..0c0d4c4 --- /dev/null +++ b/include/lib/ArduinoJson/Configuration.hpp @@ -0,0 +1,255 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#if __cplusplus >= 201103L +#define ARDUINOJSON_HAS_LONG_LONG 1 +#define ARDUINOJSON_HAS_NULLPTR 1 +#define ARDUINOJSON_HAS_RVALUE_REFERENCES 1 +#else +#define ARDUINOJSON_HAS_LONG_LONG 0 +#define ARDUINOJSON_HAS_NULLPTR 0 +#define ARDUINOJSON_HAS_RVALUE_REFERENCES 0 +#endif + +#if defined(_MSC_VER) && !ARDUINOJSON_HAS_LONG_LONG +#define ARDUINOJSON_HAS_INT64 1 +#else +#define ARDUINOJSON_HAS_INT64 0 +#endif + +// Small or big machine? +#ifndef ARDUINOJSON_EMBEDDED_MODE +#if defined(ARDUINO) /* Arduino*/ \ + || defined(__IAR_SYSTEMS_ICC__) /* IAR Embedded Workbench */ \ + || defined(__XC) /* MPLAB XC compiler */ \ + || defined(__ARMCC_VERSION) /* Keil ARM Compiler */ \ + || defined(__AVR) /* Atmel AVR8/GNU C Compiler */ +#define ARDUINOJSON_EMBEDDED_MODE 1 +#else +#define ARDUINOJSON_EMBEDDED_MODE 0 +#endif +#endif + +// Auto enable std::stream if the right headers are here and no conflicting +// macro is defined +#if !defined(ARDUINOJSON_ENABLE_STD_STREAM) && defined(__has_include) +#if __has_include(<istream>) && \ + __has_include(<ostream>) && \ + !defined(min) && \ + !defined(max) +#define ARDUINOJSON_ENABLE_STD_STREAM 1 +#else +#define ARDUINOJSON_ENABLE_STD_STREAM 0 +#endif +#endif + +// Auto enable std::string if the right header is here and no conflicting +// macro is defined +#if !defined(ARDUINOJSON_ENABLE_STD_STRING) && defined(__has_include) +#if __has_include(<string>) && !defined(min) && !defined(max) +#define ARDUINOJSON_ENABLE_STD_STRING 1 +#else +#define ARDUINOJSON_ENABLE_STD_STRING 0 +#endif +#endif + +#if ARDUINOJSON_EMBEDDED_MODE + +// Store floats by default to reduce the memory usage (issue #134) +#ifndef ARDUINOJSON_USE_DOUBLE +#define ARDUINOJSON_USE_DOUBLE 0 +#endif + +// Store longs by default, because they usually match the size of a float. +#ifndef ARDUINOJSON_USE_LONG_LONG +#define ARDUINOJSON_USE_LONG_LONG 0 +#endif + +// Embedded systems usually don't have std::string +#ifndef ARDUINOJSON_ENABLE_STD_STRING +#define ARDUINOJSON_ENABLE_STD_STRING 0 +#endif + +// Embedded systems usually don't have std::stream +#ifndef ARDUINOJSON_ENABLE_STD_STREAM +#define ARDUINOJSON_ENABLE_STD_STREAM 0 +#endif + +// Limit nesting as the stack is likely to be small +#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT +#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10 +#endif + +// Number of bits to store the pointer to next node +// (saves RAM but limits the number of values in a document) +#ifndef ARDUINOJSON_SLOT_OFFSET_SIZE +#if defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 2 +// Address space == 16-bit => max 127 values +#define ARDUINOJSON_SLOT_OFFSET_SIZE 1 +#else +// Address space > 16-bit => max 32767 values +#define ARDUINOJSON_SLOT_OFFSET_SIZE 2 +#endif +#endif + +#else // ARDUINOJSON_EMBEDDED_MODE + +// On a computer we have plenty of memory so we can use doubles +#ifndef ARDUINOJSON_USE_DOUBLE +#define ARDUINOJSON_USE_DOUBLE 1 +#endif + +// Use long long when available +#ifndef ARDUINOJSON_USE_LONG_LONG +#if ARDUINOJSON_HAS_LONG_LONG || ARDUINOJSON_HAS_INT64 +#define ARDUINOJSON_USE_LONG_LONG 1 +#else +#define ARDUINOJSON_USE_LONG_LONG 0 +#endif +#endif + +// On a computer, we can use std::string +#ifndef ARDUINOJSON_ENABLE_STD_STRING +#define ARDUINOJSON_ENABLE_STD_STRING 1 +#endif + +// On a computer, we can assume std::stream +#ifndef ARDUINOJSON_ENABLE_STD_STREAM +#define ARDUINOJSON_ENABLE_STD_STREAM 1 +#endif + +// On a computer, the stack is large so we can increase nesting limit +#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT +#define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50 +#endif + +// Number of bits to store the pointer to next node +#ifndef ARDUINOJSON_SLOT_OFFSET_SIZE +#define ARDUINOJSON_SLOT_OFFSET_SIZE 4 +#endif + +#endif // ARDUINOJSON_EMBEDDED_MODE + +#ifdef ARDUINO + +#include <Arduino.h> + +// Enable support for Arduino's String class +#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING +#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1 +#endif + +// Enable support for Arduino's Stream class +#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM +#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1 +#endif + +// Enable support for Arduino's Print class +#ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT +#define ARDUINOJSON_ENABLE_ARDUINO_PRINT 1 +#endif + +#else // ARDUINO + +// Disable support for Arduino's String class +#ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING +#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0 +#endif + +// Disable support for Arduino's Stream class +#ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM +#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0 +#endif + +// Disable support for Arduino's Print class +#ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT +#define ARDUINOJSON_ENABLE_ARDUINO_PRINT 0 +#endif + +#endif // ARDUINO + +#ifndef ARDUINOJSON_ENABLE_PROGMEM +#if defined(PROGMEM) && defined(pgm_read_byte) && defined(pgm_read_dword) && \ + defined(pgm_read_ptr) && defined(pgm_read_float) +#define ARDUINOJSON_ENABLE_PROGMEM 1 +#else +#define ARDUINOJSON_ENABLE_PROGMEM 0 +#endif +#endif + +// Convert unicode escape sequence (\u0123) to UTF-8 +#ifndef ARDUINOJSON_DECODE_UNICODE +#define ARDUINOJSON_DECODE_UNICODE 1 +#endif + +// Ignore comments in input +#ifndef ARDUINOJSON_ENABLE_COMMENTS +#define ARDUINOJSON_ENABLE_COMMENTS 0 +#endif + +// Support NaN in JSON +#ifndef ARDUINOJSON_ENABLE_NAN +#define ARDUINOJSON_ENABLE_NAN 0 +#endif + +// Support Infinity in JSON +#ifndef ARDUINOJSON_ENABLE_INFINITY +#define ARDUINOJSON_ENABLE_INFINITY 0 +#endif + +// Control the exponentiation threshold for big numbers +// CAUTION: cannot be more that 1e9 !!!! +#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD +#define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7 +#endif + +// Control the exponentiation threshold for small numbers +#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD +#define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5 +#endif + +#ifndef ARDUINOJSON_LITTLE_ENDIAN +#if defined(_MSC_VER) || \ + (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \ + defined(__LITTLE_ENDIAN__) || defined(__i386) || defined(__x86_64) +#define ARDUINOJSON_LITTLE_ENDIAN 1 +#else +#define ARDUINOJSON_LITTLE_ENDIAN 0 +#endif +#endif + +#ifndef ARDUINOJSON_ENABLE_ALIGNMENT +#if defined(__AVR) +#define ARDUINOJSON_ENABLE_ALIGNMENT 0 +#else +#define ARDUINOJSON_ENABLE_ALIGNMENT 1 +#endif +#endif + +#ifndef ARDUINOJSON_TAB +#define ARDUINOJSON_TAB " " +#endif + +#ifndef ARDUINOJSON_ENABLE_STRING_DEDUPLICATION +#define ARDUINOJSON_ENABLE_STRING_DEDUPLICATION 1 +#endif + +#ifndef ARDUINOJSON_STRING_BUFFER_SIZE +#define ARDUINOJSON_STRING_BUFFER_SIZE 32 +#endif + +#ifndef ARDUINOJSON_DEBUG +#ifdef __PLATFORMIO_BUILD_DEBUG__ +#define ARDUINOJSON_DEBUG 1 +#else +#define ARDUINOJSON_DEBUG 0 +#endif +#endif + +#if ARDUINOJSON_HAS_NULLPTR && defined(nullptr) +#error nullptr is defined as a macro. Remove the faulty #define or #undef nullptr +// See https://github.com/bblanchon/ArduinoJson/issues/1355 +#endif diff --git a/include/lib/ArduinoJson/Deserialization/DeserializationError.hpp b/include/lib/ArduinoJson/Deserialization/DeserializationError.hpp new file mode 100644 index 0000000..7b61711 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/DeserializationError.hpp @@ -0,0 +1,122 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Polyfills/preprocessor.hpp> +#include <ArduinoJson/Polyfills/static_array.hpp> + +#if ARDUINOJSON_ENABLE_STD_STREAM +#include <ostream> +#endif + +namespace ARDUINOJSON_NAMESPACE { + +class DeserializationError { + // safe bool idiom + typedef void (DeserializationError::*bool_type)() const; + void safeBoolHelper() const {} + + public: + enum Code { + Ok, + EmptyInput, + IncompleteInput, + InvalidInput, + NoMemory, + TooDeep + }; + + DeserializationError() {} + DeserializationError(Code c) : _code(c) {} + + // Compare with DeserializationError + friend bool operator==(const DeserializationError& lhs, + const DeserializationError& rhs) { + return lhs._code == rhs._code; + } + friend bool operator!=(const DeserializationError& lhs, + const DeserializationError& rhs) { + return lhs._code != rhs._code; + } + + // Compare with Code + friend bool operator==(const DeserializationError& lhs, Code rhs) { + return lhs._code == rhs; + } + friend bool operator==(Code lhs, const DeserializationError& rhs) { + return lhs == rhs._code; + } + friend bool operator!=(const DeserializationError& lhs, Code rhs) { + return lhs._code != rhs; + } + friend bool operator!=(Code lhs, const DeserializationError& rhs) { + return lhs != rhs._code; + } + + // Behaves like a bool + operator bool_type() const { + return _code != Ok ? &DeserializationError::safeBoolHelper : 0; + } + friend bool operator==(bool value, const DeserializationError& err) { + return static_cast<bool>(err) == value; + } + friend bool operator==(const DeserializationError& err, bool value) { + return static_cast<bool>(err) == value; + } + friend bool operator!=(bool value, const DeserializationError& err) { + return static_cast<bool>(err) != value; + } + friend bool operator!=(const DeserializationError& err, bool value) { + return static_cast<bool>(err) != value; + } + + // Returns internal enum, useful for switch statement + Code code() const { + return _code; + } + + const char* c_str() const { + static const char* messages[] = { + "Ok", "EmptyInput", "IncompleteInput", + "InvalidInput", "NoMemory", "TooDeep"}; + ARDUINOJSON_ASSERT(static_cast<size_t>(_code) < + sizeof(messages) / sizeof(messages[0])); + return messages[_code]; + } + +#if ARDUINOJSON_ENABLE_PROGMEM + const __FlashStringHelper* f_str() const { + ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s0, "Ok"); + ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s1, "EmptyInput"); + ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s2, "IncompleteInput"); + ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s3, "InvalidInput"); + ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s4, "NoMemory"); + ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s5, "TooDeep"); + ARDUINOJSON_DEFINE_STATIC_ARRAY( + const char*, messages, ARDUINOJSON_EXPAND6({s0, s1, s2, s3, s4, s5})); + return ARDUINOJSON_READ_STATIC_ARRAY(const __FlashStringHelper*, messages, + _code); + } +#endif + + private: + Code _code; +}; + +#if ARDUINOJSON_ENABLE_STD_STREAM +inline std::ostream& operator<<(std::ostream& s, + const DeserializationError& e) { + s << e.c_str(); + return s; +} + +inline std::ostream& operator<<(std::ostream& s, DeserializationError::Code c) { + s << DeserializationError(c).c_str(); + return s; +} +#endif + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Filter.hpp b/include/lib/ArduinoJson/Deserialization/Filter.hpp new file mode 100644 index 0000000..7ea3078 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Filter.hpp @@ -0,0 +1,66 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class Filter { + public: + explicit Filter(VariantConstRef v) : _variant(v) {} + + bool allow() const { + return _variant; + } + + bool allowArray() const { + return _variant == true || _variant.is<ArrayConstRef>(); + } + + bool allowObject() const { + return _variant == true || _variant.is<ObjectConstRef>(); + } + + bool allowValue() const { + return _variant == true; + } + + template <typename TKey> + Filter operator[](const TKey& key) const { + if (_variant == true) // "true" means "allow recursively" + return *this; + else + return Filter(_variant[key] | _variant["*"]); + } + + private: + VariantConstRef _variant; +}; + +struct AllowAllFilter { + bool allow() const { + return true; + } + + bool allowArray() const { + return true; + } + + bool allowObject() const { + return true; + } + + bool allowValue() const { + return true; + } + + template <typename TKey> + AllowAllFilter operator[](const TKey&) const { + return AllowAllFilter(); + } +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/NestingLimit.hpp b/include/lib/ArduinoJson/Deserialization/NestingLimit.hpp new file mode 100644 index 0000000..06964b4 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/NestingLimit.hpp @@ -0,0 +1,29 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class NestingLimit { + public: + NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} + explicit NestingLimit(uint8_t n) : _value(n) {} + + NestingLimit decrement() const { + ARDUINOJSON_ASSERT(_value > 0); + return NestingLimit(static_cast<uint8_t>(_value - 1)); + } + + bool reached() const { + return _value == 0; + } + + private: + uint8_t _value; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Reader.hpp b/include/lib/ArduinoJson/Deserialization/Reader.hpp new file mode 100644 index 0000000..e965c82 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Reader.hpp @@ -0,0 +1,56 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +#include <stdlib.h> // for size_t + +namespace ARDUINOJSON_NAMESPACE { + +// The default reader is a simple wrapper for Readers that are not copiable +template <typename TSource, typename Enable = void> +struct Reader { + public: + Reader(TSource& source) : _source(&source) {} + + int read() { + return _source->read(); + } + + size_t readBytes(char* buffer, size_t length) { + return _source->readBytes(buffer, length); + } + + private: + TSource* _source; +}; + +template <typename TSource, typename Enable = void> +struct BoundedReader { + // no default implementation because we need to pass the size to the + // constructor +}; +} // namespace ARDUINOJSON_NAMESPACE + +#include <ArduinoJson/Deserialization/Readers/IteratorReader.hpp> +#include <ArduinoJson/Deserialization/Readers/RamReader.hpp> +#include <ArduinoJson/Deserialization/Readers/VariantReader.hpp> + +#if ARDUINOJSON_ENABLE_ARDUINO_STREAM +#include <ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp> +#endif + +#if ARDUINOJSON_ENABLE_ARDUINO_STRING +#include <ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp> +#endif + +#if ARDUINOJSON_ENABLE_PROGMEM +#include <ArduinoJson/Deserialization/Readers/FlashReader.hpp> +#endif + +#if ARDUINOJSON_ENABLE_STD_STREAM +#include <ArduinoJson/Deserialization/Readers/StdStreamReader.hpp> +#endif diff --git a/include/lib/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp b/include/lib/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp new file mode 100644 index 0000000..724638f --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp @@ -0,0 +1,31 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <Arduino.h> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TSource> +struct Reader<TSource, + typename enable_if<is_base_of<Stream, TSource>::value>::type> { + public: + explicit Reader(Stream& stream) : _stream(&stream) {} + + int read() { + // don't use _stream.read() as it ignores the timeout + char c; + return _stream->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1; + } + + size_t readBytes(char* buffer, size_t length) { + return _stream->readBytes(buffer, length); + } + + private: + Stream* _stream; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp b/include/lib/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp new file mode 100644 index 0000000..71571d4 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp @@ -0,0 +1,17 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TSource> +struct Reader<TSource, + typename enable_if<is_base_of< ::String, TSource>::value>::type> + : BoundedReader<const char*> { + explicit Reader(const ::String& s) + : BoundedReader<const char*>(s.c_str(), s.length()) {} +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Readers/FlashReader.hpp b/include/lib/ArduinoJson/Deserialization/Readers/FlashReader.hpp new file mode 100644 index 0000000..7eca134 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Readers/FlashReader.hpp @@ -0,0 +1,53 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +namespace ARDUINOJSON_NAMESPACE { + +template <> +struct Reader<const __FlashStringHelper*, void> { + const char* _ptr; + + public: + explicit Reader(const __FlashStringHelper* ptr) + : _ptr(reinterpret_cast<const char*>(ptr)) {} + + int read() { + return pgm_read_byte(_ptr++); + } + + size_t readBytes(char* buffer, size_t length) { + memcpy_P(buffer, _ptr, length); + _ptr += length; + return length; + } +}; + +template <> +struct BoundedReader<const __FlashStringHelper*, void> { + const char* _ptr; + const char* _end; + + public: + explicit BoundedReader(const __FlashStringHelper* ptr, size_t size) + : _ptr(reinterpret_cast<const char*>(ptr)), _end(_ptr + size) {} + + int read() { + if (_ptr < _end) + return pgm_read_byte(_ptr++); + else + return -1; + } + + size_t readBytes(char* buffer, size_t length) { + size_t available = static_cast<size_t>(_end - _ptr); + if (available < length) + length = available; + memcpy_P(buffer, _ptr, length); + _ptr += length; + return length; + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Readers/IteratorReader.hpp b/include/lib/ArduinoJson/Deserialization/Readers/IteratorReader.hpp new file mode 100644 index 0000000..37c3c31 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Readers/IteratorReader.hpp @@ -0,0 +1,43 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TIterator> +class IteratorReader { + TIterator _ptr, _end; + + public: + explicit IteratorReader(TIterator begin, TIterator end) + : _ptr(begin), _end(end) {} + + int read() { + if (_ptr < _end) + return static_cast<unsigned char>(*_ptr++); + else + return -1; + } + + size_t readBytes(char* buffer, size_t length) { + size_t i = 0; + while (i < length && _ptr < _end) buffer[i++] = *_ptr++; + return i; + } +}; + +template <typename T> +struct void_ { + typedef void type; +}; + +template <typename TSource> +struct Reader<TSource, typename void_<typename TSource::const_iterator>::type> + : IteratorReader<typename TSource::const_iterator> { + explicit Reader(const TSource& source) + : IteratorReader<typename TSource::const_iterator>(source.begin(), + source.end()) {} +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Readers/RamReader.hpp b/include/lib/ArduinoJson/Deserialization/Readers/RamReader.hpp new file mode 100644 index 0000000..67cf682 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Readers/RamReader.hpp @@ -0,0 +1,50 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/type_traits.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +struct IsCharOrVoid { + static const bool value = + is_same<T, void>::value || is_same<T, char>::value || + is_same<T, unsigned char>::value || is_same<T, signed char>::value; +}; + +template <typename T> +struct IsCharOrVoid<const T> : IsCharOrVoid<T> {}; + +template <typename TSource> +struct Reader<TSource*, + typename enable_if<IsCharOrVoid<TSource>::value>::type> { + const char* _ptr; + + public: + explicit Reader(const void* ptr) + : _ptr(ptr ? reinterpret_cast<const char*>(ptr) : "") {} + + int read() { + return static_cast<unsigned char>(*_ptr++); + } + + size_t readBytes(char* buffer, size_t length) { + for (size_t i = 0; i < length; i++) buffer[i] = *_ptr++; + return length; + } +}; + +template <typename TSource> +struct BoundedReader<TSource*, + typename enable_if<IsCharOrVoid<TSource>::value>::type> + : public IteratorReader<const char*> { + public: + explicit BoundedReader(const void* ptr, size_t len) + : IteratorReader<const char*>(reinterpret_cast<const char*>(ptr), + reinterpret_cast<const char*>(ptr) + len) {} +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp b/include/lib/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp new file mode 100644 index 0000000..eebaa2c --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp @@ -0,0 +1,29 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <istream> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TSource> +struct Reader<TSource, typename enable_if< + is_base_of<std::istream, TSource>::value>::type> { + public: + explicit Reader(std::istream& stream) : _stream(&stream) {} + + int read() { + return _stream->get(); + } + + size_t readBytes(char* buffer, size_t length) { + _stream->read(buffer, static_cast<std::streamsize>(length)); + return static_cast<size_t>(_stream->gcount()); + } + + private: + std::istream* _stream; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/Readers/VariantReader.hpp b/include/lib/ArduinoJson/Deserialization/Readers/VariantReader.hpp new file mode 100644 index 0000000..e56e262 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/Readers/VariantReader.hpp @@ -0,0 +1,34 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Object/MemberProxy.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TArray> +struct Reader<ElementProxy<TArray>, void> : Reader<char*, void> { + explicit Reader(const ElementProxy<TArray>& x) + : Reader<char*, void>(x.template as<const char*>()) {} +}; + +template <typename TObject, typename TStringRef> +struct Reader<MemberProxy<TObject, TStringRef>, void> : Reader<char*, void> { + explicit Reader(const MemberProxy<TObject, TStringRef>& x) + : Reader<char*, void>(x.template as<const char*>()) {} +}; + +template <> +struct Reader<VariantRef, void> : Reader<char*, void> { + explicit Reader(VariantRef x) : Reader<char*, void>(x.as<const char*>()) {} +}; + +template <> +struct Reader<VariantConstRef, void> : Reader<char*, void> { + explicit Reader(VariantConstRef x) + : Reader<char*, void>(x.as<const char*>()) {} +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Deserialization/deserialize.hpp b/include/lib/ArduinoJson/Deserialization/deserialize.hpp new file mode 100644 index 0000000..2329542 --- /dev/null +++ b/include/lib/ArduinoJson/Deserialization/deserialize.hpp @@ -0,0 +1,71 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Deserialization/DeserializationError.hpp> +#include <ArduinoJson/Deserialization/Filter.hpp> +#include <ArduinoJson/Deserialization/NestingLimit.hpp> +#include <ArduinoJson/Deserialization/Reader.hpp> +#include <ArduinoJson/StringStorage/StringStorage.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <template <typename, typename> class TDeserializer, typename TReader, + typename TWriter> +TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool &pool, + TReader reader, + TWriter writer) { + return TDeserializer<TReader, TWriter>(pool, reader, writer); +} + +// deserialize(JsonDocument&, const std::string&, NestingLimit, Filter); +// deserialize(JsonDocument&, const String&, NestingLimit, Filter); +// deserialize(JsonDocument&, char*, NestingLimit, Filter); +// deserialize(JsonDocument&, const char*, NestingLimit, Filter); +// deserialize(JsonDocument&, const __FlashStringHelper*, NestingLimit, Filter); +template <template <typename, typename> class TDeserializer, typename TString, + typename TFilter> +typename enable_if<!is_array<TString>::value, DeserializationError>::type +deserialize(JsonDocument &doc, const TString &input, NestingLimit nestingLimit, + TFilter filter) { + Reader<TString> reader(input); + doc.clear(); + return makeDeserializer<TDeserializer>( + doc.memoryPool(), reader, + makeStringStorage(input, doc.memoryPool())) + .parse(doc.data(), filter, nestingLimit); +} +// +// deserialize(JsonDocument&, char*, size_t, NestingLimit, Filter); +// deserialize(JsonDocument&, const char*, size_t, NestingLimit, Filter); +// deserialize(JsonDocument&, const __FlashStringHelper*, size_t, NL, Filter); +template <template <typename, typename> class TDeserializer, typename TChar, + typename TFilter> +DeserializationError deserialize(JsonDocument &doc, TChar *input, + size_t inputSize, NestingLimit nestingLimit, + TFilter filter) { + BoundedReader<TChar *> reader(input, inputSize); + doc.clear(); + return makeDeserializer<TDeserializer>( + doc.memoryPool(), reader, + makeStringStorage(input, doc.memoryPool())) + .parse(doc.data(), filter, nestingLimit); +} +// +// deserialize(JsonDocument&, std::istream&, NestingLimit, Filter); +// deserialize(JsonDocument&, Stream&, NestingLimit, Filter); +template <template <typename, typename> class TDeserializer, typename TStream, + typename TFilter> +DeserializationError deserialize(JsonDocument &doc, TStream &input, + NestingLimit nestingLimit, TFilter filter) { + Reader<TStream> reader(input); + doc.clear(); + return makeDeserializer<TDeserializer>( + doc.memoryPool(), reader, + makeStringStorage(input, doc.memoryPool())) + .parse(doc.data(), filter, nestingLimit); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Document/BasicJsonDocument.hpp b/include/lib/ArduinoJson/Document/BasicJsonDocument.hpp new file mode 100644 index 0000000..5c85d8a --- /dev/null +++ b/include/lib/ArduinoJson/Document/BasicJsonDocument.hpp @@ -0,0 +1,164 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Document/JsonDocument.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// Helper to implement the "base-from-member" idiom +// (we need to store the allocator before constructing JsonDocument) +template <typename TAllocator> +class AllocatorOwner { + public: + AllocatorOwner() {} + AllocatorOwner(const AllocatorOwner& src) : _allocator(src._allocator) {} + AllocatorOwner(TAllocator a) : _allocator(a) {} + + void* allocate(size_t size) { + return _allocator.allocate(size); + } + + void deallocate(void* ptr) { + if (ptr) + _allocator.deallocate(ptr); + } + + void* reallocate(void* ptr, size_t new_size) { + return _allocator.reallocate(ptr, new_size); + } + + TAllocator& allocator() { + return _allocator; + } + + private: + TAllocator _allocator; +}; + +template <typename TAllocator> +class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument { + public: + explicit BasicJsonDocument(size_t capa, TAllocator alloc = TAllocator()) + : AllocatorOwner<TAllocator>(alloc), JsonDocument(allocPool(capa)) {} + + // Copy-constructor + BasicJsonDocument(const BasicJsonDocument& src) + : AllocatorOwner<TAllocator>(src), JsonDocument() { + copyAssignFrom(src); + } + + // Move-constructor +#if ARDUINOJSON_HAS_RVALUE_REFERENCES + BasicJsonDocument(BasicJsonDocument&& src) : AllocatorOwner<TAllocator>(src) { + moveAssignFrom(src); + } +#endif + + BasicJsonDocument(const JsonDocument& src) { + copyAssignFrom(src); + } + + // Construct from variant, array, or object + template <typename T> + BasicJsonDocument( + const T& src, + typename enable_if< + is_same<T, VariantRef>::value || is_same<T, VariantConstRef>::value || + is_same<T, ArrayRef>::value || is_same<T, ArrayConstRef>::value || + is_same<T, ObjectRef>::value || + is_same<T, ObjectConstRef>::value>::type* = 0) + : JsonDocument(allocPool(src.memoryUsage())) { + set(src); + } + + // disambiguate + BasicJsonDocument(VariantRef src) + : JsonDocument(allocPool(src.memoryUsage())) { + set(src); + } + + ~BasicJsonDocument() { + freePool(); + } + + BasicJsonDocument& operator=(const BasicJsonDocument& src) { + copyAssignFrom(src); + return *this; + } + +#if ARDUINOJSON_HAS_RVALUE_REFERENCES + BasicJsonDocument& operator=(BasicJsonDocument&& src) { + moveAssignFrom(src); + return *this; + } +#endif + + template <typename T> + BasicJsonDocument& operator=(const T& src) { + reallocPoolIfTooSmall(src.memoryUsage()); + set(src); + return *this; + } + + void shrinkToFit() { + ptrdiff_t bytes_reclaimed = _pool.squash(); + if (bytes_reclaimed == 0) + return; + + void* old_ptr = _pool.buffer(); + void* new_ptr = this->reallocate(old_ptr, _pool.capacity()); + + ptrdiff_t ptr_offset = + static_cast<char*>(new_ptr) - static_cast<char*>(old_ptr); + + _pool.movePointers(ptr_offset); + _data.movePointers(ptr_offset, ptr_offset - bytes_reclaimed); + } + + bool garbageCollect() { + // make a temporary clone and move assign + BasicJsonDocument tmp(*this); + if (!tmp.capacity()) + return false; + tmp.set(*this); + moveAssignFrom(tmp); + return true; + } + + using AllocatorOwner<TAllocator>::allocator; + + private: + MemoryPool allocPool(size_t requiredSize) { + size_t capa = addPadding(requiredSize); + return MemoryPool(reinterpret_cast<char*>(this->allocate(capa)), capa); + } + + void reallocPoolIfTooSmall(size_t requiredSize) { + if (requiredSize <= capacity()) + return; + freePool(); + replacePool(allocPool(addPadding(requiredSize))); + } + + void freePool() { + this->deallocate(memoryPool().buffer()); + } + + void copyAssignFrom(const JsonDocument& src) { + reallocPoolIfTooSmall(src.capacity()); + set(src); + } + + void moveAssignFrom(BasicJsonDocument& src) { + freePool(); + _data = src._data; + _pool = src._pool; + src._data.setNull(); + src._pool = MemoryPool(0, 0); + } +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Document/DynamicJsonDocument.hpp b/include/lib/ArduinoJson/Document/DynamicJsonDocument.hpp new file mode 100644 index 0000000..de6f411 --- /dev/null +++ b/include/lib/ArduinoJson/Document/DynamicJsonDocument.hpp @@ -0,0 +1,29 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Document/BasicJsonDocument.hpp> + +#include <stdlib.h> // malloc, free + +namespace ARDUINOJSON_NAMESPACE { + +struct DefaultAllocator { + void* allocate(size_t size) { + return malloc(size); + } + + void deallocate(void* ptr) { + free(ptr); + } + + void* reallocate(void* ptr, size_t new_size) { + return realloc(ptr, new_size); + } +}; + +typedef BasicJsonDocument<DefaultAllocator> DynamicJsonDocument; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Document/JsonDocument.hpp b/include/lib/ArduinoJson/Document/JsonDocument.hpp new file mode 100644 index 0000000..d67d934 --- /dev/null +++ b/include/lib/ArduinoJson/Document/JsonDocument.hpp @@ -0,0 +1,344 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Array/ElementProxy.hpp> +#include <ArduinoJson/Memory/MemoryPool.hpp> +#include <ArduinoJson/Object/MemberProxy.hpp> +#include <ArduinoJson/Object/ObjectRef.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> +#include <ArduinoJson/Variant/VariantTo.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class JsonDocument : public Visitable { + public: + template <typename TVisitor> + typename TVisitor::result_type accept(TVisitor& visitor) const { + return getVariant().accept(visitor); + } + + template <typename T> + T as() { + return getVariant().template as<T>(); + } + + template <typename T> + T as() const { + return getVariant().template as<T>(); + } + + void clear() { + _pool.clear(); + _data.setNull(); + } + + template <typename T> + bool is() { + return getVariant().template is<T>(); + } + + template <typename T> + bool is() const { + return getVariant().template is<T>(); + } + + bool isNull() const { + return getVariant().isNull(); + } + + size_t memoryUsage() const { + return _pool.size(); + } + + bool overflowed() const { + return _pool.overflowed(); + } + + size_t nesting() const { + return _data.nesting(); + } + + size_t capacity() const { + return _pool.capacity(); + } + + size_t size() const { + return _data.size(); + } + + bool set(const JsonDocument& src) { + return to<VariantRef>().set(src.as<VariantConstRef>()); + } + + template <typename T> + typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set( + const T& src) { + return to<VariantRef>().set(src); + } + + template <typename T> + typename VariantTo<T>::type to() { + clear(); + return getVariant().template to<T>(); + } + + // for internal use only + MemoryPool& memoryPool() { + return _pool; + } + + // for internal use only + VariantData& data() { + return _data; + } + + ArrayRef createNestedArray() { + return addElement().to<ArrayRef>(); + } + + // createNestedArray(char*) + // createNestedArray(const char*) + // createNestedArray(const __FlashStringHelper*) + template <typename TChar> + ArrayRef createNestedArray(TChar* key) { + return getOrAddMember(key).template to<ArrayRef>(); + } + + // createNestedArray(const std::string&) + // createNestedArray(const String&) + template <typename TString> + ArrayRef createNestedArray(const TString& key) { + return getOrAddMember(key).template to<ArrayRef>(); + } + + ObjectRef createNestedObject() { + return addElement().to<ObjectRef>(); + } + + // createNestedObject(char*) + // createNestedObject(const char*) + // createNestedObject(const __FlashStringHelper*) + template <typename TChar> + ObjectRef createNestedObject(TChar* key) { + return getOrAddMember(key).template to<ObjectRef>(); + } + + // createNestedObject(const std::string&) + // createNestedObject(const String&) + template <typename TString> + ObjectRef createNestedObject(const TString& key) { + return getOrAddMember(key).template to<ObjectRef>(); + } + + // containsKey(char*) const + // containsKey(const char*) const + // containsKey(const __FlashStringHelper*) const + template <typename TChar> + bool containsKey(TChar* key) const { + return !getMember(key).isUndefined(); + } + + // containsKey(const std::string&) const + // containsKey(const String&) const + template <typename TString> + bool containsKey(const TString& key) const { + return !getMember(key).isUndefined(); + } + + // operator[](const std::string&) + // operator[](const String&) + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value, + MemberProxy<JsonDocument&, TString> >::type + operator[](const TString& key) { + return MemberProxy<JsonDocument&, TString>(*this, key); + } + + // operator[](char*) + // operator[](const char*) + // operator[](const __FlashStringHelper*) + template <typename TChar> + FORCE_INLINE typename enable_if<IsString<TChar*>::value, + MemberProxy<JsonDocument&, TChar*> >::type + operator[](TChar* key) { + return MemberProxy<JsonDocument&, TChar*>(*this, key); + } + + // operator[](const std::string&) const + // operator[](const String&) const + template <typename TString> + FORCE_INLINE + typename enable_if<IsString<TString>::value, VariantConstRef>::type + operator[](const TString& key) const { + return getMember(key); + } + + // operator[](char*) const + // operator[](const char*) const + // operator[](const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE + typename enable_if<IsString<TChar*>::value, VariantConstRef>::type + operator[](TChar* key) const { + return getMember(key); + } + + FORCE_INLINE ElementProxy<JsonDocument&> operator[](size_t index) { + return ElementProxy<JsonDocument&>(*this, index); + } + + FORCE_INLINE VariantConstRef operator[](size_t index) const { + return getElement(index); + } + + FORCE_INLINE VariantRef getElement(size_t index) { + return VariantRef(&_pool, _data.getElement(index)); + } + + FORCE_INLINE VariantConstRef getElement(size_t index) const { + return VariantConstRef(_data.getElement(index)); + } + + FORCE_INLINE VariantRef getOrAddElement(size_t index) { + return VariantRef(&_pool, _data.getOrAddElement(index, &_pool)); + } + + // JsonVariantConst getMember(char*) const + // JsonVariantConst getMember(const char*) const + // JsonVariantConst getMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantConstRef getMember(TChar* key) const { + return VariantConstRef(_data.getMember(adaptString(key))); + } + + // JsonVariantConst getMember(const std::string&) const + // JsonVariantConst getMember(const String&) const + template <typename TString> + FORCE_INLINE + typename enable_if<IsString<TString>::value, VariantConstRef>::type + getMember(const TString& key) const { + return VariantConstRef(_data.getMember(adaptString(key))); + } + + // JsonVariant getMember(char*) + // JsonVariant getMember(const char*) + // JsonVariant getMember(const __FlashStringHelper*) + template <typename TChar> + FORCE_INLINE VariantRef getMember(TChar* key) { + return VariantRef(&_pool, _data.getMember(adaptString(key))); + } + + // JsonVariant getMember(const std::string&) + // JsonVariant getMember(const String&) + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value, VariantRef>::type + getMember(const TString& key) { + return VariantRef(&_pool, _data.getMember(adaptString(key))); + } + + // getOrAddMember(char*) + // getOrAddMember(const char*) + // getOrAddMember(const __FlashStringHelper*) + template <typename TChar> + FORCE_INLINE VariantRef getOrAddMember(TChar* key) { + return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool)); + } + + // getOrAddMember(const std::string&) + // getOrAddMember(const String&) + template <typename TString> + FORCE_INLINE VariantRef getOrAddMember(const TString& key) { + return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool)); + } + + FORCE_INLINE VariantRef addElement() { + return VariantRef(&_pool, _data.addElement(&_pool)); + } + + template <typename TValue> + FORCE_INLINE bool add(const TValue& value) { + return addElement().set(value); + } + + // add(char*) const + // add(const char*) const + // add(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE bool add(TChar* value) { + return addElement().set(value); + } + + FORCE_INLINE void remove(size_t index) { + _data.remove(index); + } + // remove(char*) + // remove(const char*) + // remove(const __FlashStringHelper*) + template <typename TChar> + FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove( + TChar* key) { + _data.remove(adaptString(key)); + } + // remove(const std::string&) + // remove(const String&) + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove( + const TString& key) { + _data.remove(adaptString(key)); + } + + FORCE_INLINE operator VariantConstRef() const { + return VariantConstRef(&_data); + } + + bool operator==(VariantConstRef rhs) const { + return getVariant() == rhs; + } + + bool operator!=(VariantConstRef rhs) const { + return getVariant() != rhs; + } + + protected: + JsonDocument() : _pool(0, 0) { + _data.setNull(); + } + + JsonDocument(MemoryPool pool) : _pool(pool) { + _data.setNull(); + } + + JsonDocument(char* buf, size_t capa) : _pool(buf, capa) { + _data.setNull(); + } + + ~JsonDocument() {} + + void replacePool(MemoryPool pool) { + _pool = pool; + } + + VariantRef getVariant() { + return VariantRef(&_pool, &_data); + } + + VariantConstRef getVariant() const { + return VariantConstRef(&_data); + } + + MemoryPool _pool; + VariantData _data; + + private: + JsonDocument(const JsonDocument&); + JsonDocument& operator=(const JsonDocument&); +}; + +inline bool convertToJson(const JsonDocument& src, VariantRef dst) { + return dst.set(src.as<VariantConstRef>()); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Document/StaticJsonDocument.hpp b/include/lib/ArduinoJson/Document/StaticJsonDocument.hpp new file mode 100644 index 0000000..fbbadd4 --- /dev/null +++ b/include/lib/ArduinoJson/Document/StaticJsonDocument.hpp @@ -0,0 +1,56 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Document/JsonDocument.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <size_t desiredCapacity> +class StaticJsonDocument : public JsonDocument { + static const size_t _capacity = + AddPadding<Max<1, desiredCapacity>::value>::value; + + public: + StaticJsonDocument() : JsonDocument(_buffer, _capacity) {} + + StaticJsonDocument(const StaticJsonDocument& src) + : JsonDocument(_buffer, _capacity) { + set(src); + } + + template <typename T> + StaticJsonDocument(const T& src, + typename enable_if<IsVisitable<T>::value>::type* = 0) + : JsonDocument(_buffer, _capacity) { + set(src); + } + + // disambiguate + StaticJsonDocument(VariantRef src) : JsonDocument(_buffer, _capacity) { + set(src); + } + + StaticJsonDocument operator=(const StaticJsonDocument& src) { + set(src); + return *this; + } + + template <typename T> + StaticJsonDocument operator=(const T& src) { + set(src); + return *this; + } + + void garbageCollect() { + StaticJsonDocument tmp(*this); + set(tmp); + } + + private: + char _buffer[_capacity]; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Json/EscapeSequence.hpp b/include/lib/ArduinoJson/Json/EscapeSequence.hpp new file mode 100644 index 0000000..811e825 --- /dev/null +++ b/include/lib/ArduinoJson/Json/EscapeSequence.hpp @@ -0,0 +1,39 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class EscapeSequence { + public: + // Optimized for code size on a 8-bit AVR + static char escapeChar(char c) { + const char *p = escapeTable(true); + while (p[0] && p[1] != c) { + p += 2; + } + return p[0]; + } + + // Optimized for code size on a 8-bit AVR + static char unescapeChar(char c) { + const char *p = escapeTable(false); + for (;;) { + if (p[0] == '\0') + return 0; + if (p[0] == c) + return p[1]; + p += 2; + } + } + + private: + static const char *escapeTable(bool excludeSolidus) { + return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0]; + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Json/JsonDeserializer.hpp b/include/lib/ArduinoJson/Json/JsonDeserializer.hpp new file mode 100644 index 0000000..1a07be8 --- /dev/null +++ b/include/lib/ArduinoJson/Json/JsonDeserializer.hpp @@ -0,0 +1,740 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Deserialization/deserialize.hpp> +#include <ArduinoJson/Json/EscapeSequence.hpp> +#include <ArduinoJson/Json/Latch.hpp> +#include <ArduinoJson/Json/Utf16.hpp> +#include <ArduinoJson/Json/Utf8.hpp> +#include <ArduinoJson/Memory/MemoryPool.hpp> +#include <ArduinoJson/Numbers/parseNumber.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TReader, typename TStringStorage> +class JsonDeserializer { + public: + JsonDeserializer(MemoryPool &pool, TReader reader, + TStringStorage stringStorage) + : _stringStorage(stringStorage), + _foundSomething(false), + _latch(reader), + _pool(&pool), + _error(DeserializationError::Ok) {} + + template <typename TFilter> + DeserializationError parse(VariantData &variant, TFilter filter, + NestingLimit nestingLimit) { + parseVariant(variant, filter, nestingLimit); + + if (!_error && _latch.last() != 0 && !variant.isEnclosed()) { + // We don't detect trailing characters earlier, so we need to check now + return DeserializationError::InvalidInput; + } + + return _error; + } + + private: + char current() { + return _latch.current(); + } + + void move() { + _latch.clear(); + } + + bool eat(char charToSkip) { + if (current() != charToSkip) + return false; + move(); + return true; + } + + template <typename TFilter> + bool parseVariant(VariantData &variant, TFilter filter, + NestingLimit nestingLimit) { + if (!skipSpacesAndComments()) + return false; + + switch (current()) { + case '[': + if (filter.allowArray()) + return parseArray(variant.toArray(), filter, nestingLimit); + else + return skipArray(nestingLimit); + + case '{': + if (filter.allowObject()) + return parseObject(variant.toObject(), filter, nestingLimit); + else + return skipObject(nestingLimit); + + case '\"': + case '\'': + if (filter.allowValue()) + return parseStringValue(variant); + else + return skipString(); + + default: + if (filter.allowValue()) + return parseNumericValue(variant); + else + return skipNumericValue(); + } + } + + bool skipVariant(NestingLimit nestingLimit) { + if (!skipSpacesAndComments()) + return false; + + switch (current()) { + case '[': + return skipArray(nestingLimit); + + case '{': + return skipObject(nestingLimit); + + case '\"': + case '\'': + return skipString(); + + default: + return skipNumericValue(); + } + } + + template <typename TFilter> + bool parseArray(CollectionData &array, TFilter filter, + NestingLimit nestingLimit) { + if (nestingLimit.reached()) { + _error = DeserializationError::TooDeep; + return false; + } + + // Skip opening braket + ARDUINOJSON_ASSERT(current() == '['); + move(); + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + + // Empty array? + if (eat(']')) + return true; + + TFilter memberFilter = filter[0UL]; + + // Read each value + for (;;) { + if (memberFilter.allow()) { + // Allocate slot in array + VariantData *value = array.addElement(_pool); + if (!value) { + _error = DeserializationError::NoMemory; + return false; + } + + // 1 - Parse value + if (!parseVariant(*value, memberFilter, nestingLimit.decrement())) + return false; + } else { + if (!skipVariant(nestingLimit.decrement())) + return false; + } + + // 2 - Skip spaces + if (!skipSpacesAndComments()) + return false; + + // 3 - More values? + if (eat(']')) + return true; + if (!eat(',')) { + _error = DeserializationError::InvalidInput; + return false; + } + } + } + + bool skipArray(NestingLimit nestingLimit) { + if (nestingLimit.reached()) { + _error = DeserializationError::TooDeep; + return false; + } + + // Skip opening braket + ARDUINOJSON_ASSERT(current() == '['); + move(); + + // Read each value + for (;;) { + // 1 - Skip value + if (!skipVariant(nestingLimit.decrement())) + return false; + + // 2 - Skip spaces + if (!skipSpacesAndComments()) + return false; + + // 3 - More values? + if (eat(']')) + return true; + if (!eat(',')) { + _error = DeserializationError::InvalidInput; + return false; + } + } + } + + template <typename TFilter> + bool parseObject(CollectionData &object, TFilter filter, + NestingLimit nestingLimit) { + if (nestingLimit.reached()) { + _error = DeserializationError::TooDeep; + return false; + } + + // Skip opening brace + ARDUINOJSON_ASSERT(current() == '{'); + move(); + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + + // Empty object? + if (eat('}')) + return true; + + // Read each key value pair + for (;;) { + // Parse key + if (!parseKey()) + return false; + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + + // Colon + if (!eat(':')) { + _error = DeserializationError::InvalidInput; + return false; + } + + const char *key = _stringStorage.c_str(); + + TFilter memberFilter = filter[key]; + + if (memberFilter.allow()) { + VariantData *variant = object.getMember(adaptString(key)); + if (!variant) { + // Save key in memory pool. + // This MUST be done before adding the slot. + key = _stringStorage.save(); + + // Allocate slot in object + VariantSlot *slot = object.addSlot(_pool); + if (!slot) { + _error = DeserializationError::NoMemory; + return false; + } + + slot->setKey(key, typename TStringStorage::storage_policy()); + + variant = slot->data(); + } + + // Parse value + if (!parseVariant(*variant, memberFilter, nestingLimit.decrement())) + return false; + } else { + if (!skipVariant(nestingLimit.decrement())) + return false; + } + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + + // More keys/values? + if (eat('}')) + return true; + if (!eat(',')) { + _error = DeserializationError::InvalidInput; + return false; + } + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + } + } + + bool skipObject(NestingLimit nestingLimit) { + if (nestingLimit.reached()) { + _error = DeserializationError::TooDeep; + return false; + } + + // Skip opening brace + ARDUINOJSON_ASSERT(current() == '{'); + move(); + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + + // Empty object? + if (eat('}')) + return true; + + // Read each key value pair + for (;;) { + // Skip key + if (!skipVariant(nestingLimit.decrement())) + return false; + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + + // Colon + if (!eat(':')) { + _error = DeserializationError::InvalidInput; + return false; + } + + // Skip value + if (!skipVariant(nestingLimit.decrement())) + return false; + + // Skip spaces + if (!skipSpacesAndComments()) + return false; + + // More keys/values? + if (eat('}')) + return true; + if (!eat(',')) { + _error = DeserializationError::InvalidInput; + return false; + } + } + } + + bool parseKey() { + _stringStorage.startString(); + if (isQuote(current())) { + return parseQuotedString(); + } else { + return parseNonQuotedString(); + } + } + + bool parseStringValue(VariantData &variant) { + _stringStorage.startString(); + if (!parseQuotedString()) + return false; + const char *value = _stringStorage.save(); + variant.setStringPointer(value, typename TStringStorage::storage_policy()); + return true; + } + + bool parseQuotedString() { +#if ARDUINOJSON_DECODE_UNICODE + Utf16::Codepoint codepoint; +#endif + const char stopChar = current(); + + move(); + for (;;) { + char c = current(); + move(); + if (c == stopChar) + break; + + if (c == '\0') { + _error = DeserializationError::IncompleteInput; + return false; + } + + if (c == '\\') { + c = current(); + + if (c == '\0') { + _error = DeserializationError::IncompleteInput; + return false; + } + + if (c == 'u') { +#if ARDUINOJSON_DECODE_UNICODE + move(); + uint16_t codeunit; + if (!parseHex4(codeunit)) + return false; + if (codepoint.append(codeunit)) + Utf8::encodeCodepoint(codepoint.value(), _stringStorage); +#else + _stringStorage.append('\\'); +#endif + continue; + } + + // replace char + c = EscapeSequence::unescapeChar(c); + if (c == '\0') { + _error = DeserializationError::InvalidInput; + return false; + } + move(); + } + + _stringStorage.append(c); + } + + _stringStorage.append('\0'); + + if (!_stringStorage.isValid()) { + _error = DeserializationError::NoMemory; + return false; + } + + return true; + } + + bool parseNonQuotedString() { + char c = current(); + ARDUINOJSON_ASSERT(c); + + if (canBeInNonQuotedString(c)) { // no quotes + do { + move(); + _stringStorage.append(c); + c = current(); + } while (canBeInNonQuotedString(c)); + } else { + _error = DeserializationError::InvalidInput; + return false; + } + + _stringStorage.append('\0'); + + if (!_stringStorage.isValid()) { + _error = DeserializationError::NoMemory; + return false; + } + + return true; + } + + bool skipString() { + const char stopChar = current(); + + move(); + for (;;) { + char c = current(); + move(); + if (c == stopChar) + break; + if (c == '\0') { + _error = DeserializationError::IncompleteInput; + return false; + } + if (c == '\\') { + if (current() != '\0') + move(); + } + } + + return true; + } + + bool parseNumericValue(VariantData &result) { + uint8_t n = 0; + + char c = current(); + while (canBeInNonQuotedString(c) && n < 63) { + move(); + _buffer[n++] = c; + c = current(); + } + _buffer[n] = 0; + + c = _buffer[0]; + if (c == 't') { // true + result.setBoolean(true); + if (n != 4) { + _error = DeserializationError::IncompleteInput; + return false; + } + return true; + } + if (c == 'f') { // false + result.setBoolean(false); + if (n != 5) { + _error = DeserializationError::IncompleteInput; + return false; + } + return true; + } + if (c == 'n') { // null + // the variant is already null + if (n != 4) { + _error = DeserializationError::IncompleteInput; + return false; + } + return true; + } + + if (!parseNumber(_buffer, result)) { + _error = DeserializationError::InvalidInput; + return false; + } + + return true; + } + + bool skipNumericValue() { + char c = current(); + while (canBeInNonQuotedString(c)) { + move(); + c = current(); + } + return true; + } + + bool parseHex4(uint16_t &result) { + result = 0; + for (uint8_t i = 0; i < 4; ++i) { + char digit = current(); + if (!digit) { + _error = DeserializationError::IncompleteInput; + return false; + } + uint8_t value = decodeHex(digit); + if (value > 0x0F) { + _error = DeserializationError::InvalidInput; + return false; + } + result = uint16_t((result << 4) | value); + move(); + } + return true; + } + + static inline bool isBetween(char c, char min, char max) { + return min <= c && c <= max; + } + + static inline bool canBeInNonQuotedString(char c) { + return isBetween(c, '0', '9') || isBetween(c, '_', 'z') || + isBetween(c, 'A', 'Z') || c == '+' || c == '-' || c == '.'; + } + + static inline bool isQuote(char c) { + return c == '\'' || c == '\"'; + } + + static inline uint8_t decodeHex(char c) { + if (c < 'A') + return uint8_t(c - '0'); + c = char(c & ~0x20); // uppercase + return uint8_t(c - 'A' + 10); + } + + bool skipSpacesAndComments() { + for (;;) { + switch (current()) { + // end of string + case '\0': + _error = _foundSomething ? DeserializationError::IncompleteInput + : DeserializationError::EmptyInput; + return false; + + // spaces + case ' ': + case '\t': + case '\r': + case '\n': + move(); + continue; + +#if ARDUINOJSON_ENABLE_COMMENTS + // comments + case '/': + move(); // skip '/' + switch (current()) { + // block comment + case '*': { + move(); // skip '*' + bool wasStar = false; + for (;;) { + char c = current(); + if (c == '\0') { + _error = DeserializationError::IncompleteInput; + return false; + } + if (c == '/' && wasStar) { + move(); + break; + } + wasStar = c == '*'; + move(); + } + break; + } + + // trailing comment + case '/': + // no need to skip "//" + for (;;) { + move(); + char c = current(); + if (c == '\0') { + _error = DeserializationError::IncompleteInput; + return false; + } + if (c == '\n') + break; + } + break; + + // not a comment, just a '/' + default: + _error = DeserializationError::InvalidInput; + return false; + } + break; +#endif + + default: + _foundSomething = true; + return true; + } + } + } + + TStringStorage _stringStorage; + bool _foundSomething; + Latch<TReader> _latch; + MemoryPool *_pool; + char _buffer[64]; // using a member instead of a local variable because it + // ended in the recursive path after compiler inlined the + // code + DeserializationError _error; +}; + +// +// deserializeJson(JsonDocument&, const std::string&, ...) +// +// ... = NestingLimit +template <typename TString> +DeserializationError deserializeJson( + JsonDocument &doc, const TString &input, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TString> +DeserializationError deserializeJson( + JsonDocument &doc, const TString &input, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter); +} +// ... = NestingLimit, Filter +template <typename TString> +DeserializationError deserializeJson(JsonDocument &doc, const TString &input, + NestingLimit nestingLimit, Filter filter) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter); +} + +// +// deserializeJson(JsonDocument&, std::istream&, ...) +// +// ... = NestingLimit +template <typename TStream> +DeserializationError deserializeJson( + JsonDocument &doc, TStream &input, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TStream> +DeserializationError deserializeJson( + JsonDocument &doc, TStream &input, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter); +} +// ... = NestingLimit, Filter +template <typename TStream> +DeserializationError deserializeJson(JsonDocument &doc, TStream &input, + NestingLimit nestingLimit, Filter filter) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter); +} + +// +// deserializeJson(JsonDocument&, char*, ...) +// +// ... = NestingLimit +template <typename TChar> +DeserializationError deserializeJson( + JsonDocument &doc, TChar *input, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TChar> +DeserializationError deserializeJson( + JsonDocument &doc, TChar *input, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter); +} +// ... = NestingLimit, Filter +template <typename TChar> +DeserializationError deserializeJson(JsonDocument &doc, TChar *input, + NestingLimit nestingLimit, Filter filter) { + return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter); +} + +// +// deserializeJson(JsonDocument&, char*, size_t, ...) +// +// ... = NestingLimit +template <typename TChar> +DeserializationError deserializeJson( + JsonDocument &doc, TChar *input, size_t inputSize, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TChar> +DeserializationError deserializeJson( + JsonDocument &doc, TChar *input, size_t inputSize, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit, + filter); +} +// ... = NestingLimit, Filter +template <typename TChar> +DeserializationError deserializeJson(JsonDocument &doc, TChar *input, + size_t inputSize, + NestingLimit nestingLimit, Filter filter) { + return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit, + filter); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Json/JsonSerializer.hpp b/include/lib/ArduinoJson/Json/JsonSerializer.hpp new file mode 100644 index 0000000..5cb9aa2 --- /dev/null +++ b/include/lib/ArduinoJson/Json/JsonSerializer.hpp @@ -0,0 +1,137 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Json/TextFormatter.hpp> +#include <ArduinoJson/Misc/Visitable.hpp> +#include <ArduinoJson/Serialization/measure.hpp> +#include <ArduinoJson/Serialization/serialize.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TWriter> +class JsonSerializer : public Visitor<size_t> { + public: + static const bool producesText = true; + + JsonSerializer(TWriter writer) : _formatter(writer) {} + + FORCE_INLINE size_t visitArray(const CollectionData &array) { + write('['); + + VariantSlot *slot = array.head(); + + while (slot != 0) { + slot->data()->accept(*this); + + slot = slot->next(); + if (slot == 0) + break; + + write(','); + } + + write(']'); + return bytesWritten(); + } + + size_t visitObject(const CollectionData &object) { + write('{'); + + VariantSlot *slot = object.head(); + + while (slot != 0) { + _formatter.writeString(slot->key()); + write(':'); + slot->data()->accept(*this); + + slot = slot->next(); + if (slot == 0) + break; + + write(','); + } + + write('}'); + return bytesWritten(); + } + + size_t visitFloat(Float value) { + _formatter.writeFloat(value); + return bytesWritten(); + } + + size_t visitString(const char *value) { + _formatter.writeString(value); + return bytesWritten(); + } + + size_t visitRawJson(const char *data, size_t n) { + _formatter.writeRaw(data, n); + return bytesWritten(); + } + + size_t visitSignedInteger(Integer value) { + _formatter.writeInteger(value); + return bytesWritten(); + } + + size_t visitUnsignedInteger(UInt value) { + _formatter.writeInteger(value); + return bytesWritten(); + } + + size_t visitBoolean(bool value) { + _formatter.writeBoolean(value); + return bytesWritten(); + } + + size_t visitNull() { + _formatter.writeRaw("null"); + return bytesWritten(); + } + + protected: + size_t bytesWritten() const { + return _formatter.bytesWritten(); + } + + void write(char c) { + _formatter.writeRaw(c); + } + + void write(const char *s) { + _formatter.writeRaw(s); + } + + private: + TextFormatter<TWriter> _formatter; +}; + +template <typename TSource, typename TDestination> +size_t serializeJson(const TSource &source, TDestination &destination) { + return serialize<JsonSerializer>(source, destination); +} + +template <typename TSource> +size_t serializeJson(const TSource &source, void *buffer, size_t bufferSize) { + return serialize<JsonSerializer>(source, buffer, bufferSize); +} + +template <typename TSource> +size_t measureJson(const TSource &source) { + return measure<JsonSerializer>(source); +} + +#if ARDUINOJSON_ENABLE_STD_STREAM +template <typename T> +inline typename enable_if<IsVisitable<T>::value, std::ostream &>::type +operator<<(std::ostream &os, const T &source) { + serializeJson(source, os); + return os; +} +#endif + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Json/Latch.hpp b/include/lib/ArduinoJson/Json/Latch.hpp new file mode 100644 index 0000000..aef1fe3 --- /dev/null +++ b/include/lib/ArduinoJson/Json/Latch.hpp @@ -0,0 +1,55 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/assert.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TReader> +class Latch { + public: + Latch(TReader reader) : _reader(reader), _loaded(false) { +#if ARDUINOJSON_DEBUG + _ended = false; +#endif + } + + void clear() { + _loaded = false; + } + + int last() const { + return _current; + } + + FORCE_INLINE char current() { + if (!_loaded) { + load(); + } + return _current; + } + + private: + void load() { + ARDUINOJSON_ASSERT(!_ended); + int c = _reader.read(); +#if ARDUINOJSON_DEBUG + if (c <= 0) + _ended = true; +#endif + _current = static_cast<char>(c > 0 ? c : 0); + _loaded = true; + } + + TReader _reader; + char _current; + bool _loaded; +#if ARDUINOJSON_DEBUG + bool _ended; +#endif +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Json/PrettyJsonSerializer.hpp b/include/lib/ArduinoJson/Json/PrettyJsonSerializer.hpp new file mode 100644 index 0000000..dbb0c17 --- /dev/null +++ b/include/lib/ArduinoJson/Json/PrettyJsonSerializer.hpp @@ -0,0 +1,89 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Json/JsonSerializer.hpp> +#include <ArduinoJson/Serialization/measure.hpp> +#include <ArduinoJson/Serialization/serialize.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TWriter> +class PrettyJsonSerializer : public JsonSerializer<TWriter> { + typedef JsonSerializer<TWriter> base; + + public: + PrettyJsonSerializer(TWriter writer) : base(writer), _nesting(0) {} + + size_t visitArray(const CollectionData &array) { + VariantSlot *slot = array.head(); + if (slot) { + base::write("[\r\n"); + _nesting++; + while (slot != 0) { + indent(); + slot->data()->accept(*this); + + slot = slot->next(); + base::write(slot ? ",\r\n" : "\r\n"); + } + _nesting--; + indent(); + base::write("]"); + } else { + base::write("[]"); + } + return this->bytesWritten(); + } + + size_t visitObject(const CollectionData &object) { + VariantSlot *slot = object.head(); + if (slot) { + base::write("{\r\n"); + _nesting++; + while (slot != 0) { + indent(); + base::visitString(slot->key()); + base::write(": "); + slot->data()->accept(*this); + + slot = slot->next(); + base::write(slot ? ",\r\n" : "\r\n"); + } + _nesting--; + indent(); + base::write("}"); + } else { + base::write("{}"); + } + return this->bytesWritten(); + } + + private: + void indent() { + for (uint8_t i = 0; i < _nesting; i++) base::write(ARDUINOJSON_TAB); + } + + uint8_t _nesting; +}; + +template <typename TSource, typename TDestination> +size_t serializeJsonPretty(const TSource &source, TDestination &destination) { + return serialize<PrettyJsonSerializer>(source, destination); +} + +template <typename TSource> +size_t serializeJsonPretty(const TSource &source, void *buffer, + size_t bufferSize) { + return serialize<PrettyJsonSerializer>(source, buffer, bufferSize); +} + +template <typename TSource> +size_t measureJsonPretty(const TSource &source) { + return measure<PrettyJsonSerializer>(source); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Json/TextFormatter.hpp b/include/lib/ArduinoJson/Json/TextFormatter.hpp new file mode 100644 index 0000000..18694f1 --- /dev/null +++ b/include/lib/ArduinoJson/Json/TextFormatter.hpp @@ -0,0 +1,163 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <stdint.h> +#include <string.h> // for strlen + +#include <ArduinoJson/Json/EscapeSequence.hpp> +#include <ArduinoJson/Numbers/FloatParts.hpp> +#include <ArduinoJson/Numbers/Integer.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> +#include <ArduinoJson/Polyfills/attributes.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Serialization/CountingDecorator.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TWriter> +class TextFormatter { + public: + explicit TextFormatter(TWriter writer) : _writer(writer) {} + + // Returns the number of bytes sent to the TWriter implementation. + size_t bytesWritten() const { + return _writer.count(); + } + + void writeBoolean(bool value) { + if (value) + writeRaw("true"); + else + writeRaw("false"); + } + + void writeString(const char *value) { + ARDUINOJSON_ASSERT(value != NULL); + writeRaw('\"'); + while (*value) writeChar(*value++); + writeRaw('\"'); + } + + void writeChar(char c) { + char specialChar = EscapeSequence::escapeChar(c); + if (specialChar) { + writeRaw('\\'); + writeRaw(specialChar); + } else { + writeRaw(c); + } + } + + template <typename T> + void writeFloat(T value) { + if (isnan(value)) + return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null"); + +#if ARDUINOJSON_ENABLE_INFINITY + if (value < 0.0) { + writeRaw('-'); + value = -value; + } + + if (isinf(value)) + return writeRaw("Infinity"); +#else + if (isinf(value)) + return writeRaw("null"); + + if (value < 0.0) { + writeRaw('-'); + value = -value; + } +#endif + + FloatParts<T> parts(value); + + writeInteger(parts.integral); + if (parts.decimalPlaces) + writeDecimals(parts.decimal, parts.decimalPlaces); + + if (parts.exponent) { + writeRaw('e'); + writeInteger(parts.exponent); + } + } + + template <typename T> + typename enable_if<is_signed<T>::value>::type writeInteger(T value) { + typedef typename make_unsigned<T>::type unsigned_type; + unsigned_type unsigned_value; + if (value < 0) { + writeRaw('-'); + unsigned_value = unsigned_type(unsigned_type(~value) + 1); + } else { + unsigned_value = unsigned_type(value); + } + writeInteger(unsigned_value); + } + + template <typename T> + typename enable_if<is_unsigned<T>::value>::type writeInteger(T value) { + char buffer[22]; + char *end = buffer + sizeof(buffer); + char *begin = end; + + // write the string in reverse order + do { + *--begin = char(value % 10 + '0'); + value = T(value / 10); + } while (value); + + // and dump it in the right order + writeRaw(begin, end); + } + + void writeDecimals(uint32_t value, int8_t width) { + // buffer should be big enough for all digits and the dot + char buffer[16]; + char *end = buffer + sizeof(buffer); + char *begin = end; + + // write the string in reverse order + while (width--) { + *--begin = char(value % 10 + '0'); + value /= 10; + } + *--begin = '.'; + + // and dump it in the right order + writeRaw(begin, end); + } + + void writeRaw(const char *s) { + _writer.write(reinterpret_cast<const uint8_t *>(s), strlen(s)); + } + + void writeRaw(const char *s, size_t n) { + _writer.write(reinterpret_cast<const uint8_t *>(s), n); + } + + void writeRaw(const char *begin, const char *end) { + _writer.write(reinterpret_cast<const uint8_t *>(begin), + static_cast<size_t>(end - begin)); + } + + template <size_t N> + void writeRaw(const char (&s)[N]) { + _writer.write(reinterpret_cast<const uint8_t *>(s), N - 1); + } + void writeRaw(char c) { + _writer.write(static_cast<uint8_t>(c)); + } + + protected: + CountingDecorator<TWriter> _writer; + size_t _length; + + private: + TextFormatter &operator=(const TextFormatter &); // cannot be assigned +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Json/Utf16.hpp b/include/lib/ArduinoJson/Json/Utf16.hpp new file mode 100644 index 0000000..4e2750f --- /dev/null +++ b/include/lib/ArduinoJson/Json/Utf16.hpp @@ -0,0 +1,67 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +#include <stdint.h> // uint16_t, uint32_t + +// The high surrogate may be uninitialized if the pair is invalid, +// we choose to ignore the problem to reduce the size of the code +// Garbage in => Garbage out +#if defined(__GNUC__) +#if __GNUC__ >= 7 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif +#endif + +namespace ARDUINOJSON_NAMESPACE { + +namespace Utf16 { +inline bool isHighSurrogate(uint16_t codeunit) { + return codeunit >= 0xD800 && codeunit < 0xDC00; +} + +inline bool isLowSurrogate(uint16_t codeunit) { + return codeunit >= 0xDC00 && codeunit < 0xE000; +} + +class Codepoint { + public: + Codepoint() : _highSurrogate(0) {} + + bool append(uint16_t codeunit) { + if (isHighSurrogate(codeunit)) { + _highSurrogate = codeunit & 0x3FF; + return false; + } + + if (isLowSurrogate(codeunit)) { + _codepoint = + uint32_t(0x10000 + ((_highSurrogate << 10) | (codeunit & 0x3FF))); + return true; + } + + _codepoint = codeunit; + return true; + } + + uint32_t value() const { + return _codepoint; + } + + private: + uint16_t _highSurrogate; + uint32_t _codepoint; +}; +} // namespace Utf16 +} // namespace ARDUINOJSON_NAMESPACE + +#if defined(__GNUC__) +#if __GNUC__ >= 8 +#pragma GCC diagnostic pop +#endif +#endif diff --git a/include/lib/ArduinoJson/Json/Utf8.hpp b/include/lib/ArduinoJson/Json/Utf8.hpp new file mode 100644 index 0000000..a30f77a --- /dev/null +++ b/include/lib/ArduinoJson/Json/Utf8.hpp @@ -0,0 +1,46 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +namespace Utf8 { +template <typename TStringBuilder> +inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) { + // this function was optimize for code size on AVR + + // a buffer to store the string in reverse + char buf[5]; + char* p = buf; + + *(p++) = 0; + if (codepoint32 < 0x80) { + *(p++) = char((codepoint32)); + } else { + *(p++) = char((codepoint32 | 0x80) & 0xBF); + uint16_t codepoint16 = uint16_t(codepoint32 >> 6); + if (codepoint16 < 0x20) { // 0x800 + *(p++) = char(codepoint16 | 0xC0); + } else { + *(p++) = char((codepoint16 | 0x80) & 0xBF); + codepoint16 = uint16_t(codepoint16 >> 6); + if (codepoint16 < 0x10) { // 0x10000 + *(p++) = char(codepoint16 | 0xE0); + } else { + *(p++) = char((codepoint16 | 0x80) & 0xBF); + codepoint16 = uint16_t(codepoint16 >> 6); + *(p++) = char(codepoint16 | 0xF0); + } + } + } + + while (*(--p)) { + str.append(*p); + } +} +} // namespace Utf8 +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Memory/Alignment.hpp b/include/lib/ArduinoJson/Memory/Alignment.hpp new file mode 100644 index 0000000..bf16798 --- /dev/null +++ b/include/lib/ArduinoJson/Memory/Alignment.hpp @@ -0,0 +1,60 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +#include <stddef.h> // size_t + +namespace ARDUINOJSON_NAMESPACE { + +#if ARDUINOJSON_ENABLE_ALIGNMENT + +inline bool isAligned(size_t value) { + const size_t mask = sizeof(void *) - 1; + size_t addr = value; + return (addr & mask) == 0; +} + +inline size_t addPadding(size_t bytes) { + const size_t mask = sizeof(void *) - 1; + return (bytes + mask) & ~mask; +} + +template <size_t bytes> +struct AddPadding { + static const size_t mask = sizeof(void *) - 1; + static const size_t value = (bytes + mask) & ~mask; +}; + +#else + +inline bool isAligned(size_t) { + return true; +} + +inline size_t addPadding(size_t bytes) { + return bytes; +} + +template <size_t bytes> +struct AddPadding { + static const size_t value = bytes; +}; + +#endif + +template <typename T> +inline bool isAligned(T *ptr) { + return isAligned(reinterpret_cast<size_t>(ptr)); +} + +template <typename T> +inline T *addPadding(T *p) { + size_t address = addPadding(reinterpret_cast<size_t>(p)); + return reinterpret_cast<T *>(address); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Memory/MemoryPool.hpp b/include/lib/ArduinoJson/Memory/MemoryPool.hpp new file mode 100644 index 0000000..49debf8 --- /dev/null +++ b/include/lib/ArduinoJson/Memory/MemoryPool.hpp @@ -0,0 +1,212 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Memory/Alignment.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> +#include <ArduinoJson/Polyfills/mpl/max.hpp> +#include <ArduinoJson/Variant/VariantSlot.hpp> + +#include <string.h> // memmove + +#define JSON_STRING_SIZE(SIZE) (SIZE + 1) + +namespace ARDUINOJSON_NAMESPACE { + +// _begin _end +// v v +// +-------------+--------------+--------------+ +// | strings... | (free) | ...variants | +// +-------------+--------------+--------------+ +// ^ ^ +// _left _right + +class MemoryPool { + public: + MemoryPool(char* buf, size_t capa) + : _begin(buf), + _left(buf), + _right(buf ? buf + capa : 0), + _end(buf ? buf + capa : 0), + _overflowed(false) { + ARDUINOJSON_ASSERT(isAligned(_begin)); + ARDUINOJSON_ASSERT(isAligned(_right)); + ARDUINOJSON_ASSERT(isAligned(_end)); + } + + void* buffer() { + return _begin; + } + + // Gets the capacity of the memoryPool in bytes + size_t capacity() const { + return size_t(_end - _begin); + } + + size_t size() const { + return size_t(_left - _begin + _end - _right); + } + + bool overflowed() const { + return _overflowed; + } + + VariantSlot* allocVariant() { + return allocRight<VariantSlot>(); + } + + template <typename TAdaptedString> + const char* saveString(const TAdaptedString& str) { + if (str.isNull()) + return 0; + +#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION + const char* existingCopy = findString(str.begin()); + if (existingCopy) + return existingCopy; +#endif + + size_t n = str.size(); + + char* newCopy = allocString(n + 1); + if (newCopy) { + str.copyTo(newCopy, n); + newCopy[n] = 0; // force null-terminator + } + return newCopy; + } + + void getFreeZone(char** zoneStart, size_t* zoneSize) const { + *zoneStart = _left; + *zoneSize = size_t(_right - _left); + } + + const char* saveStringFromFreeZone(size_t len) { +#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION + const char* dup = findString(_left); + if (dup) + return dup; +#endif + + const char* str = _left; + _left += len; + checkInvariants(); + return str; + } + + void markAsOverflowed() { + _overflowed = true; + } + + void clear() { + _left = _begin; + _right = _end; + _overflowed = false; + } + + bool canAlloc(size_t bytes) const { + return _left + bytes <= _right; + } + + bool owns(void* p) const { + return _begin <= p && p < _end; + } + + // Workaround for missing placement new + void* operator new(size_t, void* p) { + return p; + } + + // Squash the free space between strings and variants + // + // _begin _end + // v v + // +-------------+--------------+ + // | strings... | ...variants | + // +-------------+--------------+ + // ^ + // _left _right + // + // This funcion is called before a realloc. + ptrdiff_t squash() { + char* new_right = addPadding(_left); + if (new_right >= _right) + return 0; + + size_t right_size = static_cast<size_t>(_end - _right); + memmove(new_right, _right, right_size); + + ptrdiff_t bytes_reclaimed = _right - new_right; + _right = new_right; + _end = new_right + right_size; + return bytes_reclaimed; + } + + // Move all pointers together + // This funcion is called after a realloc. + void movePointers(ptrdiff_t offset) { + _begin += offset; + _left += offset; + _right += offset; + _end += offset; + } + + private: + void checkInvariants() { + ARDUINOJSON_ASSERT(_begin <= _left); + ARDUINOJSON_ASSERT(_left <= _right); + ARDUINOJSON_ASSERT(_right <= _end); + ARDUINOJSON_ASSERT(isAligned(_right)); + } + +#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION + template <typename TIterator> + const char* findString(TIterator str) { + for (char* next = _begin; next < _left; ++next) { + char* begin = next; + + // try to match + for (TIterator it = str; *it == *next; ++it) { + if (*next++ == 0) + return begin; + } + + // jump to next terminator + while (*next) ++next; + } + return 0; + } +#endif + + char* allocString(size_t n) { + if (!canAlloc(n)) { + _overflowed = true; + return 0; + } + char* s = _left; + _left += n; + checkInvariants(); + return s; + } + + template <typename T> + T* allocRight() { + return reinterpret_cast<T*>(allocRight(sizeof(T))); + } + + void* allocRight(size_t bytes) { + if (!canAlloc(bytes)) { + _overflowed = true; + return 0; + } + _right -= bytes; + return _right; + } + + char *_begin, *_left, *_right, *_end; + bool _overflowed; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Misc/SerializedValue.hpp b/include/lib/ArduinoJson/Misc/SerializedValue.hpp new file mode 100644 index 0000000..30173bf --- /dev/null +++ b/include/lib/ArduinoJson/Misc/SerializedValue.hpp @@ -0,0 +1,68 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Strings/StringAdapters.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// A special type of data that can be used to insert pregenerated JSON portions. +template <typename T> +class SerializedValue { + public: + explicit SerializedValue(T str) : _str(str) {} + operator T() const { + return _str; + } + + const char* data() const { + return _str.c_str(); + } + + size_t size() const { + // CAUTION: the old Arduino String doesn't have size() + return _str.length(); + } + + private: + T _str; +}; + +template <typename TChar> +class SerializedValue<TChar*> { + public: + explicit SerializedValue(TChar* p, size_t n) : _data(p), _size(n) {} + operator TChar*() const { + return _data; + } + + TChar* data() const { + return _data; + } + + size_t size() const { + return _size; + } + + private: + TChar* _data; + size_t _size; +}; + +template <typename T> +inline SerializedValue<T> serialized(T str) { + return SerializedValue<T>(str); +} + +template <typename TChar> +inline SerializedValue<TChar*> serialized(TChar* p) { + return SerializedValue<TChar*>(p, adaptString(p).size()); +} + +template <typename TChar> +inline SerializedValue<TChar*> serialized(TChar* p, size_t n) { + return SerializedValue<TChar*>(p, n); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Misc/Visitable.hpp b/include/lib/ArduinoJson/Misc/Visitable.hpp new file mode 100644 index 0000000..f25d12f --- /dev/null +++ b/include/lib/ArduinoJson/Misc/Visitable.hpp @@ -0,0 +1,21 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/type_traits.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +struct Visitable { + // template<Visitor> + // void accept(Visitor&) const; +}; + +template <typename T> +struct IsVisitable : is_base_of<Visitable, T> {}; + +template <typename T> +struct IsVisitable<T &> : IsVisitable<T> {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/MsgPack/MsgPackDeserializer.hpp b/include/lib/ArduinoJson/MsgPack/MsgPackDeserializer.hpp new file mode 100644 index 0000000..49c6fd4 --- /dev/null +++ b/include/lib/ArduinoJson/MsgPack/MsgPackDeserializer.hpp @@ -0,0 +1,599 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Deserialization/deserialize.hpp> +#include <ArduinoJson/Memory/MemoryPool.hpp> +#include <ArduinoJson/MsgPack/endianess.hpp> +#include <ArduinoJson/MsgPack/ieee754.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TReader, typename TStringStorage> +class MsgPackDeserializer { + public: + MsgPackDeserializer(MemoryPool &pool, TReader reader, + TStringStorage stringStorage) + : _pool(&pool), + _reader(reader), + _stringStorage(stringStorage), + _error(DeserializationError::Ok), + _foundSomething(false) {} + + template <typename TFilter> + DeserializationError parse(VariantData &variant, TFilter filter, + NestingLimit nestingLimit) { + parseVariant(&variant, filter, nestingLimit); + return _foundSomething ? _error : DeserializationError::EmptyInput; + } + + private: + // Prevent VS warning "assignment operator could not be generated" + MsgPackDeserializer &operator=(const MsgPackDeserializer &); + + bool invalidInput() { + _error = DeserializationError::InvalidInput; + return false; + } + + template <typename TFilter> + bool parseVariant(VariantData *variant, TFilter filter, + NestingLimit nestingLimit) { + uint8_t code = 0; // TODO: why do we need to initialize this variable? + if (!readByte(code)) + return false; + + _foundSomething = true; + + bool allowValue = filter.allowValue(); + + switch (code) { + case 0xc0: + // already null + return true; + + case 0xc1: + return invalidInput(); + + case 0xc2: + if (allowValue) + variant->setBoolean(false); + return true; + + case 0xc3: + if (allowValue) + variant->setBoolean(true); + return true; + + case 0xc4: // bin 8 (not supported) + return skipString<uint8_t>(); + + case 0xc5: // bin 16 (not supported) + return skipString<uint16_t>(); + + case 0xc6: // bin 32 (not supported) + return skipString<uint32_t>(); + + case 0xc7: // ext 8 (not supported) + return skipExt<uint8_t>(); + + case 0xc8: // ext 16 (not supported) + return skipExt<uint16_t>(); + + case 0xc9: // ext 32 (not supported) + return skipExt<uint32_t>(); + + case 0xca: + if (allowValue) + return readFloat<float>(variant); + else + return skipBytes(4); + + case 0xcb: + if (allowValue) + return readDouble<double>(variant); + else + return skipBytes(8); + + case 0xcc: + if (allowValue) + return readInteger<uint8_t>(variant); + else + return skipBytes(1); + + case 0xcd: + if (allowValue) + return readInteger<uint16_t>(variant); + else + return skipBytes(2); + + case 0xce: + if (allowValue) + return readInteger<uint32_t>(variant); + else + return skipBytes(4); + + case 0xcf: +#if ARDUINOJSON_USE_LONG_LONG + if (allowValue) + return readInteger<uint64_t>(variant); + else + return skipBytes(8); +#else + return skipBytes(8); // not supported +#endif + + case 0xd0: + if (allowValue) + return readInteger<int8_t>(variant); + else + return skipBytes(1); + + case 0xd1: + if (allowValue) + return readInteger<int16_t>(variant); + else + return skipBytes(2); + + case 0xd2: + if (allowValue) + return readInteger<int32_t>(variant); + else + return skipBytes(4); + + case 0xd3: +#if ARDUINOJSON_USE_LONG_LONG + if (allowValue) + return readInteger<int64_t>(variant); + else + return skipBytes(8); // not supported +#else + return skipBytes(8); +#endif + + case 0xd4: // fixext 1 (not supported) + return skipBytes(2); + + case 0xd5: // fixext 2 (not supported) + return skipBytes(3); + + case 0xd6: // fixext 4 (not supported) + return skipBytes(5); + + case 0xd7: // fixext 8 (not supported) + return skipBytes(9); + + case 0xd8: // fixext 16 (not supported) + return skipBytes(17); + + case 0xd9: + if (allowValue) + return readString<uint8_t>(variant); + else + return skipString<uint8_t>(); + + case 0xda: + if (allowValue) + return readString<uint16_t>(variant); + else + return skipString<uint16_t>(); + + case 0xdb: + if (allowValue) + return readString<uint32_t>(variant); + else + return skipString<uint32_t>(); + + case 0xdc: + return readArray<uint16_t>(variant, filter, nestingLimit); + + case 0xdd: + return readArray<uint32_t>(variant, filter, nestingLimit); + + case 0xde: + return readObject<uint16_t>(variant, filter, nestingLimit); + + case 0xdf: + return readObject<uint32_t>(variant, filter, nestingLimit); + } + + switch (code & 0xf0) { + case 0x80: + return readObject(variant, code & 0x0F, filter, nestingLimit); + + case 0x90: + return readArray(variant, code & 0x0F, filter, nestingLimit); + } + + if ((code & 0xe0) == 0xa0) { + if (allowValue) + return readString(variant, code & 0x1f); + else + return skipBytes(code & 0x1f); + } + + if (allowValue) + variant->setInteger(static_cast<int8_t>(code)); + + return true; + } + + bool readByte(uint8_t &value) { + int c = _reader.read(); + if (c < 0) { + _error = DeserializationError::IncompleteInput; + return false; + } + value = static_cast<uint8_t>(c); + return true; + } + + bool readBytes(uint8_t *p, size_t n) { + if (_reader.readBytes(reinterpret_cast<char *>(p), n) == n) + return true; + _error = DeserializationError::IncompleteInput; + return false; + } + + template <typename T> + bool readBytes(T &value) { + return readBytes(reinterpret_cast<uint8_t *>(&value), sizeof(value)); + } + + bool skipBytes(size_t n) { + for (; n; --n) { + if (_reader.read() < 0) { + _error = DeserializationError::IncompleteInput; + return false; + } + } + return true; + } + + template <typename T> + bool readInteger(T &value) { + if (!readBytes(value)) + return false; + fixEndianess(value); + return true; + } + + template <typename T> + bool readInteger(VariantData *variant) { + T value; + if (!readInteger(value)) + return false; + variant->setInteger(value); + return true; + } + + template <typename T> + typename enable_if<sizeof(T) == 4, bool>::type readFloat( + VariantData *variant) { + T value; + if (!readBytes(value)) + return false; + fixEndianess(value); + variant->setFloat(value); + return true; + } + + template <typename T> + typename enable_if<sizeof(T) == 8, bool>::type readDouble( + VariantData *variant) { + T value; + if (!readBytes(value)) + return false; + fixEndianess(value); + variant->setFloat(value); + return true; + } + + template <typename T> + typename enable_if<sizeof(T) == 4, bool>::type readDouble( + VariantData *variant) { + uint8_t i[8]; // input is 8 bytes + T value; // output is 4 bytes + uint8_t *o = reinterpret_cast<uint8_t *>(&value); + if (!readBytes(i, 8)) + return false; + doubleToFloat(i, o); + fixEndianess(value); + variant->setFloat(value); + return true; + } + + template <typename T> + bool readString(VariantData *variant) { + T size; + if (!readInteger(size)) + return false; + return readString(variant, size); + } + + template <typename T> + bool readString() { + T size; + if (!readInteger(size)) + return false; + return readString(size); + } + + template <typename T> + bool skipString() { + T size; + if (!readInteger(size)) + return false; + return skipBytes(size); + } + + bool readString(VariantData *variant, size_t n) { + if (!readString(n)) + return false; + variant->setStringPointer(_stringStorage.save(), + typename TStringStorage::storage_policy()); + return true; + } + + bool readString(size_t n) { + _stringStorage.startString(); + for (; n; --n) { + uint8_t c; + if (!readBytes(c)) + return false; + _stringStorage.append(static_cast<char>(c)); + } + _stringStorage.append('\0'); + if (!_stringStorage.isValid()) { + _error = DeserializationError::NoMemory; + return false; + } + + return true; + } + + template <typename TSize, typename TFilter> + bool readArray(VariantData *variant, TFilter filter, + NestingLimit nestingLimit) { + TSize size; + if (!readInteger(size)) + return false; + return readArray(variant, size, filter, nestingLimit); + } + + template <typename TFilter> + bool readArray(VariantData *variant, size_t n, TFilter filter, + NestingLimit nestingLimit) { + if (nestingLimit.reached()) { + _error = DeserializationError::TooDeep; + return false; + } + + bool allowArray = filter.allowArray(); + + CollectionData *array = allowArray ? &variant->toArray() : 0; + + TFilter memberFilter = filter[0U]; + + for (; n; --n) { + VariantData *value; + + if (memberFilter.allow()) { + value = array->addElement(_pool); + if (!value) { + _error = DeserializationError::NoMemory; + return false; + } + } else { + value = 0; + } + + if (!parseVariant(value, memberFilter, nestingLimit.decrement())) + return false; + } + + return true; + } + + template <typename TSize, typename TFilter> + bool readObject(VariantData *variant, TFilter filter, + NestingLimit nestingLimit) { + TSize size; + if (!readInteger(size)) + return false; + return readObject(variant, size, filter, nestingLimit); + } + + template <typename TFilter> + bool readObject(VariantData *variant, size_t n, TFilter filter, + NestingLimit nestingLimit) { + if (nestingLimit.reached()) { + _error = DeserializationError::TooDeep; + return false; + } + + CollectionData *object = filter.allowObject() ? &variant->toObject() : 0; + + for (; n; --n) { + if (!readKey()) + return false; + + const char *key = _stringStorage.c_str(); + TFilter memberFilter = filter[key]; + VariantData *member; + + if (memberFilter.allow()) { + // Save key in memory pool. + // This MUST be done before adding the slot. + key = _stringStorage.save(); + + VariantSlot *slot = object->addSlot(_pool); + if (!slot) { + _error = DeserializationError::NoMemory; + return false; + } + + slot->setKey(key, typename TStringStorage::storage_policy()); + + member = slot->data(); + } else { + member = 0; + } + + if (!parseVariant(member, memberFilter, nestingLimit.decrement())) + return false; + } + + return true; + } + + bool readKey() { + uint8_t code; + if (!readByte(code)) + return false; + + if ((code & 0xe0) == 0xa0) + return readString(code & 0x1f); + + switch (code) { + case 0xd9: + return readString<uint8_t>(); + + case 0xda: + return readString<uint16_t>(); + + case 0xdb: + return readString<uint32_t>(); + + default: + return invalidInput(); + } + } + + template <typename T> + bool skipExt() { + T size; + if (!readInteger(size)) + return false; + return skipBytes(size + 1); + } + + MemoryPool *_pool; + TReader _reader; + TStringStorage _stringStorage; + DeserializationError _error; + bool _foundSomething; +}; + +// +// deserializeMsgPack(JsonDocument&, const std::string&, ...) +// +// ... = NestingLimit +template <typename TString> +DeserializationError deserializeMsgPack( + JsonDocument &doc, const TString &input, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TString> +DeserializationError deserializeMsgPack( + JsonDocument &doc, const TString &input, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter); +} +// ... = NestingLimit, Filter +template <typename TString> +DeserializationError deserializeMsgPack(JsonDocument &doc, const TString &input, + NestingLimit nestingLimit, + Filter filter) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter); +} + +// +// deserializeMsgPack(JsonDocument&, std::istream&, ...) +// +// ... = NestingLimit +template <typename TStream> +DeserializationError deserializeMsgPack( + JsonDocument &doc, TStream &input, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TStream> +DeserializationError deserializeMsgPack( + JsonDocument &doc, TStream &input, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter); +} +// ... = NestingLimit, Filter +template <typename TStream> +DeserializationError deserializeMsgPack(JsonDocument &doc, TStream &input, + NestingLimit nestingLimit, + Filter filter) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter); +} + +// +// deserializeMsgPack(JsonDocument&, char*, ...) +// +// ... = NestingLimit +template <typename TChar> +DeserializationError deserializeMsgPack( + JsonDocument &doc, TChar *input, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TChar> +DeserializationError deserializeMsgPack( + JsonDocument &doc, TChar *input, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter); +} +// ... = NestingLimit, Filter +template <typename TChar> +DeserializationError deserializeMsgPack(JsonDocument &doc, TChar *input, + NestingLimit nestingLimit, + Filter filter) { + return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter); +} + +// +// deserializeMsgPack(JsonDocument&, char*, size_t, ...) +// +// ... = NestingLimit +template <typename TChar> +DeserializationError deserializeMsgPack( + JsonDocument &doc, TChar *input, size_t inputSize, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit, + AllowAllFilter()); +} +// ... = Filter, NestingLimit +template <typename TChar> +DeserializationError deserializeMsgPack( + JsonDocument &doc, TChar *input, size_t inputSize, Filter filter, + NestingLimit nestingLimit = NestingLimit()) { + return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit, + filter); +} +// ... = NestingLimit, Filter +template <typename TChar> +DeserializationError deserializeMsgPack(JsonDocument &doc, TChar *input, + size_t inputSize, + NestingLimit nestingLimit, + Filter filter) { + return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit, + filter); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/MsgPack/MsgPackSerializer.hpp b/include/lib/ArduinoJson/MsgPack/MsgPackSerializer.hpp new file mode 100644 index 0000000..b1cd872 --- /dev/null +++ b/include/lib/ArduinoJson/MsgPack/MsgPackSerializer.hpp @@ -0,0 +1,212 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/MsgPack/endianess.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Serialization/CountingDecorator.hpp> +#include <ArduinoJson/Serialization/measure.hpp> +#include <ArduinoJson/Serialization/serialize.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TWriter> +class MsgPackSerializer : public Visitor<size_t> { + public: + static const bool producesText = false; + + MsgPackSerializer(TWriter writer) : _writer(writer) {} + + template <typename T> + typename enable_if<sizeof(T) == 4, size_t>::type visitFloat(T value32) { + writeByte(0xCA); + writeInteger(value32); + return bytesWritten(); + } + + template <typename T> + ARDUINOJSON_NO_SANITIZE("float-cast-overflow") + typename enable_if<sizeof(T) == 8, size_t>::type visitFloat(T value64) { + float value32 = float(value64); + if (value32 == value64) { + writeByte(0xCA); + writeInteger(value32); + } else { + writeByte(0xCB); + writeInteger(value64); + } + return bytesWritten(); + } + + size_t visitArray(const CollectionData& array) { + size_t n = array.size(); + if (n < 0x10) { + writeByte(uint8_t(0x90 + array.size())); + } else if (n < 0x10000) { + writeByte(0xDC); + writeInteger(uint16_t(n)); + } else { + writeByte(0xDD); + writeInteger(uint32_t(n)); + } + for (VariantSlot* slot = array.head(); slot; slot = slot->next()) { + slot->data()->accept(*this); + } + return bytesWritten(); + } + + size_t visitObject(const CollectionData& object) { + size_t n = object.size(); + if (n < 0x10) { + writeByte(uint8_t(0x80 + n)); + } else if (n < 0x10000) { + writeByte(0xDE); + writeInteger(uint16_t(n)); + } else { + writeByte(0xDF); + writeInteger(uint32_t(n)); + } + for (VariantSlot* slot = object.head(); slot; slot = slot->next()) { + visitString(slot->key()); + slot->data()->accept(*this); + } + return bytesWritten(); + } + + size_t visitString(const char* value) { + ARDUINOJSON_ASSERT(value != NULL); + + size_t n = strlen(value); + + if (n < 0x20) { + writeByte(uint8_t(0xA0 + n)); + } else if (n < 0x100) { + writeByte(0xD9); + writeInteger(uint8_t(n)); + } else if (n < 0x10000) { + writeByte(0xDA); + writeInteger(uint16_t(n)); + } else { + writeByte(0xDB); + writeInteger(uint32_t(n)); + } + writeBytes(reinterpret_cast<const uint8_t*>(value), n); + return bytesWritten(); + } + + size_t visitRawJson(const char* data, size_t size) { + writeBytes(reinterpret_cast<const uint8_t*>(data), size); + return bytesWritten(); + } + + size_t visitSignedInteger(Integer value) { + if (value > 0) { + visitUnsignedInteger(static_cast<UInt>(value)); + } else if (value >= -0x20) { + writeInteger(int8_t(value)); + } else if (value >= -0x80) { + writeByte(0xD0); + writeInteger(int8_t(value)); + } else if (value >= -0x8000) { + writeByte(0xD1); + writeInteger(int16_t(value)); + } +#if ARDUINOJSON_USE_LONG_LONG + else if (value >= -0x80000000LL) +#else + else +#endif + { + writeByte(0xD2); + writeInteger(int32_t(value)); + } +#if ARDUINOJSON_USE_LONG_LONG + else { + writeByte(0xD3); + writeInteger(int64_t(value)); + } +#endif + return bytesWritten(); + } + + size_t visitUnsignedInteger(UInt value) { + if (value <= 0x7F) { + writeInteger(uint8_t(value)); + } else if (value <= 0xFF) { + writeByte(0xCC); + writeInteger(uint8_t(value)); + } else if (value <= 0xFFFF) { + writeByte(0xCD); + writeInteger(uint16_t(value)); + } +#if ARDUINOJSON_USE_LONG_LONG + else if (value <= 0xFFFFFFFF) +#else + else +#endif + { + writeByte(0xCE); + writeInteger(uint32_t(value)); + } +#if ARDUINOJSON_USE_LONG_LONG + else { + writeByte(0xCF); + writeInteger(uint64_t(value)); + } +#endif + return bytesWritten(); + } + + size_t visitBoolean(bool value) { + writeByte(value ? 0xC3 : 0xC2); + return bytesWritten(); + } + + size_t visitNull() { + writeByte(0xC0); + return bytesWritten(); + } + + private: + size_t bytesWritten() const { + return _writer.count(); + } + + void writeByte(uint8_t c) { + _writer.write(c); + } + + void writeBytes(const uint8_t* p, size_t n) { + _writer.write(p, n); + } + + template <typename T> + void writeInteger(T value) { + fixEndianess(value); + writeBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value)); + } + + CountingDecorator<TWriter> _writer; +}; + +template <typename TSource, typename TDestination> +inline size_t serializeMsgPack(const TSource& source, TDestination& output) { + return serialize<MsgPackSerializer>(source, output); +} + +template <typename TSource> +inline size_t serializeMsgPack(const TSource& source, void* output, + size_t size) { + return serialize<MsgPackSerializer>(source, output, size); +} + +template <typename TSource> +inline size_t measureMsgPack(const TSource& source) { + return measure<MsgPackSerializer>(source); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/MsgPack/endianess.hpp b/include/lib/ArduinoJson/MsgPack/endianess.hpp new file mode 100644 index 0000000..74f7e9d --- /dev/null +++ b/include/lib/ArduinoJson/MsgPack/endianess.hpp @@ -0,0 +1,41 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Polyfills/utility.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +#if ARDUINOJSON_LITTLE_ENDIAN +inline void fixEndianess(uint8_t *p, integral_constant<size_t, 8>) { + swap(p[0], p[7]); + swap(p[1], p[6]); + swap(p[2], p[5]); + swap(p[3], p[4]); +} + +inline void fixEndianess(uint8_t *p, integral_constant<size_t, 4>) { + swap(p[0], p[3]); + swap(p[1], p[2]); +} + +inline void fixEndianess(uint8_t *p, integral_constant<size_t, 2>) { + swap(p[0], p[1]); +} + +inline void fixEndianess(uint8_t *, integral_constant<size_t, 1>) {} + +template <typename T> +inline void fixEndianess(T &value) { + fixEndianess(reinterpret_cast<uint8_t *>(&value), + integral_constant<size_t, sizeof(T)>()); +} +#else +template <typename T> +inline void fixEndianess(T &) {} +#endif + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/MsgPack/ieee754.hpp b/include/lib/ArduinoJson/MsgPack/ieee754.hpp new file mode 100644 index 0000000..016d533 --- /dev/null +++ b/include/lib/ArduinoJson/MsgPack/ieee754.hpp @@ -0,0 +1,18 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) { + f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5)); + f[1] = uint8_t((d[1] << 3) | (d[2] >> 5)); + f[2] = uint8_t((d[2] << 3) | (d[3] >> 5)); + f[3] = uint8_t((d[3] << 3) | (d[4] >> 5)); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Namespace.hpp b/include/lib/ArduinoJson/Namespace.hpp new file mode 100644 index 0000000..2d85440 --- /dev/null +++ b/include/lib/ArduinoJson/Namespace.hpp @@ -0,0 +1,26 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Polyfills/preprocessor.hpp> +#include <ArduinoJson/version.hpp> + +#ifndef ARDUINOJSON_NAMESPACE + +#define ARDUINOJSON_NAMESPACE \ + ARDUINOJSON_CONCAT4( \ + ARDUINOJSON_CONCAT4(ArduinoJson, ARDUINOJSON_VERSION_MAJOR, \ + ARDUINOJSON_VERSION_MINOR, \ + ARDUINOJSON_VERSION_REVISION), \ + _, \ + ARDUINOJSON_HEX_DIGIT(ARDUINOJSON_ENABLE_PROGMEM, \ + ARDUINOJSON_USE_LONG_LONG, ARDUINOJSON_USE_DOUBLE, \ + ARDUINOJSON_ENABLE_STRING_DEDUPLICATION), \ + ARDUINOJSON_HEX_DIGIT( \ + ARDUINOJSON_ENABLE_NAN, ARDUINOJSON_ENABLE_INFINITY, \ + ARDUINOJSON_ENABLE_COMMENTS, ARDUINOJSON_DECODE_UNICODE)) + +#endif diff --git a/include/lib/ArduinoJson/Numbers/Float.hpp b/include/lib/ArduinoJson/Numbers/Float.hpp new file mode 100644 index 0000000..bbaca04 --- /dev/null +++ b/include/lib/ArduinoJson/Numbers/Float.hpp @@ -0,0 +1,17 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +#if ARDUINOJSON_USE_DOUBLE +typedef double Float; +#else +typedef float Float; +#endif +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Numbers/FloatParts.hpp b/include/lib/ArduinoJson/Numbers/FloatParts.hpp new file mode 100644 index 0000000..4e53add --- /dev/null +++ b/include/lib/ArduinoJson/Numbers/FloatParts.hpp @@ -0,0 +1,87 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Numbers/FloatTraits.hpp> +#include <ArduinoJson/Polyfills/math.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TFloat> +struct FloatParts { + uint32_t integral; + uint32_t decimal; + int16_t exponent; + int8_t decimalPlaces; + + FloatParts(TFloat value) { + uint32_t maxDecimalPart = sizeof(TFloat) >= 8 ? 1000000000 : 1000000; + decimalPlaces = sizeof(TFloat) >= 8 ? 9 : 6; + + exponent = normalize(value); + + integral = uint32_t(value); + // reduce number of decimal places by the number of integral places + for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) { + maxDecimalPart /= 10; + decimalPlaces--; + } + + TFloat remainder = (value - TFloat(integral)) * TFloat(maxDecimalPart); + + decimal = uint32_t(remainder); + remainder = remainder - TFloat(decimal); + + // rounding: + // increment by 1 if remainder >= 0.5 + decimal += uint32_t(remainder * 2); + if (decimal >= maxDecimalPart) { + decimal = 0; + integral++; + if (exponent && integral >= 10) { + exponent++; + integral = 1; + } + } + + // remove trailing zeros + while (decimal % 10 == 0 && decimalPlaces > 0) { + decimal /= 10; + decimalPlaces--; + } + } + + static int16_t normalize(TFloat& value) { + typedef FloatTraits<TFloat> traits; + int16_t powersOf10 = 0; + + int8_t index = sizeof(TFloat) == 8 ? 8 : 5; + int bit = 1 << index; + + if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) { + for (; index >= 0; index--) { + if (value >= traits::positiveBinaryPowerOfTen(index)) { + value *= traits::negativeBinaryPowerOfTen(index); + powersOf10 = int16_t(powersOf10 + bit); + } + bit >>= 1; + } + } + + if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) { + for (; index >= 0; index--) { + if (value < traits::negativeBinaryPowerOfTenPlusOne(index)) { + value *= traits::positiveBinaryPowerOfTen(index); + powersOf10 = int16_t(powersOf10 - bit); + } + bit >>= 1; + } + } + + return powersOf10; + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Numbers/FloatTraits.hpp b/include/lib/ArduinoJson/Numbers/FloatTraits.hpp new file mode 100644 index 0000000..60b1dfd --- /dev/null +++ b/include/lib/ArduinoJson/Numbers/FloatTraits.hpp @@ -0,0 +1,201 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <stddef.h> // for size_t +#include <stdint.h> + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Polyfills/alias_cast.hpp> +#include <ArduinoJson/Polyfills/math.hpp> +#include <ArduinoJson/Polyfills/preprocessor.hpp> +#include <ArduinoJson/Polyfills/static_array.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T, size_t = sizeof(T)> +struct FloatTraits {}; + +template <typename T> +struct FloatTraits<T, 8 /*64bits*/> { + typedef uint64_t mantissa_type; + static const short mantissa_bits = 52; + static const mantissa_type mantissa_max = + (mantissa_type(1) << mantissa_bits) - 1; + + typedef int16_t exponent_type; + static const exponent_type exponent_max = 308; + + template <typename TExponent> + static T make_float(T m, TExponent e) { + if (e > 0) { + for (uint8_t index = 0; e != 0; index++) { + if (e & 1) + m *= positiveBinaryPowerOfTen(index); + e >>= 1; + } + } else { + e = TExponent(-e); + for (uint8_t index = 0; e != 0; index++) { + if (e & 1) + m *= negativeBinaryPowerOfTen(index); + e >>= 1; + } + } + return m; + } + + static T positiveBinaryPowerOfTen(int index) { + ARDUINOJSON_DEFINE_STATIC_ARRAY( // + uint32_t, factors, + ARDUINOJSON_EXPAND18({ + 0x40240000, 0x00000000, // 1e1 + 0x40590000, 0x00000000, // 1e2 + 0x40C38800, 0x00000000, // 1e4 + 0x4197D784, 0x00000000, // 1e8 + 0x4341C379, 0x37E08000, // 1e16 + 0x4693B8B5, 0xB5056E17, // 1e32 + 0x4D384F03, 0xE93FF9F5, // 1e64 + 0x5A827748, 0xF9301D32, // 1e128 + 0x75154FDD, 0x7F73BF3C // 1e256 + })); + return forge( + ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index), + ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index + 1)); + } + + static T negativeBinaryPowerOfTen(int index) { + ARDUINOJSON_DEFINE_STATIC_ARRAY( // + uint32_t, factors, + ARDUINOJSON_EXPAND18({ + 0x3FB99999, 0x9999999A, // 1e-1 + 0x3F847AE1, 0x47AE147B, // 1e-2 + 0x3F1A36E2, 0xEB1C432D, // 1e-4 + 0x3E45798E, 0xE2308C3A, // 1e-8 + 0x3C9CD2B2, 0x97D889BC, // 1e-16 + 0x3949F623, 0xD5A8A733, // 1e-32 + 0x32A50FFD, 0x44F4A73D, // 1e-64 + 0x255BBA08, 0xCF8C979D, // 1e-128 + 0x0AC80628, 0x64AC6F43 // 1e-256 + })); + return forge( + ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index), + ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index + 1)); + } + + static T negativeBinaryPowerOfTenPlusOne(int index) { + ARDUINOJSON_DEFINE_STATIC_ARRAY( // + uint32_t, factors, + ARDUINOJSON_EXPAND18({ + 0x3FF00000, 0x00000000, // 1e0 + 0x3FB99999, 0x9999999A, // 1e-1 + 0x3F50624D, 0xD2F1A9FC, // 1e-3 + 0x3E7AD7F2, 0x9ABCAF48, // 1e-7 + 0x3CD203AF, 0x9EE75616, // 1e-15 + 0x398039D6, 0x65896880, // 1e-31 + 0x32DA53FC, 0x9631D10D, // 1e-63 + 0x25915445, 0x81B7DEC2, // 1e-127 + 0x0AFE07B2, 0x7DD78B14 // 1e-255 + })); + return forge( + ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index), + ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index + 1)); + } + + static T nan() { + return forge(0x7ff80000, 0x00000000); + } + + static T inf() { + return forge(0x7ff00000, 0x00000000); + } + + static T highest() { + return forge(0x7FEFFFFF, 0xFFFFFFFF); + } + + static T lowest() { + return forge(0xFFEFFFFF, 0xFFFFFFFF); + } + + // constructs a double floating point values from its binary representation + // we use this function to workaround platforms with single precision literals + // (for example, when -fsingle-precision-constant is passed to GCC) + static T forge(uint32_t msb, uint32_t lsb) { + return alias_cast<T>((uint64_t(msb) << 32) | lsb); + } +}; + +template <typename T> +struct FloatTraits<T, 4 /*32bits*/> { + typedef uint32_t mantissa_type; + static const short mantissa_bits = 23; + static const mantissa_type mantissa_max = + (mantissa_type(1) << mantissa_bits) - 1; + + typedef int8_t exponent_type; + static const exponent_type exponent_max = 38; + + template <typename TExponent> + static T make_float(T m, TExponent e) { + if (e > 0) { + for (uint8_t index = 0; e != 0; index++) { + if (e & 1) + m *= positiveBinaryPowerOfTen(index); + e >>= 1; + } + } else { + e = -e; + for (uint8_t index = 0; e != 0; index++) { + if (e & 1) + m *= negativeBinaryPowerOfTen(index); + e >>= 1; + } + } + return m; + } + + static T positiveBinaryPowerOfTen(int index) { + ARDUINOJSON_DEFINE_STATIC_ARRAY( + T, factors, + ARDUINOJSON_EXPAND6({1e1f, 1e2f, 1e4f, 1e8f, 1e16f, 1e32f})); + return ARDUINOJSON_READ_STATIC_ARRAY(T, factors, index); + } + + static T negativeBinaryPowerOfTen(int index) { + ARDUINOJSON_DEFINE_STATIC_ARRAY( + T, factors, + ARDUINOJSON_EXPAND6({1e-1f, 1e-2f, 1e-4f, 1e-8f, 1e-16f, 1e-32f})); + return ARDUINOJSON_READ_STATIC_ARRAY(T, factors, index); + } + + static T negativeBinaryPowerOfTenPlusOne(int index) { + ARDUINOJSON_DEFINE_STATIC_ARRAY( + T, factors, + ARDUINOJSON_EXPAND6({1e0f, 1e-1f, 1e-3f, 1e-7f, 1e-15f, 1e-31f})); + return ARDUINOJSON_READ_STATIC_ARRAY(T, factors, index); + } + + static T forge(uint32_t bits) { + return alias_cast<T>(bits); + } + + static T nan() { + return forge(0x7fc00000); + } + + static T inf() { + return forge(0x7f800000); + } + + static T highest() { + return forge(0x7f7fffff); + } + + static T lowest() { + return forge(0xFf7fffff); + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Numbers/Integer.hpp b/include/lib/ArduinoJson/Numbers/Integer.hpp new file mode 100644 index 0000000..fb656a7 --- /dev/null +++ b/include/lib/ArduinoJson/Numbers/Integer.hpp @@ -0,0 +1,32 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Namespace.hpp> + +#include <stdint.h> // int64_t + +namespace ARDUINOJSON_NAMESPACE { + +#if ARDUINOJSON_USE_LONG_LONG +typedef int64_t Integer; +typedef uint64_t UInt; +#else +typedef long Integer; +typedef unsigned long UInt; +#endif + +} // namespace ARDUINOJSON_NAMESPACE + +#if ARDUINOJSON_HAS_LONG_LONG && !ARDUINOJSON_USE_LONG_LONG +#define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) \ + static_assert(sizeof(T) <= sizeof(ARDUINOJSON_NAMESPACE::Integer), \ + "To use 64-bit integers with ArduinoJson, you must set " \ + "ARDUINOJSON_USE_LONG_LONG to 1. See " \ + "https://arduinojson.org/v6/api/config/use_long_long/"); +#else +#define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) +#endif diff --git a/include/lib/ArduinoJson/Numbers/arithmeticCompare.hpp b/include/lib/ArduinoJson/Numbers/arithmeticCompare.hpp new file mode 100644 index 0000000..bfd41d5 --- /dev/null +++ b/include/lib/ArduinoJson/Numbers/arithmeticCompare.hpp @@ -0,0 +1,121 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Numbers/Integer.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +enum CompareResult { + COMPARE_RESULT_DIFFER = 0, + COMPARE_RESULT_EQUAL = 1, + COMPARE_RESULT_GREATER = 2, + COMPARE_RESULT_LESS = 4, + + COMPARE_RESULT_GREATER_OR_EQUAL = 3, + COMPARE_RESULT_LESS_OR_EQUAL = 5 +}; + +template <typename T> +CompareResult arithmeticCompare(const T &lhs, const T &rhs) { + if (lhs < rhs) + return COMPARE_RESULT_LESS; + else if (lhs > rhs) + return COMPARE_RESULT_GREATER; + else + return COMPARE_RESULT_EQUAL; +} + +template <typename T1, typename T2> +CompareResult arithmeticCompare( + const T1 &lhs, const T2 &rhs, + typename enable_if<is_integral<T1>::value && is_integral<T2>::value && + sizeof(T1) < sizeof(T2), + int // Using int instead of void to avoid C2572 on + // Visual Studio 2012, 2013, and 2015 + >::type * = 0) { + return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs); +} + +template <typename T1, typename T2> +CompareResult arithmeticCompare( + const T1 &lhs, const T2 &rhs, + typename enable_if<is_integral<T1>::value && is_integral<T2>::value && + sizeof(T2) < sizeof(T1)>::type * = 0) { + return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs)); +} + +template <typename T1, typename T2> +CompareResult arithmeticCompare( + const T1 &lhs, const T2 &rhs, + typename enable_if<is_integral<T1>::value && is_integral<T2>::value && + is_signed<T1>::value == is_signed<T2>::value && + sizeof(T2) == sizeof(T1)>::type * = 0) { + return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs)); +} + +template <typename T1, typename T2> +CompareResult arithmeticCompare( + const T1 &lhs, const T2 &rhs, + typename enable_if<is_integral<T1>::value && is_integral<T2>::value && + is_unsigned<T1>::value && is_signed<T2>::value && + sizeof(T2) == sizeof(T1)>::type * = 0) { + if (rhs < 0) + return COMPARE_RESULT_GREATER; + return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs)); +} + +template <typename T1, typename T2> +CompareResult arithmeticCompare( + const T1 &lhs, const T2 &rhs, + typename enable_if<is_integral<T1>::value && is_integral<T2>::value && + is_signed<T1>::value && is_unsigned<T2>::value && + sizeof(T2) == sizeof(T1)>::type * = 0) { + if (lhs < 0) + return COMPARE_RESULT_LESS; + return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs); +} + +template <typename T1, typename T2> +CompareResult arithmeticCompare( + const T1 &lhs, const T2 &rhs, + typename enable_if<is_floating_point<T1>::value || + is_floating_point<T2>::value>::type * = 0) { + return arithmeticCompare<double>(static_cast<double>(lhs), + static_cast<double>(rhs)); +} + +template <typename T2> +CompareResult arithmeticCompareNegateLeft( + UInt, const T2 &, typename enable_if<is_unsigned<T2>::value>::type * = 0) { + return COMPARE_RESULT_LESS; +} + +template <typename T2> +CompareResult arithmeticCompareNegateLeft( + UInt lhs, const T2 &rhs, + typename enable_if<is_signed<T2>::value>::type * = 0) { + if (rhs > 0) + return COMPARE_RESULT_LESS; + return arithmeticCompare(-rhs, static_cast<T2>(lhs)); +} + +template <typename T1> +CompareResult arithmeticCompareNegateRight( + const T1 &, UInt, typename enable_if<is_unsigned<T1>::value>::type * = 0) { + return COMPARE_RESULT_GREATER; +} + +template <typename T1> +CompareResult arithmeticCompareNegateRight( + const T1 &lhs, UInt rhs, + typename enable_if<is_signed<T1>::value>::type * = 0) { + if (lhs > 0) + return COMPARE_RESULT_GREATER; + return arithmeticCompare(static_cast<T1>(rhs), -lhs); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Numbers/convertNumber.hpp b/include/lib/ArduinoJson/Numbers/convertNumber.hpp new file mode 100644 index 0000000..02bbefa --- /dev/null +++ b/include/lib/ArduinoJson/Numbers/convertNumber.hpp @@ -0,0 +1,107 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wconversion" +#elif defined(__GNUC__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) +#pragma GCC diagnostic push +#endif +#pragma GCC diagnostic ignored "-Wconversion" +#endif + +#include <ArduinoJson/Numbers/Float.hpp> +#include <ArduinoJson/Polyfills/limits.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// uint32 -> int32 +// uint64 -> int32 +template <typename TOut, typename TIn> +typename enable_if<is_integral<TIn>::value && is_unsigned<TIn>::value && + is_integral<TOut>::value && sizeof(TOut) <= sizeof(TIn), + bool>::type +canConvertNumber(TIn value) { + return value <= TIn(numeric_limits<TOut>::highest()); +} + +// uint32 -> int64 +template <typename TOut, typename TIn> +typename enable_if<is_integral<TIn>::value && is_unsigned<TIn>::value && + is_integral<TOut>::value && sizeof(TIn) < sizeof(TOut), + bool>::type +canConvertNumber(TIn) { + return true; +} + +// uint32 -> float +// int32 -> float +template <typename TOut, typename TIn> +typename enable_if<is_integral<TIn>::value && is_floating_point<TOut>::value, + bool>::type +canConvertNumber(TIn) { + return true; +} + +// int64 -> int32 +template <typename TOut, typename TIn> +typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value && + is_integral<TOut>::value && is_signed<TOut>::value && + sizeof(TOut) < sizeof(TIn), + bool>::type +canConvertNumber(TIn value) { + return value >= TIn(numeric_limits<TOut>::lowest()) && + value <= TIn(numeric_limits<TOut>::highest()); +} + +// int32 -> int32 +// int32 -> int64 +template <typename TOut, typename TIn> +typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value && + is_integral<TOut>::value && is_signed<TOut>::value && + sizeof(TIn) <= sizeof(TOut), + bool>::type +canConvertNumber(TIn) { + return true; +} + +// int32 -> uint32 +template <typename TOut, typename TIn> +typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value && + is_integral<TOut>::value && is_unsigned<TOut>::value, + bool>::type +canConvertNumber(TIn value) { + if (value < 0) + return false; + return value <= TIn(numeric_limits<TOut>::highest()); +} + +// float -> int32 +// float -> int64 +template <typename TOut, typename TIn> +typename enable_if<is_floating_point<TIn>::value && + !is_floating_point<TOut>::value, + bool>::type +canConvertNumber(TIn value) { + return value >= numeric_limits<TOut>::lowest() && + value <= numeric_limits<TOut>::highest(); +} + +template <typename TOut, typename TIn> +TOut convertNumber(TIn value) { + return canConvertNumber<TOut>(value) ? TOut(value) : 0; +} +} // namespace ARDUINOJSON_NAMESPACE + +#if defined(__clang__) +#pragma clang diagnostic pop +#elif defined(__GNUC__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) +#pragma GCC diagnostic pop +#endif +#endif diff --git a/include/lib/ArduinoJson/Numbers/parseNumber.hpp b/include/lib/ArduinoJson/Numbers/parseNumber.hpp new file mode 100644 index 0000000..cf050c7 --- /dev/null +++ b/include/lib/ArduinoJson/Numbers/parseNumber.hpp @@ -0,0 +1,153 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Numbers/FloatTraits.hpp> +#include <ArduinoJson/Numbers/convertNumber.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> +#include <ArduinoJson/Polyfills/ctype.hpp> +#include <ArduinoJson/Polyfills/math.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Variant/Converter.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename A, typename B> +struct choose_largest : conditional<(sizeof(A) > sizeof(B)), A, B> {}; + +inline bool parseNumber(const char* s, VariantData& result) { + typedef FloatTraits<Float> traits; + typedef choose_largest<traits::mantissa_type, UInt>::type mantissa_t; + typedef traits::exponent_type exponent_t; + + ARDUINOJSON_ASSERT(s != 0); + + bool is_negative = false; + switch (*s) { + case '-': + is_negative = true; + s++; + break; + case '+': + s++; + break; + } + +#if ARDUINOJSON_ENABLE_NAN + if (*s == 'n' || *s == 'N') { + result.setFloat(traits::nan()); + return true; + } +#endif + +#if ARDUINOJSON_ENABLE_INFINITY + if (*s == 'i' || *s == 'I') { + result.setFloat(is_negative ? -traits::inf() : traits::inf()); + return true; + } +#endif + + if (!isdigit(*s) && *s != '.') + return false; + + mantissa_t mantissa = 0; + exponent_t exponent_offset = 0; + const mantissa_t maxUint = UInt(-1); + + while (isdigit(*s)) { + uint8_t digit = uint8_t(*s - '0'); + if (mantissa > maxUint / 10) + break; + mantissa *= 10; + if (mantissa > maxUint - digit) + break; + mantissa += digit; + s++; + } + + if (*s == '\0') { + if (is_negative) { + const mantissa_t sintMantissaMax = mantissa_t(1) + << (sizeof(Integer) * 8 - 1); + if (mantissa <= sintMantissaMax) { + result.setInteger(Integer(~mantissa + 1)); + return true; + } + } else { + result.setInteger(UInt(mantissa)); + return true; + } + } + + // avoid mantissa overflow + while (mantissa > traits::mantissa_max) { + mantissa /= 10; + exponent_offset++; + } + + // remaing digits can't fit in the mantissa + while (isdigit(*s)) { + exponent_offset++; + s++; + } + + if (*s == '.') { + s++; + while (isdigit(*s)) { + if (mantissa < traits::mantissa_max / 10) { + mantissa = mantissa * 10 + uint8_t(*s - '0'); + exponent_offset--; + } + s++; + } + } + + int exponent = 0; + if (*s == 'e' || *s == 'E') { + s++; + bool negative_exponent = false; + if (*s == '-') { + negative_exponent = true; + s++; + } else if (*s == '+') { + s++; + } + + while (isdigit(*s)) { + exponent = exponent * 10 + (*s - '0'); + if (exponent + exponent_offset > traits::exponent_max) { + if (negative_exponent) + result.setFloat(is_negative ? -0.0f : 0.0f); + else + result.setFloat(is_negative ? -traits::inf() : traits::inf()); + return true; + } + s++; + } + if (negative_exponent) + exponent = -exponent; + } + exponent += exponent_offset; + + // we should be at the end of the string, otherwise it's an error + if (*s != '\0') + return false; + + Float final_result = + traits::make_float(static_cast<Float>(mantissa), exponent); + + result.setFloat(is_negative ? -final_result : final_result); + return true; +} + +template <typename T> +inline T parseNumber(const char* s) { + VariantData value; + value.init(); // VariantData is a POD, so it has no constructor + parseNumber(s, value); + return Converter<T>::fromJson(VariantConstRef(&value)); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Object/MemberProxy.hpp b/include/lib/ArduinoJson/Object/MemberProxy.hpp new file mode 100644 index 0000000..0bee84b --- /dev/null +++ b/include/lib/ArduinoJson/Object/MemberProxy.hpp @@ -0,0 +1,202 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Variant/VariantOperators.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> +#include <ArduinoJson/Variant/VariantShortcuts.hpp> +#include <ArduinoJson/Variant/VariantTo.hpp> + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4522) +#endif + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TObject, typename TStringRef> +class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >, + public VariantShortcuts<MemberProxy<TObject, TStringRef> >, + public Visitable, + public VariantTag { + typedef MemberProxy<TObject, TStringRef> this_type; + + public: + typedef VariantRef variant_type; + + FORCE_INLINE MemberProxy(TObject variant, TStringRef key) + : _object(variant), _key(key) {} + + FORCE_INLINE MemberProxy(const MemberProxy &src) + : _object(src._object), _key(src._key) {} + + FORCE_INLINE operator VariantConstRef() const { + return getUpstreamMember(); + } + + FORCE_INLINE this_type &operator=(const this_type &src) { + getOrAddUpstreamMember().set(src); + return *this; + } + + template <typename TValue> + FORCE_INLINE typename enable_if<!is_array<TValue>::value, this_type &>::type + operator=(const TValue &src) { + getOrAddUpstreamMember().set(src); + return *this; + } + + // operator=(char*) + // operator=(const char*) + // operator=(const __FlashStringHelper*) + template <typename TChar> + FORCE_INLINE this_type &operator=(TChar *src) { + getOrAddUpstreamMember().set(src); + return *this; + } + + FORCE_INLINE void clear() const { + getUpstreamMember().clear(); + } + + FORCE_INLINE bool isNull() const { + return getUpstreamMember().isNull(); + } + + template <typename T> + FORCE_INLINE typename enable_if<!is_same<T, char *>::value, T>::type as() + const { + return getUpstreamMember().template as<T>(); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type + ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()") + as() const { + return as<const char *>(); + } + + template <typename T> + FORCE_INLINE operator T() const { + return getUpstreamMember(); + } + + template <typename TValue> + FORCE_INLINE bool is() const { + return getUpstreamMember().template is<TValue>(); + } + + FORCE_INLINE size_t size() const { + return getUpstreamMember().size(); + } + + FORCE_INLINE void remove(size_t index) const { + getUpstreamMember().remove(index); + } + // remove(char*) const + // remove(const char*) const + // remove(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove( + TChar *key) const { + getUpstreamMember().remove(key); + } + // remove(const std::string&) const + // remove(const String&) const + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove( + const TString &key) const { + getUpstreamMember().remove(key); + } + + template <typename TValue> + FORCE_INLINE typename VariantTo<TValue>::type to() { + return getOrAddUpstreamMember().template to<TValue>(); + } + + template <typename TValue> + FORCE_INLINE bool set(const TValue &value) { + return getOrAddUpstreamMember().set(value); + } + + // set(char*) const + // set(const char*) const + // set(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE bool set(TChar *value) { + return getOrAddUpstreamMember().set(value); + } + + template <typename TVisitor> + typename TVisitor::result_type accept(TVisitor &visitor) const { + return getUpstreamMember().accept(visitor); + } + + FORCE_INLINE VariantRef addElement() const { + return getOrAddUpstreamMember().addElement(); + } + + FORCE_INLINE VariantRef getElement(size_t index) const { + return getUpstreamMember().getElement(index); + } + + FORCE_INLINE VariantRef getOrAddElement(size_t index) const { + return getOrAddUpstreamMember().getOrAddElement(index); + } + + // getMember(char*) const + // getMember(const char*) const + // getMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantRef getMember(TChar *key) const { + return getUpstreamMember().getMember(key); + } + + // getMember(const std::string&) const + // getMember(const String&) const + template <typename TString> + FORCE_INLINE VariantRef getMember(const TString &key) const { + return getUpstreamMember().getMember(key); + } + + // getOrAddMember(char*) const + // getOrAddMember(const char*) const + // getOrAddMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantRef getOrAddMember(TChar *key) const { + return getOrAddUpstreamMember().getOrAddMember(key); + } + + // getOrAddMember(const std::string&) const + // getOrAddMember(const String&) const + template <typename TString> + FORCE_INLINE VariantRef getOrAddMember(const TString &key) const { + return getOrAddUpstreamMember().getOrAddMember(key); + } + + private: + FORCE_INLINE VariantRef getUpstreamMember() const { + return _object.getMember(_key); + } + + FORCE_INLINE VariantRef getOrAddUpstreamMember() const { + return _object.getOrAddMember(_key); + } + + friend bool convertToJson(const this_type &src, VariantRef dst) { + return dst.set(src.getUpstreamMember()); + } + + TObject _object; + TStringRef _key; +}; + +} // namespace ARDUINOJSON_NAMESPACE + +#ifdef _MSC_VER +#pragma warning(pop) +#endif diff --git a/include/lib/ArduinoJson/Object/ObjectFunctions.hpp b/include/lib/ArduinoJson/Object/ObjectFunctions.hpp new file mode 100644 index 0000000..1b46e84 --- /dev/null +++ b/include/lib/ArduinoJson/Object/ObjectFunctions.hpp @@ -0,0 +1,51 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Collection/CollectionData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TVisitor> +typename TVisitor::result_type objectAccept(const CollectionData *obj, + TVisitor &visitor) { + if (obj) + return visitor.visitObject(*obj); + else + return visitor.visitNull(); +} + +inline bool objectEquals(const CollectionData *lhs, const CollectionData *rhs) { + if (lhs == rhs) + return true; + if (!lhs || !rhs) + return false; + return lhs->equalsObject(*rhs); +} + +template <typename TAdaptedString> +inline VariantData *objectGetMember(const CollectionData *obj, + TAdaptedString key) { + if (!obj) + return 0; + return obj->getMember(key); +} + +template <typename TAdaptedString> +void objectRemove(CollectionData *obj, TAdaptedString key) { + if (!obj) + return; + obj->removeMember(key); +} + +template <typename TAdaptedString> +inline VariantData *objectGetOrAddMember(CollectionData *obj, + TAdaptedString key, MemoryPool *pool) { + if (!obj) + return 0; + + return obj->getOrAddMember(key, pool); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Object/ObjectImpl.hpp b/include/lib/ArduinoJson/Object/ObjectImpl.hpp new file mode 100644 index 0000000..d66b61c --- /dev/null +++ b/include/lib/ArduinoJson/Object/ObjectImpl.hpp @@ -0,0 +1,69 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Array/ArrayRef.hpp> +#include <ArduinoJson/Object/ObjectRef.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TObject> +template <typename TString> +inline ArrayRef ObjectShortcuts<TObject>::createNestedArray( + const TString& key) const { + return impl()->getOrAddMember(key).template to<ArrayRef>(); +} + +template <typename TObject> +template <typename TChar> +inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(TChar* key) const { + return impl()->getOrAddMember(key).template to<ArrayRef>(); +} + +template <typename TObject> +template <typename TString> +inline ObjectRef ObjectShortcuts<TObject>::createNestedObject( + const TString& key) const { + return impl()->getOrAddMember(key).template to<ObjectRef>(); +} + +template <typename TObject> +template <typename TChar> +inline ObjectRef ObjectShortcuts<TObject>::createNestedObject( + TChar* key) const { + return impl()->getOrAddMember(key).template to<ObjectRef>(); +} + +template <typename TObject> +template <typename TString> +inline typename enable_if<IsString<TString>::value, bool>::type +ObjectShortcuts<TObject>::containsKey(const TString& key) const { + return !impl()->getMember(key).isUndefined(); +} + +template <typename TObject> +template <typename TChar> +inline typename enable_if<IsString<TChar*>::value, bool>::type +ObjectShortcuts<TObject>::containsKey(TChar* key) const { + return !impl()->getMember(key).isUndefined(); +} + +template <typename TObject> +template <typename TString> +inline typename enable_if<IsString<TString*>::value, + MemberProxy<TObject, TString*> >::type +ObjectShortcuts<TObject>::operator[](TString* key) const { + return MemberProxy<TObject, TString*>(*impl(), key); +} + +template <typename TObject> +template <typename TString> +inline typename enable_if<IsString<TString>::value, + MemberProxy<TObject, TString> >::type +ObjectShortcuts<TObject>::operator[](const TString& key) const { + return MemberProxy<TObject, TString>(*impl(), key); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Object/ObjectIterator.hpp b/include/lib/ArduinoJson/Object/ObjectIterator.hpp new file mode 100644 index 0000000..d729459 --- /dev/null +++ b/include/lib/ArduinoJson/Object/ObjectIterator.hpp @@ -0,0 +1,123 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Object/Pair.hpp> +#include <ArduinoJson/Variant/SlotFunctions.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class PairPtr { + public: + PairPtr(MemoryPool *pool, VariantSlot *slot) : _pair(pool, 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 *pool, VariantSlot *slot) + : _pool(pool), _slot(slot) {} + + Pair operator*() const { + return Pair(_pool, _slot); + } + PairPtr operator->() { + return PairPtr(_pool, _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->next(); + return *this; + } + + ObjectIterator &operator+=(size_t distance) { + _slot = _slot->next(distance); + return *this; + } + + VariantSlot *internal() { + return _slot; + } + + private: + MemoryPool *_pool; + 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->next(); + return *this; + } + + ObjectConstIterator &operator+=(size_t distance) { + _slot = _slot->next(distance); + return *this; + } + + const VariantSlot *internal() { + return _slot; + } + + private: + const VariantSlot *_slot; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Object/ObjectRef.hpp b/include/lib/ArduinoJson/Object/ObjectRef.hpp new file mode 100644 index 0000000..c945fb6 --- /dev/null +++ b/include/lib/ArduinoJson/Object/ObjectRef.hpp @@ -0,0 +1,277 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Object/ObjectFunctions.hpp> +#include <ArduinoJson/Object/ObjectIterator.hpp> + +// Returns the size (in bytes) of an object with n elements. +// Can be very handy to determine the size of a StaticMemoryPool. +#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \ + ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot)) + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TData> +class ObjectRefBase { + public: + operator VariantConstRef() const { + const void* data = _data; // prevent warning cast-align + return VariantConstRef(reinterpret_cast<const VariantData*>(data)); + } + + template <typename TVisitor> + typename TVisitor::result_type accept(TVisitor& visitor) const { + return objectAccept(_data, visitor); + } + + FORCE_INLINE bool isNull() const { + return _data == 0; + } + + FORCE_INLINE operator bool() const { + return _data != 0; + } + + FORCE_INLINE size_t memoryUsage() const { + return _data ? _data->memoryUsage() : 0; + } + + FORCE_INLINE size_t nesting() const { + return _data ? _data->nesting() : 0; + } + + FORCE_INLINE size_t size() const { + return _data ? _data->size() : 0; + } + + protected: + ObjectRefBase(TData* data) : _data(data) {} + TData* _data; +}; + +class ObjectConstRef : public ObjectRefBase<const CollectionData>, + public Visitable { + friend class ObjectRef; + typedef ObjectRefBase<const CollectionData> base_type; + + public: + typedef ObjectConstIterator iterator; + + ObjectConstRef() : base_type(0) {} + ObjectConstRef(const CollectionData* data) : base_type(data) {} + + FORCE_INLINE iterator begin() const { + if (!_data) + return iterator(); + return iterator(_data->head()); + } + + FORCE_INLINE iterator end() const { + return iterator(); + } + + // containsKey(const std::string&) const + // containsKey(const String&) const + template <typename TString> + FORCE_INLINE bool containsKey(const TString& key) const { + return !getMember(key).isUndefined(); + } + + // containsKey(char*) const + // containsKey(const char*) const + // containsKey(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE bool containsKey(TChar* key) const { + return !getMember(key).isUndefined(); + } + + // getMember(const std::string&) const + // getMember(const String&) const + template <typename TString> + FORCE_INLINE VariantConstRef getMember(const TString& key) const { + return get_impl(adaptString(key)); + } + + // getMember(char*) const + // getMember(const char*) const + // getMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantConstRef getMember(TChar* key) const { + return get_impl(adaptString(key)); + } + + // operator[](const std::string&) const + // operator[](const String&) const + template <typename TString> + FORCE_INLINE + typename enable_if<IsString<TString>::value, VariantConstRef>::type + operator[](const TString& key) const { + return get_impl(adaptString(key)); + } + + // operator[](char*) const + // operator[](const char*) const + // operator[](const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE + typename enable_if<IsString<TChar*>::value, VariantConstRef>::type + operator[](TChar* key) const { + return get_impl(adaptString(key)); + } + + FORCE_INLINE bool operator==(ObjectConstRef rhs) const { + return objectEquals(_data, rhs._data); + } + + private: + template <typename TAdaptedString> + FORCE_INLINE VariantConstRef get_impl(TAdaptedString key) const { + return VariantConstRef(objectGetMember(_data, key)); + } +}; + +class ObjectRef : public ObjectRefBase<CollectionData>, + public ObjectShortcuts<ObjectRef>, + public Visitable { + typedef ObjectRefBase<CollectionData> base_type; + + public: + typedef ObjectIterator iterator; + + FORCE_INLINE ObjectRef() : base_type(0), _pool(0) {} + FORCE_INLINE ObjectRef(MemoryPool* buf, CollectionData* data) + : base_type(data), _pool(buf) {} + + operator VariantRef() const { + void* data = _data; // prevent warning cast-align + return VariantRef(_pool, reinterpret_cast<VariantData*>(data)); + } + + operator ObjectConstRef() const { + return ObjectConstRef(_data); + } + + FORCE_INLINE iterator begin() const { + if (!_data) + return iterator(); + return iterator(_pool, _data->head()); + } + + FORCE_INLINE iterator end() const { + return iterator(); + } + + void clear() const { + if (!_data) + return; + _data->clear(); + } + + FORCE_INLINE bool set(ObjectConstRef src) { + if (!_data || !src._data) + return false; + return _data->copyFrom(*src._data, _pool); + } + + // getMember(const std::string&) const + // getMember(const String&) const + template <typename TString> + FORCE_INLINE VariantRef getMember(const TString& key) const { + return VariantRef(_pool, objectGetMember(_data, adaptString(key))); + } + + // getMember(char*) const + // getMember(const char*) const + // getMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantRef getMember(TChar* key) const { + return VariantRef(_pool, objectGetMember(_data, adaptString(key))); + } + + // getOrAddMember(const std::string&) const + // getOrAddMember(const String&) const + template <typename TString> + FORCE_INLINE VariantRef getOrAddMember(const TString& key) const { + return VariantRef(_pool, + objectGetOrAddMember(_data, adaptString(key), _pool)); + } + + // getOrAddMember(char*) const + // getOrAddMember(const char*) const + // getOrAddMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantRef getOrAddMember(TChar* key) const { + return VariantRef(_pool, + objectGetOrAddMember(_data, adaptString(key), _pool)); + } + + FORCE_INLINE bool operator==(ObjectRef rhs) const { + return objectEquals(_data, rhs._data); + } + + FORCE_INLINE void remove(iterator it) const { + if (!_data) + return; + _data->removeSlot(it.internal()); + } + + // remove(const std::string&) const + // remove(const String&) const + template <typename TString> + FORCE_INLINE void remove(const TString& key) const { + objectRemove(_data, adaptString(key)); + } + + // remove(char*) const + // remove(const char*) const + // remove(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE void remove(TChar* key) const { + objectRemove(_data, adaptString(key)); + } + + private: + MemoryPool* _pool; +}; + +template <> +struct Converter<ObjectConstRef> { + static bool toJson(VariantConstRef src, VariantRef dst) { + return variantCopyFrom(getData(dst), getData(src), getPool(dst)); + } + + static ObjectConstRef fromJson(VariantConstRef src) { + return ObjectConstRef(variantAsObject(getData(src))); + } + + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data && data->isObject(); + } +}; + +template <> +struct Converter<ObjectRef> { + static bool toJson(VariantConstRef src, VariantRef dst) { + return variantCopyFrom(getData(dst), getData(src), getPool(dst)); + } + + static ObjectRef fromJson(VariantRef src) { + VariantData* data = getData(src); + MemoryPool* pool = getPool(src); + return ObjectRef(pool, data != 0 ? data->asObject() : 0); + } + + static bool checkJson(VariantConstRef) { + return false; + } + + static bool checkJson(VariantRef src) { + VariantData* data = getData(src); + return data && data->isObject(); + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Object/ObjectShortcuts.hpp b/include/lib/ArduinoJson/Object/ObjectShortcuts.hpp new file mode 100644 index 0000000..0f3409f --- /dev/null +++ b/include/lib/ArduinoJson/Object/ObjectShortcuts.hpp @@ -0,0 +1,73 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/attributes.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Strings/StringAdapters.hpp> + +namespace ARDUINOJSON_NAMESPACE { +template <typename TParent, typename TStringRef> +class MemberProxy; + +template <typename TObject> +class ObjectShortcuts { + public: + // containsKey(const std::string&) const + // containsKey(const String&) const + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value, bool>::type + containsKey(const TString &key) const; + + // containsKey(char*) const + // containsKey(const char*) const + // containsKey(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE typename enable_if<IsString<TChar *>::value, bool>::type + containsKey(TChar *key) const; + + // operator[](const std::string&) const + // operator[](const String&) const + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value, + MemberProxy<TObject, TString> >::type + operator[](const TString &key) const; + + // operator[](char*) const + // operator[](const char*) const + // operator[](const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE typename enable_if<IsString<TChar *>::value, + MemberProxy<TObject, TChar *> >::type + operator[](TChar *key) const; + + // createNestedArray(const std::string&) const + // createNestedArray(const String&) const + template <typename TString> + FORCE_INLINE ArrayRef createNestedArray(const TString &key) const; + + // createNestedArray(char*) const + // createNestedArray(const char*) const + // createNestedArray(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE ArrayRef createNestedArray(TChar *key) const; + + // createNestedObject(const std::string&) const + // createNestedObject(const String&) const + template <typename TString> + ObjectRef createNestedObject(const TString &key) const; + + // createNestedObject(char*) const + // createNestedObject(const char*) const + // createNestedObject(const __FlashStringHelper*) const + template <typename TChar> + ObjectRef createNestedObject(TChar *key) const; + + private: + const TObject *impl() const { + return static_cast<const TObject *>(this); + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Object/Pair.hpp b/include/lib/ArduinoJson/Object/Pair.hpp new file mode 100644 index 0000000..44fce75 --- /dev/null +++ b/include/lib/ArduinoJson/Object/Pair.hpp @@ -0,0 +1,55 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Strings/String.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> + +namespace ARDUINOJSON_NAMESPACE { +// A key value pair for CollectionData. +class Pair { + public: + Pair(MemoryPool* pool, VariantSlot* slot) { + if (slot) { + _key = String(slot->key(), !slot->ownsKey()); + _value = VariantRef(pool, slot->data()); + } + } + + String key() const { + return _key; + } + + VariantRef value() const { + return _value; + } + + private: + String _key; + VariantRef _value; +}; + +class PairConst { + public: + PairConst(const VariantSlot* slot) { + if (slot) { + _key = String(slot->key(), !slot->ownsKey()); + _value = VariantConstRef(slot->data()); + } + } + + String key() const { + return _key; + } + + VariantConstRef value() const { + return _value; + } + + private: + String _key; + VariantConstRef _value; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/alias_cast.hpp b/include/lib/ArduinoJson/Polyfills/alias_cast.hpp new file mode 100644 index 0000000..8f8e277 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/alias_cast.hpp @@ -0,0 +1,29 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <stdint.h> +#include <stdlib.h> // for size_t + +#include <ArduinoJson/Configuration.hpp> +#include "math.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T, typename F> +struct alias_cast_t { + union { + F raw; + T data; + }; +}; + +template <typename T, typename F> +T alias_cast(F raw_data) { + alias_cast_t<T, F> ac; + ac.raw = raw_data; + return ac.data; +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/assert.hpp b/include/lib/ArduinoJson/Polyfills/assert.hpp new file mode 100644 index 0000000..1030ec6 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/assert.hpp @@ -0,0 +1,14 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> + +#if ARDUINOJSON_DEBUG +#include <assert.h> +#define ARDUINOJSON_ASSERT(X) assert(X) +#else +#define ARDUINOJSON_ASSERT(X) ((void)0) +#endif diff --git a/include/lib/ArduinoJson/Polyfills/attributes.hpp b/include/lib/ArduinoJson/Polyfills/attributes.hpp new file mode 100644 index 0000000..f04c9ac --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/attributes.hpp @@ -0,0 +1,54 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#ifdef _MSC_VER // Visual Studio + +#define FORCE_INLINE // __forceinline causes C4714 when returning std::string +#define NO_INLINE __declspec(noinline) + +#ifndef ARDUINOJSON_DEPRECATED +#define ARDUINOJSON_DEPRECATED(msg) __declspec(deprecated(msg)) +#endif + +#elif defined(__GNUC__) // GCC or Clang + +#define FORCE_INLINE __attribute__((always_inline)) +#define NO_INLINE __attribute__((noinline)) + +#ifndef ARDUINOJSON_DEPRECATED +#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) +#define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated(msg))) +#else +#define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated)) +#endif +#endif + +#else // Other compilers + +#define FORCE_INLINE +#define NO_INLINE + +#ifndef ARDUINOJSON_DEPRECATED +#define ARDUINOJSON_DEPRECATED(msg) +#endif + +#endif + +#if __cplusplus >= 201103L +#define NOEXCEPT noexcept +#else +#define NOEXCEPT throw() +#endif + +#if defined(__has_attribute) +#if __has_attribute(no_sanitize) +#define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check))) +#else +#define ARDUINOJSON_NO_SANITIZE(check) +#endif +#else +#define ARDUINOJSON_NO_SANITIZE(check) +#endif diff --git a/include/lib/ArduinoJson/Polyfills/ctype.hpp b/include/lib/ArduinoJson/Polyfills/ctype.hpp new file mode 100644 index 0000000..bd7a8cc --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/ctype.hpp @@ -0,0 +1,20 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +#ifndef isdigit +inline bool isdigit(char c) { + return '0' <= c && c <= '9'; +} +#endif + +inline bool issign(char c) { + return '-' == c || c == '+'; +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/integer.hpp b/include/lib/ArduinoJson/Polyfills/integer.hpp new file mode 100644 index 0000000..066c7b8 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/integer.hpp @@ -0,0 +1,30 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <stdint.h> // int8_t, int16_t + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <int Bits> +struct int_t; + +template <> +struct int_t<8> { + typedef int8_t type; +}; + +template <> +struct int_t<16> { + typedef int16_t type; +}; + +template <> +struct int_t<32> { + typedef int32_t type; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/limits.hpp b/include/lib/ArduinoJson/Polyfills/limits.hpp new file mode 100644 index 0000000..8004828 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/limits.hpp @@ -0,0 +1,45 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "type_traits.hpp" + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4310) +#endif + +namespace ARDUINOJSON_NAMESPACE { + +// Differs from standard because we can't use the symbols "min" and "max" +template <typename T, typename Enable = void> +struct numeric_limits; + +template <typename T> +struct numeric_limits<T, typename enable_if<is_unsigned<T>::value>::type> { + static T lowest() { + return 0; + } + static T highest() { + return T(-1); + } +}; + +template <typename T> +struct numeric_limits< + T, typename enable_if<is_integral<T>::value && is_signed<T>::value>::type> { + static T lowest() { + return T(T(1) << (sizeof(T) * 8 - 1)); + } + static T highest() { + return T(~lowest()); + } +}; + +} // namespace ARDUINOJSON_NAMESPACE + +#ifdef _MSC_VER +#pragma warning(pop) +#endif diff --git a/include/lib/ArduinoJson/Polyfills/math.hpp b/include/lib/ArduinoJson/Polyfills/math.hpp new file mode 100644 index 0000000..eff272a --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/math.hpp @@ -0,0 +1,27 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// Some libraries #define isnan() and isinf() so we need to check before +// using this name + +#ifndef isnan +template <typename T> +bool isnan(T x) { + return x != x; +} +#endif + +#ifndef isinf +template <typename T> +bool isinf(T x) { + return x != 0.0 && x * 2 == x; +} +#endif +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/mpl/max.hpp b/include/lib/ArduinoJson/Polyfills/mpl/max.hpp new file mode 100644 index 0000000..9ac47a5 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/mpl/max.hpp @@ -0,0 +1,26 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +#include <stddef.h> // for size_t + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that returns the highest value +template <size_t X, size_t Y, bool MaxIsX = (X > Y)> +struct Max {}; + +template <size_t X, size_t Y> +struct Max<X, Y, true> { + static const size_t value = X; +}; + +template <size_t X, size_t Y> +struct Max<X, Y, false> { + static const size_t value = Y; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/pgmspace.hpp b/include/lib/ArduinoJson/Polyfills/pgmspace.hpp new file mode 100644 index 0000000..f253818 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/pgmspace.hpp @@ -0,0 +1,79 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Polyfills/assert.hpp> + +namespace ARDUINOJSON_NAMESPACE { +// Wraps a const char* so that the our functions are picked only if the +// originals are missing +struct pgm_p { + pgm_p(const char* p) : address(p) {} + const char* address; +}; +} // namespace ARDUINOJSON_NAMESPACE + +#ifndef strlen_P +inline size_t strlen_P(ARDUINOJSON_NAMESPACE::pgm_p s) { + const char* p = s.address; + ARDUINOJSON_ASSERT(p != NULL); + while (pgm_read_byte(p)) p++; + return size_t(p - s.address); +} +#endif + +#ifndef strncmp_P +inline int strncmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b, size_t n) { + const char* s1 = a; + const char* s2 = b.address; + ARDUINOJSON_ASSERT(s1 != NULL); + ARDUINOJSON_ASSERT(s2 != NULL); + while (n-- > 0) { + char c1 = *s1++; + char c2 = static_cast<char>(pgm_read_byte(s2++)); + if (c1 < c2) + return -1; + if (c1 > c2) + return 1; + if (c1 == 0 /* and c2 as well */) + return 0; + } + return 0; +} +#endif + +#ifndef strcmp_P +inline int strcmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b) { + const char* s1 = a; + const char* s2 = b.address; + ARDUINOJSON_ASSERT(s1 != NULL); + ARDUINOJSON_ASSERT(s2 != NULL); + for (;;) { + char c1 = *s1++; + char c2 = static_cast<char>(pgm_read_byte(s2++)); + if (c1 < c2) + return -1; + if (c1 > c2) + return 1; + if (c1 == 0 /* and c2 as well */) + return 0; + } +} +#endif + +#ifndef memcpy_P +inline void* memcpy_P(void* dst, ARDUINOJSON_NAMESPACE::pgm_p src, size_t n) { + uint8_t* d = reinterpret_cast<uint8_t*>(dst); + const char* s = src.address; + ARDUINOJSON_ASSERT(d != NULL); + ARDUINOJSON_ASSERT(s != NULL); + while (n-- > 0) { + *d++ = pgm_read_byte(s++); + } + return dst; +} +#endif diff --git a/include/lib/ArduinoJson/Polyfills/pgmspace_generic.hpp b/include/lib/ArduinoJson/Polyfills/pgmspace_generic.hpp new file mode 100644 index 0000000..f5bbd85 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/pgmspace_generic.hpp @@ -0,0 +1,32 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +typename enable_if<is_pointer<T>::value, T>::type pgm_read(const void* p) { + return reinterpret_cast<T>(pgm_read_ptr(p)); +} + +template <typename T> +typename enable_if<is_floating_point<T>::value && + sizeof(T) == sizeof(float), // on AVR sizeof(double) == + // sizeof(float) + T>::type +pgm_read(const void* p) { + return pgm_read_float(p); +} + +template <typename T> +typename enable_if<is_same<T, uint32_t>::value, T>::type pgm_read( + const void* p) { + return pgm_read_dword(p); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/preprocessor.hpp b/include/lib/ArduinoJson/Polyfills/preprocessor.hpp new file mode 100644 index 0000000..488654b --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/preprocessor.hpp @@ -0,0 +1,35 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#define ARDUINOJSON_EXPAND6(a, b, c, d, e, f) a, b, c, d, e, f +#define ARDUINOJSON_EXPAND9(a, b, c, d, e, f, g, h, i) a, b, c, d, e, f, g, h, i +#define ARDUINOJSON_EXPAND18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, \ + q, r) \ + a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r + +#define ARDUINOJSON_CONCAT_(A, B) A##B +#define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B) +#define ARDUINOJSON_CONCAT4(A, B, C, D) \ + ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), ARDUINOJSON_CONCAT2(C, D)) + +#define ARDUINOJSON_HEX_DIGIT_0000() 0 +#define ARDUINOJSON_HEX_DIGIT_0001() 1 +#define ARDUINOJSON_HEX_DIGIT_0010() 2 +#define ARDUINOJSON_HEX_DIGIT_0011() 3 +#define ARDUINOJSON_HEX_DIGIT_0100() 4 +#define ARDUINOJSON_HEX_DIGIT_0101() 5 +#define ARDUINOJSON_HEX_DIGIT_0110() 6 +#define ARDUINOJSON_HEX_DIGIT_0111() 7 +#define ARDUINOJSON_HEX_DIGIT_1000() 8 +#define ARDUINOJSON_HEX_DIGIT_1001() 9 +#define ARDUINOJSON_HEX_DIGIT_1010() A +#define ARDUINOJSON_HEX_DIGIT_1011() B +#define ARDUINOJSON_HEX_DIGIT_1100() C +#define ARDUINOJSON_HEX_DIGIT_1101() D +#define ARDUINOJSON_HEX_DIGIT_1110() E +#define ARDUINOJSON_HEX_DIGIT_1111() F +#define ARDUINOJSON_HEX_DIGIT_(A, B, C, D) ARDUINOJSON_HEX_DIGIT_##A##B##C##D() +#define ARDUINOJSON_HEX_DIGIT(A, B, C, D) ARDUINOJSON_HEX_DIGIT_(A, B, C, D) diff --git a/include/lib/ArduinoJson/Polyfills/safe_strcmp.hpp b/include/lib/ArduinoJson/Polyfills/safe_strcmp.hpp new file mode 100644 index 0000000..e017b5d --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/safe_strcmp.hpp @@ -0,0 +1,32 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +#include <stdint.h> // int8_t + +namespace ARDUINOJSON_NAMESPACE { + +inline int safe_strcmp(const char* a, const char* b) { + if (a == b) + return 0; + if (!a) + return -1; + if (!b) + return 1; + return strcmp(a, b); +} + +inline int safe_strncmp(const char* a, const char* b, size_t n) { + if (a == b) + return 0; + if (!a) + return -1; + if (!b) + return 1; + return strncmp(a, b, n); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/static_array.hpp b/include/lib/ArduinoJson/Polyfills/static_array.hpp new file mode 100644 index 0000000..a877b4c --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/static_array.hpp @@ -0,0 +1,34 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> + +#if ARDUINOJSON_ENABLE_PROGMEM + +#include <ArduinoJson/Polyfills/pgmspace_generic.hpp> + +#ifndef ARDUINOJSON_DEFINE_STATIC_ARRAY +#define ARDUINOJSON_DEFINE_STATIC_ARRAY(type, name, value) \ + static type const name[] PROGMEM = value; +#endif + +#ifndef ARDUINOJSON_READ_STATIC_ARRAY +#define ARDUINOJSON_READ_STATIC_ARRAY(type, name, index) \ + pgm_read<type>(name + index) +#endif + +#else // i.e. ARDUINOJSON_ENABLE_PROGMEM == 0 + +#ifndef ARDUINOJSON_DEFINE_STATIC_ARRAY +#define ARDUINOJSON_DEFINE_STATIC_ARRAY(type, name, value) \ + static type const name[] = value; +#endif + +#ifndef ARDUINOJSON_READ_STATIC_ARRAY +#define ARDUINOJSON_READ_STATIC_ARRAY(type, name, index) name[index] +#endif + +#endif diff --git a/include/lib/ArduinoJson/Polyfills/type_traits.hpp b/include/lib/ArduinoJson/Polyfills/type_traits.hpp new file mode 100644 index 0000000..4a8ff4b --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits.hpp @@ -0,0 +1,24 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "type_traits/conditional.hpp" +#include "type_traits/enable_if.hpp" +#include "type_traits/integral_constant.hpp" +#include "type_traits/is_array.hpp" +#include "type_traits/is_base_of.hpp" +#include "type_traits/is_class.hpp" +#include "type_traits/is_const.hpp" +#include "type_traits/is_convertible.hpp" +#include "type_traits/is_enum.hpp" +#include "type_traits/is_floating_point.hpp" +#include "type_traits/is_integral.hpp" +#include "type_traits/is_pointer.hpp" +#include "type_traits/is_same.hpp" +#include "type_traits/is_signed.hpp" +#include "type_traits/is_unsigned.hpp" +#include "type_traits/make_unsigned.hpp" +#include "type_traits/remove_const.hpp" +#include "type_traits/remove_reference.hpp" diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/conditional.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/conditional.hpp new file mode 100644 index 0000000..e42d1bb --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/conditional.hpp @@ -0,0 +1,20 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <bool Condition, class TrueType, class FalseType> +struct conditional { + typedef TrueType type; +}; + +template <class TrueType, class FalseType> +struct conditional<false, TrueType, FalseType> { + typedef FalseType type; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/declval.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/declval.hpp new file mode 100644 index 0000000..8708112 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/declval.hpp @@ -0,0 +1,14 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +T declval(); + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/enable_if.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/enable_if.hpp new file mode 100644 index 0000000..cc29b33 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/enable_if.hpp @@ -0,0 +1,19 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that return the type T if Condition is true. +template <bool Condition, typename T = void> +struct enable_if {}; + +template <typename T> +struct enable_if<true, T> { + typedef T type; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/integral_constant.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/integral_constant.hpp new file mode 100644 index 0000000..b53d711 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/integral_constant.hpp @@ -0,0 +1,19 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T, T v> +struct integral_constant { + static const T value = v; +}; + +typedef integral_constant<bool, true> true_type; +typedef integral_constant<bool, false> false_type; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_array.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_array.hpp new file mode 100644 index 0000000..ee739a7 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_array.hpp @@ -0,0 +1,21 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +#include <stddef.h> // size_t + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +struct is_array : false_type {}; + +template <typename T> +struct is_array<T[]> : true_type {}; + +template <typename T, size_t N> +struct is_array<T[N]> : true_type {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_base_of.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_base_of.hpp new file mode 100644 index 0000000..32b41cd --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_base_of.hpp @@ -0,0 +1,26 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that returns true if Derived inherits from TBase is an +// integral type. +template <typename TBase, typename TDerived> +class is_base_of { + protected: // <- to avoid GCC's "all member functions in class are private" + typedef char Yes[1]; + typedef char No[2]; + + static Yes &probe(const TBase *); + static No &probe(...); + + public: + static const bool value = + sizeof(probe(reinterpret_cast<TDerived *>(0))) == sizeof(Yes); +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_class.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_class.hpp new file mode 100644 index 0000000..a3808f3 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_class.hpp @@ -0,0 +1,26 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "declval.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +struct is_class { + protected: // <- to avoid GCC's "all member functions in class are private" + typedef char Yes[1]; + typedef char No[2]; + + template <typename U> + static Yes &probe(void (U::*)(void)); + template <typename> + static No &probe(...); + + public: + static const bool value = sizeof(probe<T>(0)) == sizeof(Yes); +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_const.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_const.hpp new file mode 100644 index 0000000..32e758c --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_const.hpp @@ -0,0 +1,17 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "integral_constant.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that return the type T without the const modifier +template <typename T> +struct is_const : false_type {}; + +template <typename T> +struct is_const<const T> : true_type {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_convertible.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_convertible.hpp new file mode 100644 index 0000000..847525a --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_convertible.hpp @@ -0,0 +1,47 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "declval.hpp" + +#ifdef _MSC_VER +#pragma warning(push) +// conversion from 'T' to 'To', possible loss of data +#pragma warning(disable : 4244) +#endif + +// clang-format off +#ifdef __ICCARM__ +// Suppress IAR Compiler Warning[Pa093]: implicit conversion from floating point to integer +#pragma diag_suppress=Pa093 +#endif +// clang-format on + +namespace ARDUINOJSON_NAMESPACE { + +template <typename From, typename To> +struct is_convertible { + protected: // <- to avoid GCC's "all member functions in class are private" + typedef char Yes[1]; + typedef char No[2]; + + static Yes &probe(To); + static No &probe(...); + + public: + static const bool value = sizeof(probe(declval<From>())) == sizeof(Yes); +}; + +} // namespace ARDUINOJSON_NAMESPACE + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +// clang-format off +#ifdef __ICCARM__ +#pragma diag_default=Pa093 +#endif +// clang-format on diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_enum.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_enum.hpp new file mode 100644 index 0000000..26aec1d --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_enum.hpp @@ -0,0 +1,22 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "is_class.hpp" +#include "is_convertible.hpp" +#include "is_floating_point.hpp" +#include "is_integral.hpp" +#include "is_same.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +struct is_enum { + static const bool value = is_convertible<T, int>::value && + !is_class<T>::value && !is_integral<T>::value && + !is_floating_point<T>::value; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp new file mode 100644 index 0000000..b7e9d3d --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp @@ -0,0 +1,19 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "integral_constant.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template <typename> +struct is_floating_point : false_type {}; + +template <> +struct is_floating_point<float> : true_type {}; + +template <> +struct is_floating_point<double> : true_type {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_integral.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_integral.hpp new file mode 100644 index 0000000..26e895c --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_integral.hpp @@ -0,0 +1,33 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include "is_same.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that returns true if T is an integral type. +template <typename T> +struct is_integral { + static const bool value = + is_same<T, signed char>::value || is_same<T, unsigned char>::value || + is_same<T, signed short>::value || is_same<T, unsigned short>::value || + is_same<T, signed int>::value || is_same<T, unsigned int>::value || + is_same<T, signed long>::value || is_same<T, unsigned long>::value || +#if ARDUINOJSON_HAS_LONG_LONG + is_same<T, signed long long>::value || + is_same<T, unsigned long long>::value || +#endif +#if ARDUINOJSON_HAS_INT64 + is_same<T, signed __int64>::value || + is_same<T, unsigned __int64>::value || +#endif + is_same<T, char>::value || is_same<T, bool>::value; +}; + +template <typename T> +struct is_integral<const T> : is_integral<T> {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_pointer.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_pointer.hpp new file mode 100644 index 0000000..a249539 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_pointer.hpp @@ -0,0 +1,16 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "integral_constant.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +struct is_pointer : false_type {}; + +template <typename T> +struct is_pointer<T*> : true_type {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_same.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_same.hpp new file mode 100644 index 0000000..db5da9b --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_same.hpp @@ -0,0 +1,17 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "integral_constant.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that returns true if types T and U are the same. +template <typename T, typename U> +struct is_same : false_type {}; + +template <typename T> +struct is_same<T, T> : true_type {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_signed.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_signed.hpp new file mode 100644 index 0000000..fbb701c --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_signed.hpp @@ -0,0 +1,43 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "integral_constant.hpp" +namespace ARDUINOJSON_NAMESPACE { + +template <typename> +struct is_signed : false_type {}; + +template <> +struct is_signed<char> : true_type {}; + +template <> +struct is_signed<signed char> : true_type {}; + +template <> +struct is_signed<signed short> : true_type {}; + +template <> +struct is_signed<signed int> : true_type {}; + +template <> +struct is_signed<signed long> : true_type {}; + +template <> +struct is_signed<float> : true_type {}; + +template <> +struct is_signed<double> : true_type {}; + +#if ARDUINOJSON_HAS_LONG_LONG +template <> +struct is_signed<signed long long> : true_type {}; +#endif + +#if ARDUINOJSON_HAS_INT64 +template <> +struct is_signed<signed __int64> : true_type {}; +#endif +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp new file mode 100644 index 0000000..be26498 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp @@ -0,0 +1,37 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "integral_constant.hpp" +namespace ARDUINOJSON_NAMESPACE { + +template <typename> +struct is_unsigned : false_type {}; + +template <> +struct is_unsigned<bool> : true_type {}; + +template <> +struct is_unsigned<unsigned char> : true_type {}; + +template <> +struct is_unsigned<unsigned short> : true_type {}; + +template <> +struct is_unsigned<unsigned int> : true_type {}; + +template <> +struct is_unsigned<unsigned long> : true_type {}; + +#if ARDUINOJSON_HAS_INT64 +template <> +struct is_unsigned<unsigned __int64> : true_type {}; +#endif + +#if ARDUINOJSON_HAS_LONG_LONG +template <> +struct is_unsigned<unsigned long long> : true_type {}; +#endif +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp new file mode 100644 index 0000000..4cf2d08 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp @@ -0,0 +1,49 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "type_identity.hpp" +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +struct make_unsigned; + +template <> +struct make_unsigned<char> : type_identity<unsigned char> {}; + +template <> +struct make_unsigned<signed char> : type_identity<unsigned char> {}; +template <> +struct make_unsigned<unsigned char> : type_identity<unsigned char> {}; + +template <> +struct make_unsigned<signed short> : type_identity<unsigned short> {}; +template <> +struct make_unsigned<unsigned short> : type_identity<unsigned short> {}; + +template <> +struct make_unsigned<signed int> : type_identity<unsigned int> {}; +template <> +struct make_unsigned<unsigned int> : type_identity<unsigned int> {}; + +template <> +struct make_unsigned<signed long> : type_identity<unsigned long> {}; +template <> +struct make_unsigned<unsigned long> : type_identity<unsigned long> {}; + +#if ARDUINOJSON_HAS_LONG_LONG +template <> +struct make_unsigned<signed long long> : type_identity<unsigned long long> {}; +template <> +struct make_unsigned<unsigned long long> : type_identity<unsigned long long> {}; +#endif + +#if ARDUINOJSON_HAS_INT64 +template <> +struct make_unsigned<signed __int64> : type_identity<unsigned __int64> {}; +template <> +struct make_unsigned<unsigned __int64> : type_identity<unsigned __int64> {}; +#endif +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/remove_const.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/remove_const.hpp new file mode 100644 index 0000000..5a19eb1 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/remove_const.hpp @@ -0,0 +1,20 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that return the type T without the const modifier +template <typename T> +struct remove_const { + typedef T type; +}; +template <typename T> +struct remove_const<const T> { + typedef T type; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/remove_reference.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/remove_reference.hpp new file mode 100644 index 0000000..1812850 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/remove_reference.hpp @@ -0,0 +1,20 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// A meta-function that return the type T without the reference modifier. +template <typename T> +struct remove_reference { + typedef T type; +}; +template <typename T> +struct remove_reference<T&> { + typedef T type; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/type_traits/type_identity.hpp b/include/lib/ArduinoJson/Polyfills/type_traits/type_identity.hpp new file mode 100644 index 0000000..c464a47 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/type_traits/type_identity.hpp @@ -0,0 +1,15 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "integral_constant.hpp" + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +struct type_identity { + typedef T type; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Polyfills/utility.hpp b/include/lib/ArduinoJson/Polyfills/utility.hpp new file mode 100644 index 0000000..c99bc99 --- /dev/null +++ b/include/lib/ArduinoJson/Polyfills/utility.hpp @@ -0,0 +1,28 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include "type_traits.hpp" + +namespace ARDUINOJSON_NAMESPACE { +template <typename T> +inline void swap(T& a, T& b) { + T t(a); + a = b; + b = t; +} + +#if ARDUINOJSON_HAS_RVALUE_REFERENCES +template <typename T> +typename remove_reference<T>::type&& move(T&& t) { + return static_cast<typename remove_reference<T>::type&&>(t); +} +#else +template <typename T> +T& move(T& t) { + return t; +} +#endif +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/CountingDecorator.hpp b/include/lib/ArduinoJson/Serialization/CountingDecorator.hpp new file mode 100644 index 0000000..3d89fb1 --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/CountingDecorator.hpp @@ -0,0 +1,33 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TWriter> +class CountingDecorator { + public: + explicit CountingDecorator(TWriter& writer) : _writer(writer), _count(0) {} + + void write(uint8_t c) { + _count += _writer.write(c); + } + + void write(const uint8_t* s, size_t n) { + _count += _writer.write(s, n); + } + + size_t count() const { + return _count; + } + + private: + TWriter _writer; + size_t _count; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/Writer.hpp b/include/lib/ArduinoJson/Serialization/Writer.hpp new file mode 100644 index 0000000..52bd117 --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/Writer.hpp @@ -0,0 +1,47 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// The default writer is a simple wrapper for Writers that are not copiable +template <typename TDestination, typename Enable = void> +class Writer { + public: + explicit Writer(TDestination& dest) : _dest(&dest) {} + + size_t write(uint8_t c) { + return _dest->write(c); + } + + size_t write(const uint8_t* s, size_t n) { + return _dest->write(s, n); + } + + private: + TDestination* _dest; +}; + +} // namespace ARDUINOJSON_NAMESPACE + +#include <ArduinoJson/Serialization/Writers/StaticStringWriter.hpp> + +#if ARDUINOJSON_ENABLE_STD_STRING +#include <ArduinoJson/Serialization/Writers/StdStringWriter.hpp> +#endif + +#if ARDUINOJSON_ENABLE_ARDUINO_STRING +#include <ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp> +#endif + +#if ARDUINOJSON_ENABLE_STD_STREAM +#include <ArduinoJson/Serialization/Writers/StdStreamWriter.hpp> +#endif + +#if ARDUINOJSON_ENABLE_ARDUINO_PRINT +#include <ArduinoJson/Serialization/Writers/PrintWriter.hpp> +#endif diff --git a/include/lib/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp b/include/lib/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp new file mode 100644 index 0000000..5efa6e4 --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp @@ -0,0 +1,52 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <Arduino.h> + +namespace ARDUINOJSON_NAMESPACE { + +template <> +class Writer< ::String, void> { + static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE; + + public: + explicit Writer(::String &str) : _destination(&str) { + _size = 0; + } + + ~Writer() { + flush(); + } + + size_t write(uint8_t c) { + ARDUINOJSON_ASSERT(_size < bufferCapacity); + _buffer[_size++] = static_cast<char>(c); + if (_size + 1 >= bufferCapacity) + flush(); + return 1; + } + + size_t write(const uint8_t *s, size_t n) { + for (size_t i = 0; i < n; i++) { + write(s[i]); + } + return n; + } + + private: + void flush() { + ARDUINOJSON_ASSERT(_size < bufferCapacity); + _buffer[_size] = 0; + *_destination += _buffer; + _size = 0; + } + + ::String *_destination; + char _buffer[bufferCapacity]; + size_t _size; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/Writers/DummyWriter.hpp b/include/lib/ArduinoJson/Serialization/Writers/DummyWriter.hpp new file mode 100644 index 0000000..a26a1f1 --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/Writers/DummyWriter.hpp @@ -0,0 +1,21 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class DummyWriter { + public: + size_t write(uint8_t) { + return 1; + } + + size_t write(const uint8_t*, size_t n) { + return n; + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/Writers/PrintWriter.hpp b/include/lib/ArduinoJson/Serialization/Writers/PrintWriter.hpp new file mode 100644 index 0000000..13a6491 --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/Writers/PrintWriter.hpp @@ -0,0 +1,28 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TDestination> +class Writer< + TDestination, + typename enable_if<is_base_of< ::Print, TDestination>::value>::type> { + public: + explicit Writer(::Print& print) : _print(&print) {} + + size_t write(uint8_t c) { + return _print->write(c); + } + + size_t write(const uint8_t* s, size_t n) { + return _print->write(s, n); + } + + private: + ::Print* _print; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp b/include/lib/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp new file mode 100644 index 0000000..1a4213b --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp @@ -0,0 +1,35 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class StaticStringWriter { + public: + StaticStringWriter(char *buf, size_t size) : end(buf + size), p(buf) {} + + size_t write(uint8_t c) { + if (p >= end) + return 0; + *p++ = static_cast<char>(c); + return 1; + } + + size_t write(const uint8_t *s, size_t n) { + char *begin = p; + while (p < end && n > 0) { + *p++ = static_cast<char>(*s++); + n--; + } + return size_t(p - begin); + } + + private: + char *end; + char *p; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp b/include/lib/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp new file mode 100644 index 0000000..e08ba4d --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp @@ -0,0 +1,32 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ostream> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TDestination> +class Writer< + TDestination, + typename enable_if<is_base_of<std::ostream, TDestination>::value>::type> { + public: + explicit Writer(std::ostream& os) : _os(&os) {} + + size_t write(uint8_t c) { + _os->put(static_cast<char>(c)); + return 1; + } + + size_t write(const uint8_t* s, size_t n) { + _os->write(reinterpret_cast<const char*>(s), + static_cast<std::streamsize>(n)); + return n; + } + + private: + std::ostream* _os; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/Writers/StdStringWriter.hpp b/include/lib/ArduinoJson/Serialization/Writers/StdStringWriter.hpp new file mode 100644 index 0000000..c1f7cc0 --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/Writers/StdStringWriter.hpp @@ -0,0 +1,40 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> + +#include <string> + +namespace ARDUINOJSON_NAMESPACE { + +template <class T> +struct is_std_string : false_type {}; + +template <class TCharTraits, class TAllocator> +struct is_std_string<std::basic_string<char, TCharTraits, TAllocator> > + : true_type {}; + +template <typename TDestination> +class Writer<TDestination, + typename enable_if<is_std_string<TDestination>::value>::type> { + public: + Writer(TDestination &str) : _str(&str) {} + + size_t write(uint8_t c) { + _str->operator+=(static_cast<char>(c)); + return 1; + } + + size_t write(const uint8_t *s, size_t n) { + _str->append(reinterpret_cast<const char *>(s), n); + return n; + } + + private: + TDestination *_str; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/measure.hpp b/include/lib/ArduinoJson/Serialization/measure.hpp new file mode 100644 index 0000000..6d19994 --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/measure.hpp @@ -0,0 +1,18 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Serialization/Writers/DummyWriter.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <template <typename> class TSerializer, typename TSource> +size_t measure(const TSource &source) { + DummyWriter dp; + TSerializer<DummyWriter> serializer(dp); + return source.accept(serializer); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Serialization/serialize.hpp b/include/lib/ArduinoJson/Serialization/serialize.hpp new file mode 100644 index 0000000..16d2e4e --- /dev/null +++ b/include/lib/ArduinoJson/Serialization/serialize.hpp @@ -0,0 +1,54 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Serialization/Writer.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <template <typename> class TSerializer, typename TSource, + typename TWriter> +size_t doSerialize(const TSource &source, TWriter writer) { + TSerializer<TWriter> serializer(writer); + return source.accept(serializer); +} + +template <template <typename> class TSerializer, typename TSource, + typename TDestination> +size_t serialize(const TSource &source, TDestination &destination) { + Writer<TDestination> writer(destination); + return doSerialize<TSerializer>(source, writer); +} + +template <template <typename> class TSerializer, typename TSource> +typename enable_if<!TSerializer<StaticStringWriter>::producesText, size_t>::type +serialize(const TSource &source, void *buffer, size_t bufferSize) { + StaticStringWriter writer(reinterpret_cast<char *>(buffer), bufferSize); + return doSerialize<TSerializer>(source, writer); +} + +template <template <typename> class TSerializer, typename TSource> +typename enable_if<TSerializer<StaticStringWriter>::producesText, size_t>::type +serialize(const TSource &source, void *buffer, size_t bufferSize) { + StaticStringWriter writer(reinterpret_cast<char *>(buffer), bufferSize); + size_t n = doSerialize<TSerializer>(source, writer); + // add null-terminator for text output (not counted in the size) + if (n < bufferSize) + reinterpret_cast<char *>(buffer)[n] = 0; + return n; +} + +template <template <typename> class TSerializer, typename TSource, + typename TChar, size_t N> +#if defined _MSC_VER && _MSC_VER < 1900 +typename enable_if<sizeof(remove_reference<TChar>::type) == 1, size_t>::type +#else +typename enable_if<sizeof(TChar) == 1, size_t>::type +#endif +serialize(const TSource &source, TChar (&buffer)[N]) { + return serialize<TSerializer>(source, buffer, N); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/StringStorage/StringCopier.hpp b/include/lib/ArduinoJson/StringStorage/StringCopier.hpp new file mode 100644 index 0000000..8b1104b --- /dev/null +++ b/include/lib/ArduinoJson/StringStorage/StringCopier.hpp @@ -0,0 +1,62 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Memory/MemoryPool.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class StringCopier { + public: + StringCopier(MemoryPool& pool) : _pool(&pool) {} + + void startString() { + _pool->getFreeZone(&_ptr, &_capacity); + _size = 0; + } + + const char* save() { + ARDUINOJSON_ASSERT(_ptr); + return _pool->saveStringFromFreeZone(_size); + } + + void append(const char* s) { + while (*s) append(*s++); + } + + void append(const char* s, size_t n) { + while (n-- > 0) append(*s++); + } + + void append(char c) { + if (!_ptr) + return; + + if (_size >= _capacity) { + _ptr = 0; + _pool->markAsOverflowed(); + return; + } + + _ptr[_size++] = c; + } + + bool isValid() { + return _ptr != 0; + } + + const char* c_str() { + return _ptr; + } + + typedef storage_policies::store_by_copy storage_policy; + + private: + MemoryPool* _pool; + char* _ptr; + size_t _size; + size_t _capacity; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/StringStorage/StringMover.hpp b/include/lib/ArduinoJson/StringStorage/StringMover.hpp new file mode 100644 index 0000000..f727a7d --- /dev/null +++ b/include/lib/ArduinoJson/StringStorage/StringMover.hpp @@ -0,0 +1,42 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class StringMover { + public: + StringMover(char* ptr) : _writePtr(ptr) {} + + void startString() { + _startPtr = _writePtr; + } + + const char* save() const { + return _startPtr; + } + + void append(char c) { + *_writePtr++ = c; + } + + bool isValid() const { + return true; + } + + const char* c_str() const { + return _startPtr; + } + + typedef storage_policies::store_by_address storage_policy; + + private: + char* _writePtr; + char* _startPtr; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/StringStorage/StringStorage.hpp b/include/lib/ArduinoJson/StringStorage/StringStorage.hpp new file mode 100644 index 0000000..36e6326 --- /dev/null +++ b/include/lib/ArduinoJson/StringStorage/StringStorage.hpp @@ -0,0 +1,23 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/StringStorage/StringCopier.hpp> +#include <ArduinoJson/StringStorage/StringMover.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TInput> +StringCopier makeStringStorage(TInput&, MemoryPool& pool) { + return StringCopier(pool); +} + +template <typename TChar> +StringMover makeStringStorage( + TChar* input, MemoryPool&, + typename enable_if<!is_const<TChar>::value>::type* = 0) { + return StringMover(reinterpret_cast<char*>(input)); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/ArduinoStringAdapter.hpp b/include/lib/ArduinoJson/Strings/ArduinoStringAdapter.hpp new file mode 100644 index 0000000..24646cc --- /dev/null +++ b/include/lib/ArduinoJson/Strings/ArduinoStringAdapter.hpp @@ -0,0 +1,62 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <Arduino.h> + +#include <ArduinoJson/Polyfills/safe_strcmp.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class ArduinoStringAdapter { + public: + ArduinoStringAdapter(const ::String& str) : _str(&str) {} + + void copyTo(char* p, size_t n) const { + memcpy(p, _str->c_str(), n); + } + + bool isNull() const { + // Arduino's String::c_str() can return NULL + return !_str->c_str(); + } + + int compare(const char* other) const { + // Arduino's String::c_str() can return NULL + const char* me = _str->c_str(); + return safe_strcmp(me, other); + } + + bool equals(const char* expected) const { + return compare(expected) == 0; + } + + size_t size() const { + return _str->length(); + } + + const char* begin() const { + return _str->c_str(); + } + + typedef storage_policies::store_by_copy storage_policy; + + private: + const ::String* _str; +}; + +template <> +struct IsString< ::String> : true_type {}; + +template <> +struct IsString< ::StringSumHelper> : true_type {}; + +inline ArduinoStringAdapter adaptString(const ::String& str) { + return ArduinoStringAdapter(str); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/ConstRamStringAdapter.hpp b/include/lib/ArduinoJson/Strings/ConstRamStringAdapter.hpp new file mode 100644 index 0000000..ec7d53a --- /dev/null +++ b/include/lib/ArduinoJson/Strings/ConstRamStringAdapter.hpp @@ -0,0 +1,62 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <stddef.h> // size_t +#include <string.h> // strcmp + +#include <ArduinoJson/Polyfills/safe_strcmp.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class ConstRamStringAdapter { + public: + ConstRamStringAdapter(const char* str = 0) : _str(str) {} + + int compare(const char* other) const { + return safe_strcmp(_str, other); + } + + bool equals(const char* expected) const { + return compare(expected) == 0; + } + + bool isNull() const { + return !_str; + } + + size_t size() const { + if (!_str) + return 0; + return strlen(_str); + } + + const char* data() const { + return _str; + } + + const char* begin() const { + return _str; + } + + typedef storage_policies::store_by_address storage_policy; + + protected: + const char* _str; +}; + +template <> +struct IsString<const char*> : true_type {}; + +template <int N> +struct IsString<const char[N]> : true_type {}; + +inline ConstRamStringAdapter adaptString(const char* str) { + return ConstRamStringAdapter(str); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/FlashStringAdapter.hpp b/include/lib/ArduinoJson/Strings/FlashStringAdapter.hpp new file mode 100644 index 0000000..292e348 --- /dev/null +++ b/include/lib/ArduinoJson/Strings/FlashStringAdapter.hpp @@ -0,0 +1,62 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/pgmspace.hpp> +#include <ArduinoJson/Strings/FlashStringIterator.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class FlashStringAdapter { + public: + FlashStringAdapter(const __FlashStringHelper* str) : _str(str) {} + + int compare(const char* other) const { + if (!other && !_str) + return 0; + if (!_str) + return -1; + if (!other) + return 1; + return -strcmp_P(other, reinterpret_cast<const char*>(_str)); + } + + bool equals(const char* expected) const { + return compare(expected) == 0; + } + + bool isNull() const { + return !_str; + } + + void copyTo(char* p, size_t n) const { + memcpy_P(p, reinterpret_cast<const char*>(_str), n); + } + + size_t size() const { + if (!_str) + return 0; + return strlen_P(reinterpret_cast<const char*>(_str)); + } + + FlashStringIterator begin() const { + return FlashStringIterator(_str); + } + + typedef storage_policies::store_by_copy storage_policy; + + private: + const __FlashStringHelper* _str; +}; + +inline FlashStringAdapter adaptString(const __FlashStringHelper* str) { + return FlashStringAdapter(str); +} + +template <> +struct IsString<const __FlashStringHelper*> : true_type {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/FlashStringIterator.hpp b/include/lib/ArduinoJson/Strings/FlashStringIterator.hpp new file mode 100644 index 0000000..9a97f32 --- /dev/null +++ b/include/lib/ArduinoJson/Strings/FlashStringIterator.hpp @@ -0,0 +1,44 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +namespace ARDUINOJSON_NAMESPACE { + +class FlashStringIterator { + public: + explicit FlashStringIterator(const __FlashStringHelper* ptr) + : _ptr(reinterpret_cast<const char*>(ptr)) {} + + explicit FlashStringIterator(const char* ptr) : _ptr(ptr) {} + + FlashStringIterator operator+(ptrdiff_t d) const { + return FlashStringIterator(_ptr + d); + } + + ptrdiff_t operator-(FlashStringIterator other) const { + return _ptr - other._ptr; + } + + FlashStringIterator operator++(int) { + return FlashStringIterator(_ptr++); + } + + FlashStringIterator operator++() { + return FlashStringIterator(++_ptr); + } + + bool operator!=(FlashStringIterator other) const { + return _ptr != other._ptr; + } + + char operator*() const { + return char(pgm_read_byte(_ptr)); + } + + private: + const char* _ptr; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/IsString.hpp b/include/lib/ArduinoJson/Strings/IsString.hpp new file mode 100644 index 0000000..af5a91a --- /dev/null +++ b/include/lib/ArduinoJson/Strings/IsString.hpp @@ -0,0 +1,18 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/type_traits.hpp> + +namespace ARDUINOJSON_NAMESPACE { +template <typename> +struct IsString : false_type {}; + +template <typename T> +struct IsString<const T> : IsString<T> {}; + +template <typename T> +struct IsString<T&> : IsString<T> {}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/IsWriteableString.hpp b/include/lib/ArduinoJson/Strings/IsWriteableString.hpp new file mode 100644 index 0000000..32039e3 --- /dev/null +++ b/include/lib/ArduinoJson/Strings/IsWriteableString.hpp @@ -0,0 +1,37 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> + +#if ARDUINOJSON_ENABLE_ARDUINO_STRING +#include <Arduino.h> +#endif + +#if ARDUINOJSON_ENABLE_STD_STRING +#include <string> +#endif + +namespace ARDUINOJSON_NAMESPACE { + +template <typename> +struct IsWriteableString : false_type {}; + +#if ARDUINOJSON_ENABLE_ARDUINO_STRING + +template <> +struct IsWriteableString< ::String> : true_type {}; + +#endif + +#if ARDUINOJSON_ENABLE_STD_STRING + +template <typename TCharTraits, typename TAllocator> +struct IsWriteableString<std::basic_string<char, TCharTraits, TAllocator> > + : true_type {}; + +#endif +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/RamStringAdapter.hpp b/include/lib/ArduinoJson/Strings/RamStringAdapter.hpp new file mode 100644 index 0000000..eded6c9 --- /dev/null +++ b/include/lib/ArduinoJson/Strings/RamStringAdapter.hpp @@ -0,0 +1,43 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Strings/ConstRamStringAdapter.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class RamStringAdapter : public ConstRamStringAdapter { + public: + RamStringAdapter(const char* str) : ConstRamStringAdapter(str) {} + + void copyTo(char* p, size_t n) const { + memcpy(p, _str, n); + } + + typedef ARDUINOJSON_NAMESPACE::storage_policies::store_by_copy storage_policy; +}; + +template <typename TChar> +inline RamStringAdapter adaptString(const TChar* str) { + return RamStringAdapter(reinterpret_cast<const char*>(str)); +} + +inline RamStringAdapter adaptString(char* str) { + return RamStringAdapter(str); +} + +template <typename TChar> +struct IsString<TChar*> { + static const bool value = sizeof(TChar) == 1; +}; + +template <> +struct IsString<void*> { + static const bool value = false; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/SizedFlashStringAdapter.hpp b/include/lib/ArduinoJson/Strings/SizedFlashStringAdapter.hpp new file mode 100644 index 0000000..b9cc0bf --- /dev/null +++ b/include/lib/ArduinoJson/Strings/SizedFlashStringAdapter.hpp @@ -0,0 +1,60 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Strings/FlashStringIterator.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class SizedFlashStringAdapter { + public: + SizedFlashStringAdapter(const __FlashStringHelper* str, size_t sz) + : _str(str), _size(sz) {} + + int compare(const char* other) const { + if (!other && !_str) + return 0; + if (!_str) + return -1; + if (!other) + return 1; + return -strncmp_P(other, reinterpret_cast<const char*>(_str), _size); + } + + bool equals(const char* expected) const { + return compare(expected) == 0; + } + + bool isNull() const { + return !_str; + } + + void copyTo(char* p, size_t n) const { + memcpy_P(p, reinterpret_cast<const char*>(_str), n); + } + + size_t size() const { + return _size; + } + + FlashStringIterator begin() const { + return FlashStringIterator(_str); + } + + typedef storage_policies::store_by_copy storage_policy; + + private: + const __FlashStringHelper* _str; + size_t _size; +}; + +inline SizedFlashStringAdapter adaptString(const __FlashStringHelper* str, + size_t sz) { + return SizedFlashStringAdapter(str, sz); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/SizedRamStringAdapter.hpp b/include/lib/ArduinoJson/Strings/SizedRamStringAdapter.hpp new file mode 100644 index 0000000..fe23408 --- /dev/null +++ b/include/lib/ArduinoJson/Strings/SizedRamStringAdapter.hpp @@ -0,0 +1,55 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +#include <string.h> // strcmp + +namespace ARDUINOJSON_NAMESPACE { + +class SizedRamStringAdapter { + public: + SizedRamStringAdapter(const char* str, size_t n) : _str(str), _size(n) {} + + int compare(const char* other) const { + return safe_strncmp(_str, other, _size); + } + + bool equals(const char* expected) const { + return compare(expected) == 0; + } + + bool isNull() const { + return !_str; + } + + void copyTo(char* p, size_t n) const { + memcpy(p, _str, n); + } + + size_t size() const { + return _size; + } + + const char* begin() const { + return _str; + } + + typedef storage_policies::store_by_copy storage_policy; + + private: + const char* _str; + size_t _size; +}; + +template <typename TChar> +inline SizedRamStringAdapter adaptString(const TChar* str, size_t size) { + return SizedRamStringAdapter(reinterpret_cast<const char*>(str), size); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/StdStringAdapter.hpp b/include/lib/ArduinoJson/Strings/StdStringAdapter.hpp new file mode 100644 index 0000000..ebf4c39 --- /dev/null +++ b/include/lib/ArduinoJson/Strings/StdStringAdapter.hpp @@ -0,0 +1,65 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +#include <string> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TString> +class StdStringAdapter { + public: + StdStringAdapter(const TString& str) : _str(&str) {} + + void copyTo(char* p, size_t n) const { + memcpy(p, _str->c_str(), n); + } + + bool isNull() const { + return false; + } + + int compare(const char* other) const { + if (!other) + return 1; + return _str->compare(other); + } + + bool equals(const char* expected) const { + if (!expected) + return false; + return *_str == expected; + } + + size_t size() const { + return _str->size(); + } + + const char* begin() const { + return _str->c_str(); + } + + typedef storage_policies::store_by_copy storage_policy; + + private: + const TString* _str; +}; + +template <typename TCharTraits, typename TAllocator> +struct IsString<std::basic_string<char, TCharTraits, TAllocator> > : true_type { +}; + +template <typename TCharTraits, typename TAllocator> +inline StdStringAdapter<std::basic_string<char, TCharTraits, TAllocator> > +adaptString(const std::basic_string<char, TCharTraits, TAllocator>& str) { + return StdStringAdapter<std::basic_string<char, TCharTraits, TAllocator> >( + str); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/StoragePolicy.hpp b/include/lib/ArduinoJson/Strings/StoragePolicy.hpp new file mode 100644 index 0000000..df0d62b --- /dev/null +++ b/include/lib/ArduinoJson/Strings/StoragePolicy.hpp @@ -0,0 +1,15 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +namespace ARDUINOJSON_NAMESPACE { + +namespace storage_policies { +struct store_by_address {}; +struct store_by_copy {}; +struct decide_at_runtime {}; +} // namespace storage_policies + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/String.hpp b/include/lib/ArduinoJson/Strings/String.hpp new file mode 100644 index 0000000..4f2abde --- /dev/null +++ b/include/lib/ArduinoJson/Strings/String.hpp @@ -0,0 +1,77 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Strings/ConstRamStringAdapter.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class String { + public: + String() : _data(0), _isStatic(true) {} + String(const char* data, bool isStaticData = true) + : _data(data), _isStatic(isStaticData) {} + + const char* c_str() const { + return _data; + } + + bool isNull() const { + return !_data; + } + + bool isStatic() const { + return _isStatic; + } + + friend bool operator==(String lhs, String rhs) { + if (lhs._data == rhs._data) + return true; + if (!lhs._data) + return false; + if (!rhs._data) + return false; + return strcmp(lhs._data, rhs._data) == 0; + } + + friend bool operator!=(String lhs, String rhs) { + if (lhs._data == rhs._data) + return false; + if (!lhs._data) + return true; + if (!rhs._data) + return true; + return strcmp(lhs._data, rhs._data) != 0; + } + + private: + const char* _data; + bool _isStatic; +}; + +class StringAdapter : public RamStringAdapter { + public: + StringAdapter(const String& str) + : RamStringAdapter(str.c_str()), _isStatic(str.isStatic()) {} + + bool isStatic() const { + return _isStatic; + } + + typedef storage_policies::decide_at_runtime storage_policy; + + private: + bool _isStatic; +}; + +template <> +struct IsString<String> : true_type {}; + +inline StringAdapter adaptString(const String& str) { + return StringAdapter(str); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Strings/StringAdapters.hpp b/include/lib/ArduinoJson/Strings/StringAdapters.hpp new file mode 100644 index 0000000..3d294d2 --- /dev/null +++ b/include/lib/ArduinoJson/Strings/StringAdapters.hpp @@ -0,0 +1,22 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Strings/ConstRamStringAdapter.hpp> +#include <ArduinoJson/Strings/RamStringAdapter.hpp> +#include <ArduinoJson/Strings/SizedRamStringAdapter.hpp> + +#if ARDUINOJSON_ENABLE_STD_STRING +#include <ArduinoJson/Strings/StdStringAdapter.hpp> +#endif + +#if ARDUINOJSON_ENABLE_ARDUINO_STRING +#include <ArduinoJson/Strings/ArduinoStringAdapter.hpp> +#endif + +#if ARDUINOJSON_ENABLE_PROGMEM +#include <ArduinoJson/Strings/FlashStringAdapter.hpp> +#include <ArduinoJson/Strings/SizedFlashStringAdapter.hpp> +#endif diff --git a/include/lib/ArduinoJson/Variant/Converter.hpp b/include/lib/ArduinoJson/Variant/Converter.hpp new file mode 100644 index 0000000..476ca8f --- /dev/null +++ b/include/lib/ArduinoJson/Variant/Converter.hpp @@ -0,0 +1,12 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T, typename Enable = void> +struct Converter; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/ConverterImpl.hpp b/include/lib/ArduinoJson/Variant/ConverterImpl.hpp new file mode 100644 index 0000000..34e12bb --- /dev/null +++ b/include/lib/ArduinoJson/Variant/ConverterImpl.hpp @@ -0,0 +1,268 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Strings/IsWriteableString.hpp> +#include <ArduinoJson/Variant/VariantFunctions.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T, typename Enable> +struct Converter { + static bool toJson(const T& src, VariantRef dst) { + // clang-format off + return convertToJson(src, dst); // Error here? See https://arduinojson.org/v6/unsupported-set/ + // clang-format on + } + + static T fromJson(VariantConstRef src) { + // clang-format off + T result; // Error here? See https://arduinojson.org/v6/non-default-constructible/ + convertFromJson(src, result); // Error here? See https://arduinojson.org/v6/unsupported-as/ + // clang-format on + return result; + } + + static bool checkJson(VariantConstRef src) { + T dummy; + // clang-format off + return canConvertFromJson(src, dummy); // Error here? See https://arduinojson.org/v6/unsupported-is/ + // clang-format on + } +}; + +template <typename T> +struct Converter< + T, typename enable_if<is_integral<T>::value && !is_same<bool, T>::value && + !is_same<char, T>::value>::type> { + static bool toJson(T src, VariantRef dst) { + VariantData* data = getData(dst); + ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T); + if (!data) + return false; + data->setInteger(src); + return true; + } + + static T fromJson(VariantConstRef src) { + ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T); + const VariantData* data = getData(src); + return data ? data->asIntegral<T>() : T(); + } + + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data && data->isInteger<T>(); + } +}; + +template <typename T> +struct Converter<T, typename enable_if<is_enum<T>::value>::type> { + static bool toJson(T src, VariantRef dst) { + return dst.set(static_cast<Integer>(src)); + } + + static T fromJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data ? static_cast<T>(data->asIntegral<int>()) : T(); + } + + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data && data->isInteger<int>(); + } +}; + +template <> +struct Converter<bool> { + static bool toJson(bool src, VariantRef dst) { + VariantData* data = getData(dst); + if (!data) + return false; + data->setBoolean(src); + return true; + } + + static bool fromJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data ? data->asBoolean() : false; + } + + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data && data->isBoolean(); + } +}; + +template <typename T> +struct Converter<T, typename enable_if<is_floating_point<T>::value>::type> { + static bool toJson(T src, VariantRef dst) { + VariantData* data = getData(dst); + if (!data) + return false; + data->setFloat(static_cast<Float>(src)); + return true; + } + + static T fromJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data ? data->asFloat<T>() : false; + } + + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data && data->isFloat(); + } +}; + +template <> +struct Converter<const char*> { + static bool toJson(const char* src, VariantRef dst) { + return variantSetString(getData(dst), adaptString(src), getPool(dst)); + } + + static const char* fromJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data ? data->asString() : 0; + } + + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data && data->isString(); + } +}; + +template <typename T> +inline typename enable_if<IsString<T>::value, bool>::type convertToJson( + const T& src, VariantRef dst) { + VariantData* data = getData(dst); + MemoryPool* pool = getPool(dst); + return variantSetString(data, adaptString(src), pool); +} + +template <typename T> +inline typename enable_if<IsWriteableString<T>::value>::type convertFromJson( + VariantConstRef src, T& dst) { + const VariantData* data = getData(src); + const char* cstr = data != 0 ? data->asString() : 0; + if (cstr) + dst = cstr; + else + serializeJson(src, dst); +} + +template <typename T> +inline typename enable_if<IsWriteableString<T>::value, bool>::type +canConvertFromJson(VariantConstRef src, const T&) { + const VariantData* data = getData(src); + return data && data->isString(); +} + +template <> +struct Converter<SerializedValue<const char*> > { + static bool toJson(SerializedValue<const char*> src, VariantRef dst) { + VariantData* data = getData(dst); + if (!data) + return false; + data->setLinkedRaw(src); + return true; + } +}; + +// SerializedValue<std::string> +// SerializedValue<String> +// SerializedValue<const __FlashStringHelper*> +template <typename T> +struct Converter<SerializedValue<T>, + typename enable_if<!is_same<const char*, T>::value>::type> { + static bool toJson(SerializedValue<T> src, VariantRef dst) { + VariantData* data = getData(dst); + MemoryPool* pool = getPool(dst); + return data != 0 && data->setOwnedRaw(src, pool); + } +}; + +#if ARDUINOJSON_HAS_NULLPTR + +template <> +struct Converter<decltype(nullptr)> { + static bool toJson(decltype(nullptr), VariantRef dst) { + variantSetNull(getData(dst)); + return true; + } + static decltype(nullptr) fromJson(VariantConstRef) { + return nullptr; + } + static bool checkJson(VariantConstRef src) { + const VariantData* data = getData(src); + return data == 0 || data->isNull(); + } +}; + +#endif + +#if ARDUINOJSON_ENABLE_ARDUINO_STREAM + +class MemoryPoolPrint : public Print { + public: + MemoryPoolPrint(MemoryPool* pool) : _pool(pool), _size(0) { + pool->getFreeZone(&_string, &_capacity); + } + + const char* c_str() { + _string[_size++] = 0; + ARDUINOJSON_ASSERT(_size <= _capacity); + return _pool->saveStringFromFreeZone(_size); + } + + size_t write(uint8_t c) { + if (_size >= _capacity) + return 0; + + _string[_size++] = char(c); + return 1; + } + + size_t write(const uint8_t* buffer, size_t size) { + if (_size + size >= _capacity) { + _size = _capacity; // mark as overflowed + return 0; + } + memcpy(&_string[_size], buffer, size); + _size += size; + return size; + } + + bool overflowed() const { + return _size >= _capacity; + } + + private: + MemoryPool* _pool; + size_t _size; + char* _string; + size_t _capacity; +}; + +inline bool convertToJson(const ::Printable& src, VariantRef dst) { + MemoryPool* pool = getPool(dst); + VariantData* data = getData(dst); + if (!pool || !data) + return false; + MemoryPoolPrint print(pool); + src.printTo(print); + if (print.overflowed()) { + pool->markAsOverflowed(); + data->setNull(); + return false; + } + data->setStringPointer(print.c_str(), storage_policies::store_by_copy()); + return true; +} + +#endif + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/SlotFunctions.hpp b/include/lib/ArduinoJson/Variant/SlotFunctions.hpp new file mode 100644 index 0000000..74ac5a7 --- /dev/null +++ b/include/lib/ArduinoJson/Variant/SlotFunctions.hpp @@ -0,0 +1,60 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/assert.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TAdaptedString> +inline bool slotSetKey(VariantSlot* var, TAdaptedString key, MemoryPool* pool) { + if (!var) + return false; + return slotSetKey(var, key, pool, typename TAdaptedString::storage_policy()); +} + +template <typename TAdaptedString> +inline bool slotSetKey(VariantSlot* var, TAdaptedString key, MemoryPool* pool, + storage_policies::decide_at_runtime) { + if (key.isStatic()) { + return slotSetKey(var, key, pool, storage_policies::store_by_address()); + } else { + return slotSetKey(var, key, pool, storage_policies::store_by_copy()); + } +} + +template <typename TAdaptedString> +inline bool slotSetKey(VariantSlot* var, TAdaptedString key, MemoryPool*, + storage_policies::store_by_address) { + ARDUINOJSON_ASSERT(var); + var->setKey(key.data(), storage_policies::store_by_address()); + return true; +} + +template <typename TAdaptedString> +inline bool slotSetKey(VariantSlot* var, TAdaptedString key, MemoryPool* pool, + storage_policies::store_by_copy) { + const char* dup = pool->saveString(key); + if (!dup) + return false; + ARDUINOJSON_ASSERT(var); + var->setKey(dup, storage_policies::store_by_copy()); + return true; +} + +inline size_t slotSize(const VariantSlot* var) { + size_t n = 0; + while (var) { + n++; + var = var->next(); + } + return n; +} + +inline VariantData* slotData(VariantSlot* slot) { + return reinterpret_cast<VariantData*>(slot); +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantCompare.hpp b/include/lib/ArduinoJson/Variant/VariantCompare.hpp new file mode 100644 index 0000000..025ef90 --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantCompare.hpp @@ -0,0 +1,208 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Misc/Visitable.hpp> +#include <ArduinoJson/Numbers/arithmeticCompare.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Strings/IsString.hpp> +#include <ArduinoJson/Variant/Visitor.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +class CollectionData; + +struct ComparerBase : Visitor<CompareResult> {}; + +template <typename T, typename Enable = void> +struct Comparer; + +template <typename T> +struct Comparer<T, typename enable_if<IsString<T>::value>::type> + : ComparerBase { + T rhs; + + explicit Comparer(T value) : rhs(value) {} + + CompareResult visitString(const char *lhs) { + int i = adaptString(rhs).compare(lhs); + if (i < 0) + return COMPARE_RESULT_GREATER; + else if (i > 0) + return COMPARE_RESULT_LESS; + else + return COMPARE_RESULT_EQUAL; + } + + CompareResult visitNull() { + if (adaptString(rhs).isNull()) + return COMPARE_RESULT_EQUAL; + else + return COMPARE_RESULT_DIFFER; + } +}; + +template <typename T> +struct Comparer<T, typename enable_if<is_integral<T>::value || + is_floating_point<T>::value>::type> + : ComparerBase { + T rhs; + + explicit Comparer(T value) : rhs(value) {} + + CompareResult visitFloat(Float lhs) { + return arithmeticCompare(lhs, rhs); + } + + CompareResult visitSignedInteger(Integer lhs) { + return arithmeticCompare(lhs, rhs); + } + + CompareResult visitUnsignedInteger(UInt lhs) { + return arithmeticCompare(lhs, rhs); + } + + CompareResult visitBoolean(bool lhs) { + return visitUnsignedInteger(static_cast<UInt>(lhs)); + } +}; + +struct NullComparer : ComparerBase { + CompareResult visitNull() { + return COMPARE_RESULT_EQUAL; + } +}; + +#if ARDUINOJSON_HAS_NULLPTR +template <> +struct Comparer<decltype(nullptr), void> : NullComparer { + explicit Comparer(decltype(nullptr)) : NullComparer() {} +}; +#endif + +struct ArrayComparer : ComparerBase { + const CollectionData *_rhs; + + explicit ArrayComparer(const CollectionData &rhs) : _rhs(&rhs) {} + + CompareResult visitArray(const CollectionData &lhs) { + if (lhs.equalsArray(*_rhs)) + return COMPARE_RESULT_EQUAL; + else + return COMPARE_RESULT_DIFFER; + } +}; + +struct ObjectComparer : ComparerBase { + const CollectionData *_rhs; + + explicit ObjectComparer(const CollectionData &rhs) : _rhs(&rhs) {} + + CompareResult visitObject(const CollectionData &lhs) { + if (lhs.equalsObject(*_rhs)) + return COMPARE_RESULT_EQUAL; + else + return COMPARE_RESULT_DIFFER; + } +}; + +struct RawComparer : ComparerBase { + const char *_rhsData; + size_t _rhsSize; + + explicit RawComparer(const char *rhsData, size_t rhsSize) + : _rhsData(rhsData), _rhsSize(rhsSize) {} + + CompareResult visitRawJson(const char *lhsData, size_t lhsSize) { + size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize; + int n = memcmp(lhsData, _rhsData, size); + if (n < 0) + return COMPARE_RESULT_LESS; + else if (n > 0) + return COMPARE_RESULT_GREATER; + else + return COMPARE_RESULT_EQUAL; + } +}; + +template <typename T> +struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type> + : ComparerBase { + T rhs; + + explicit Comparer(T value) : rhs(value) {} + + CompareResult visitArray(const CollectionData &lhs) { + ArrayComparer comparer(lhs); + return accept(comparer); + } + + CompareResult visitObject(const CollectionData &lhs) { + ObjectComparer comparer(lhs); + return accept(comparer); + } + + CompareResult visitFloat(Float lhs) { + Comparer<Float> comparer(lhs); + return accept(comparer); + } + + CompareResult visitString(const char *lhs) { + Comparer<const char *> comparer(lhs); + return accept(comparer); + } + + CompareResult visitRawJson(const char *lhsData, size_t lhsSize) { + RawComparer comparer(lhsData, lhsSize); + return accept(comparer); + } + + CompareResult visitSignedInteger(Integer lhs) { + Comparer<Integer> comparer(lhs); + return accept(comparer); + } + + CompareResult visitUnsignedInteger(UInt lhs) { + Comparer<UInt> comparer(lhs); + return accept(comparer); + } + + CompareResult visitBoolean(bool lhs) { + Comparer<bool> comparer(lhs); + return accept(comparer); + } + + CompareResult visitNull() { + NullComparer comparer; + return accept(comparer); + } + + private: + template <typename TComparer> + CompareResult accept(TComparer &comparer) { + CompareResult reversedResult = rhs.accept(comparer); + switch (reversedResult) { + case COMPARE_RESULT_GREATER: + return COMPARE_RESULT_LESS; + case COMPARE_RESULT_LESS: + return COMPARE_RESULT_GREATER; + default: + return reversedResult; + } + } +}; + +template <typename T1, typename T2> +CompareResult compare(const T1 &lhs, const T2 &rhs) { + Comparer<T2> comparer(rhs); + return lhs.accept(comparer); +} + +inline int variantCompare(const VariantData *a, const VariantData *b) { + return compare(VariantConstRef(a), VariantConstRef(b)); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantContent.hpp b/include/lib/ArduinoJson/Variant/VariantContent.hpp new file mode 100644 index 0000000..47bf09c --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantContent.hpp @@ -0,0 +1,59 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <stddef.h> // size_t + +#include <ArduinoJson/Collection/CollectionData.hpp> +#include <ArduinoJson/Numbers/Float.hpp> +#include <ArduinoJson/Numbers/Integer.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// +enum { + VALUE_MASK = 0x7F, + + OWNED_VALUE_BIT = 0x01, + VALUE_IS_NULL = 0, + VALUE_IS_LINKED_RAW = 0x02, + VALUE_IS_OWNED_RAW = 0x03, + VALUE_IS_LINKED_STRING = 0x04, + VALUE_IS_OWNED_STRING = 0x05, + + // CAUTION: no OWNED_VALUE_BIT below + + VALUE_IS_BOOLEAN = 0x06, + + NUMBER_BIT = 0x08, + VALUE_IS_UNSIGNED_INTEGER = 0x08, + VALUE_IS_SIGNED_INTEGER = 0x0A, + VALUE_IS_FLOAT = 0x0C, + + COLLECTION_MASK = 0x60, + VALUE_IS_OBJECT = 0x20, + VALUE_IS_ARRAY = 0x40, + + OWNED_KEY_BIT = 0x80 +}; + +struct RawData { + const char *data; + size_t size; +}; + +union VariantContent { + Float asFloat; + bool asBoolean; + UInt asUnsignedInteger; + Integer asSignedInteger; + CollectionData asCollection; + const char *asString; + struct { + const char *data; + size_t size; + } asRaw; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantData.hpp b/include/lib/ArduinoJson/Variant/VariantData.hpp new file mode 100644 index 0000000..82ae745 --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantData.hpp @@ -0,0 +1,368 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Memory/MemoryPool.hpp> +#include <ArduinoJson/Misc/SerializedValue.hpp> +#include <ArduinoJson/Numbers/convertNumber.hpp> +#include <ArduinoJson/Strings/RamStringAdapter.hpp> +#include <ArduinoJson/Variant/VariantContent.hpp> + +// VariantData can't have a constructor (to be a POD), so we have no way to fix +// this warning +#if defined(__GNUC__) +#if __GNUC__ >= 7 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#pragma GCC diagnostic ignored "-Wuninitialized" +#endif +#endif + +namespace ARDUINOJSON_NAMESPACE { + +class VariantData { + VariantContent _content; // must be first to allow cast from array to variant + uint8_t _flags; + + public: + // Must be a POD! + // - no constructor + // - no destructor + // - no virtual + // - no inheritance + void init() { + _flags = 0; + } + + template <typename TVisitor> + typename TVisitor::result_type accept(TVisitor &visitor) const { + switch (type()) { + case VALUE_IS_FLOAT: + return visitor.visitFloat(_content.asFloat); + + case VALUE_IS_ARRAY: + return visitor.visitArray(_content.asCollection); + + case VALUE_IS_OBJECT: + return visitor.visitObject(_content.asCollection); + + case VALUE_IS_LINKED_STRING: + case VALUE_IS_OWNED_STRING: + return visitor.visitString(_content.asString); + + case VALUE_IS_OWNED_RAW: + case VALUE_IS_LINKED_RAW: + return visitor.visitRawJson(_content.asRaw.data, _content.asRaw.size); + + case VALUE_IS_SIGNED_INTEGER: + return visitor.visitSignedInteger(_content.asSignedInteger); + + case VALUE_IS_UNSIGNED_INTEGER: + return visitor.visitUnsignedInteger(_content.asUnsignedInteger); + + case VALUE_IS_BOOLEAN: + return visitor.visitBoolean(_content.asBoolean != 0); + + default: + return visitor.visitNull(); + } + } + + template <typename T> + T asIntegral() const; + + template <typename T> + T asFloat() const; + + const char *asString() const; + + bool asBoolean() const; + + CollectionData *asArray() { + return isArray() ? &_content.asCollection : 0; + } + + const CollectionData *asArray() const { + return const_cast<VariantData *>(this)->asArray(); + } + + CollectionData *asObject() { + return isObject() ? &_content.asCollection : 0; + } + + const CollectionData *asObject() const { + return const_cast<VariantData *>(this)->asObject(); + } + + bool copyFrom(const VariantData &src, MemoryPool *pool) { + switch (src.type()) { + case VALUE_IS_ARRAY: + return toArray().copyFrom(src._content.asCollection, pool); + case VALUE_IS_OBJECT: + return toObject().copyFrom(src._content.asCollection, pool); + case VALUE_IS_OWNED_STRING: + return setString(RamStringAdapter(src._content.asString), pool); + case VALUE_IS_OWNED_RAW: + return setOwnedRaw( + serialized(src._content.asRaw.data, src._content.asRaw.size), pool); + default: + setType(src.type()); + _content = src._content; + return true; + } + } + + bool isArray() const { + return (_flags & VALUE_IS_ARRAY) != 0; + } + + bool isBoolean() const { + return type() == VALUE_IS_BOOLEAN; + } + + bool isCollection() const { + return (_flags & COLLECTION_MASK) != 0; + } + + template <typename T> + bool isInteger() const { + switch (type()) { + case VALUE_IS_UNSIGNED_INTEGER: + return canConvertNumber<T>(_content.asUnsignedInteger); + + case VALUE_IS_SIGNED_INTEGER: + return canConvertNumber<T>(_content.asSignedInteger); + + default: + return false; + } + } + + bool isFloat() const { + return (_flags & NUMBER_BIT) != 0; + } + + bool isString() const { + return type() == VALUE_IS_LINKED_STRING || type() == VALUE_IS_OWNED_STRING; + } + + bool isObject() const { + return (_flags & VALUE_IS_OBJECT) != 0; + } + + bool isNull() const { + return type() == VALUE_IS_NULL; + } + + bool isEnclosed() const { + return !isFloat(); + } + + void remove(size_t index) { + if (isArray()) + _content.asCollection.removeElement(index); + } + + template <typename TAdaptedString> + void remove(TAdaptedString key) { + if (isObject()) + _content.asCollection.removeMember(key); + } + + void setBoolean(bool value) { + setType(VALUE_IS_BOOLEAN); + _content.asBoolean = value; + } + + void setFloat(Float value) { + setType(VALUE_IS_FLOAT); + _content.asFloat = value; + } + + void setLinkedRaw(SerializedValue<const char *> value) { + if (value.data()) { + setType(VALUE_IS_LINKED_RAW); + _content.asRaw.data = value.data(); + _content.asRaw.size = value.size(); + } else { + setType(VALUE_IS_NULL); + } + } + + template <typename T> + bool setOwnedRaw(SerializedValue<T> value, MemoryPool *pool) { + const char *dup = pool->saveString(adaptString(value.data(), value.size())); + if (dup) { + setType(VALUE_IS_OWNED_RAW); + _content.asRaw.data = dup; + _content.asRaw.size = value.size(); + return true; + } else { + setType(VALUE_IS_NULL); + return false; + } + } + + template <typename T> + typename enable_if<is_unsigned<T>::value>::type setInteger(T value) { + setType(VALUE_IS_UNSIGNED_INTEGER); + _content.asUnsignedInteger = static_cast<UInt>(value); + } + + template <typename T> + typename enable_if<is_signed<T>::value>::type setInteger(T value) { + setType(VALUE_IS_SIGNED_INTEGER); + _content.asSignedInteger = value; + } + + void setNull() { + setType(VALUE_IS_NULL); + } + + void setStringPointer(const char *s, storage_policies::store_by_copy) { + ARDUINOJSON_ASSERT(s != 0); + setType(VALUE_IS_OWNED_STRING); + _content.asString = s; + } + + void setStringPointer(const char *s, storage_policies::store_by_address) { + ARDUINOJSON_ASSERT(s != 0); + setType(VALUE_IS_LINKED_STRING); + _content.asString = s; + } + + template <typename TAdaptedString> + bool setString(TAdaptedString value, MemoryPool *pool) { + return storeString(value, pool, typename TAdaptedString::storage_policy()); + } + + CollectionData &toArray() { + setType(VALUE_IS_ARRAY); + _content.asCollection.clear(); + return _content.asCollection; + } + + CollectionData &toObject() { + setType(VALUE_IS_OBJECT); + _content.asCollection.clear(); + return _content.asCollection; + } + + size_t memoryUsage() const { + switch (type()) { + case VALUE_IS_OWNED_STRING: + return strlen(_content.asString) + 1; + case VALUE_IS_OWNED_RAW: + return _content.asRaw.size; + case VALUE_IS_OBJECT: + case VALUE_IS_ARRAY: + return _content.asCollection.memoryUsage(); + default: + return 0; + } + } + + size_t nesting() const { + return isCollection() ? _content.asCollection.nesting() : 0; + } + + size_t size() const { + return isCollection() ? _content.asCollection.size() : 0; + } + + VariantData *addElement(MemoryPool *pool) { + if (isNull()) + toArray(); + if (!isArray()) + return 0; + return _content.asCollection.addElement(pool); + } + + VariantData *getElement(size_t index) const { + return isArray() ? _content.asCollection.getElement(index) : 0; + } + + VariantData *getOrAddElement(size_t index, MemoryPool *pool) { + if (isNull()) + toArray(); + if (!isArray()) + return 0; + return _content.asCollection.getOrAddElement(index, pool); + } + + template <typename TAdaptedString> + VariantData *getMember(TAdaptedString key) const { + return isObject() ? _content.asCollection.getMember(key) : 0; + } + + template <typename TAdaptedString> + VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool) { + if (isNull()) + toObject(); + if (!isObject()) + return 0; + return _content.asCollection.getOrAddMember(key, pool); + } + + void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance) { + if (_flags & OWNED_VALUE_BIT) + _content.asString += stringDistance; + if (_flags & COLLECTION_MASK) + _content.asCollection.movePointers(stringDistance, variantDistance); + } + + uint8_t type() const { + return _flags & VALUE_MASK; + } + + private: + void setType(uint8_t t) { + _flags &= OWNED_KEY_BIT; + _flags |= t; + } + + template <typename TAdaptedString> + inline bool storeString(TAdaptedString value, MemoryPool *pool, + storage_policies::decide_at_runtime) { + if (value.isStatic()) + return storeString(value, pool, storage_policies::store_by_address()); + else + return storeString(value, pool, storage_policies::store_by_copy()); + } + + template <typename TAdaptedString> + inline bool storeString(TAdaptedString value, MemoryPool *, + storage_policies::store_by_address) { + if (value.isNull()) + setNull(); + else + setStringPointer(value.data(), storage_policies::store_by_address()); + return true; + } + + template <typename TAdaptedString> + inline bool storeString(TAdaptedString value, MemoryPool *pool, + storage_policies::store_by_copy) { + if (value.isNull()) { + setNull(); + return true; + } + const char *copy = pool->saveString(value); + if (!copy) { + setNull(); + return false; + } + setStringPointer(copy, storage_policies::store_by_copy()); + return true; + } +}; + +} // namespace ARDUINOJSON_NAMESPACE + +#if defined(__GNUC__) +#if __GNUC__ >= 8 +#pragma GCC diagnostic pop +#endif +#endif diff --git a/include/lib/ArduinoJson/Variant/VariantFunctions.hpp b/include/lib/ArduinoJson/Variant/VariantFunctions.hpp new file mode 100644 index 0000000..3fc9cbb --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantFunctions.hpp @@ -0,0 +1,104 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/attributes.hpp> +#include <ArduinoJson/Variant/VariantData.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TVisitor> +inline typename TVisitor::result_type variantAccept(const VariantData *var, + TVisitor &visitor) { + if (var != 0) + return var->accept(visitor); + else + return visitor.visitNull(); +} + +inline const CollectionData *variantAsArray(const VariantData *var) { + return var != 0 ? var->asArray() : 0; +} + +inline const CollectionData *variantAsObject(const VariantData *var) { + return var != 0 ? var->asObject() : 0; +} + +inline CollectionData *variantAsObject(VariantData *var) { + return var != 0 ? var->asObject() : 0; +} + +inline bool variantCopyFrom(VariantData *dst, const VariantData *src, + MemoryPool *pool) { + if (!dst) + return false; + if (!src) { + dst->setNull(); + return true; + } + return dst->copyFrom(*src, pool); +} + +inline int variantCompare(const VariantData *a, const VariantData *b); + +inline void variantSetNull(VariantData *var) { + if (!var) + return; + var->setNull(); +} + +template <typename TAdaptedString> +inline bool variantSetString(VariantData *var, TAdaptedString value, + MemoryPool *pool) { + if (!var) + return false; + return var->setString(value, pool); +} + +inline size_t variantSize(const VariantData *var) { + return var != 0 ? var->size() : 0; +} + +inline CollectionData *variantToArray(VariantData *var) { + if (!var) + return 0; + return &var->toArray(); +} + +inline CollectionData *variantToObject(VariantData *var) { + if (!var) + return 0; + return &var->toObject(); +} + +inline NO_INLINE VariantData *variantAddElement(VariantData *var, + MemoryPool *pool) { + return var != 0 ? var->addElement(pool) : 0; +} + +inline NO_INLINE VariantData *variantGetOrAddElement(VariantData *var, + size_t index, + MemoryPool *pool) { + return var != 0 ? var->getOrAddElement(index, pool) : 0; +} + +template <typename TChar> +NO_INLINE VariantData *variantGetOrAddMember(VariantData *var, TChar *key, + MemoryPool *pool) { + return var != 0 ? var->getOrAddMember(adaptString(key), pool) : 0; +} + +template <typename TString> +NO_INLINE VariantData *variantGetOrAddMember(VariantData *var, + const TString &key, + MemoryPool *pool) { + return var != 0 ? var->getOrAddMember(adaptString(key), pool) : 0; +} + +inline bool variantIsNull(const VariantData *var) { + return var == 0 || var->isNull(); +} + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantImpl.hpp b/include/lib/ArduinoJson/Variant/VariantImpl.hpp new file mode 100644 index 0000000..b91e584 --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantImpl.hpp @@ -0,0 +1,143 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Array/ArrayRef.hpp> +#include <ArduinoJson/Configuration.hpp> +#include <ArduinoJson/Numbers/convertNumber.hpp> +#include <ArduinoJson/Numbers/parseNumber.hpp> +#include <ArduinoJson/Object/ObjectRef.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> + +#include <string.h> // for strcmp + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T> +inline T VariantData::asIntegral() const { + switch (type()) { + case VALUE_IS_BOOLEAN: + return _content.asBoolean; + case VALUE_IS_UNSIGNED_INTEGER: + return convertNumber<T>(_content.asUnsignedInteger); + case VALUE_IS_SIGNED_INTEGER: + return convertNumber<T>(_content.asSignedInteger); + case VALUE_IS_LINKED_STRING: + case VALUE_IS_OWNED_STRING: + return parseNumber<T>(_content.asString); + case VALUE_IS_FLOAT: + return convertNumber<T>(_content.asFloat); + default: + return 0; + } +} + +inline bool VariantData::asBoolean() const { + switch (type()) { + case VALUE_IS_BOOLEAN: + return _content.asBoolean; + case VALUE_IS_SIGNED_INTEGER: + case VALUE_IS_UNSIGNED_INTEGER: + return _content.asUnsignedInteger != 0; + case VALUE_IS_FLOAT: + return _content.asFloat != 0; + case VALUE_IS_NULL: + return false; + default: + return true; + } +} + +// T = float/double +template <typename T> +inline T VariantData::asFloat() const { + switch (type()) { + case VALUE_IS_BOOLEAN: + return static_cast<T>(_content.asBoolean); + case VALUE_IS_UNSIGNED_INTEGER: + return static_cast<T>(_content.asUnsignedInteger); + case VALUE_IS_SIGNED_INTEGER: + return static_cast<T>(_content.asSignedInteger); + case VALUE_IS_LINKED_STRING: + case VALUE_IS_OWNED_STRING: + return parseNumber<T>(_content.asString); + case VALUE_IS_FLOAT: + return static_cast<T>(_content.asFloat); + default: + return 0; + } +} + +inline const char *VariantData::asString() const { + switch (type()) { + case VALUE_IS_LINKED_STRING: + case VALUE_IS_OWNED_STRING: + return _content.asString; + default: + return 0; + } +} + +template <typename T> +inline typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type +VariantRef::to() const { + return ArrayRef(_pool, variantToArray(_data)); +} + +template <typename T> +typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type +VariantRef::to() const { + return ObjectRef(_pool, variantToObject(_data)); +} + +template <typename T> +typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type +VariantRef::to() const { + variantSetNull(_data); + return *this; +} + +inline VariantConstRef VariantConstRef::getElement(size_t index) const { + return ArrayConstRef(_data != 0 ? _data->asArray() : 0)[index]; +} + +inline VariantRef VariantRef::addElement() const { + return VariantRef(_pool, variantAddElement(_data, _pool)); +} + +inline VariantRef VariantRef::getElement(size_t index) const { + return VariantRef(_pool, _data != 0 ? _data->getElement(index) : 0); +} + +inline VariantRef VariantRef::getOrAddElement(size_t index) const { + return VariantRef(_pool, variantGetOrAddElement(_data, index, _pool)); +} + +template <typename TChar> +inline VariantRef VariantRef::getMember(TChar *key) const { + return VariantRef(_pool, _data != 0 ? _data->getMember(adaptString(key)) : 0); +} + +template <typename TString> +inline typename enable_if<IsString<TString>::value, VariantRef>::type +VariantRef::getMember(const TString &key) const { + return VariantRef(_pool, _data != 0 ? _data->getMember(adaptString(key)) : 0); +} + +template <typename TChar> +inline VariantRef VariantRef::getOrAddMember(TChar *key) const { + return VariantRef(_pool, variantGetOrAddMember(_data, key, _pool)); +} + +template <typename TString> +inline VariantRef VariantRef::getOrAddMember(const TString &key) const { + return VariantRef(_pool, variantGetOrAddMember(_data, key, _pool)); +} + +inline VariantConstRef operator|(VariantConstRef preferedValue, + VariantConstRef defaultValue) { + return preferedValue ? preferedValue : defaultValue; +} +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantOperators.hpp b/include/lib/ArduinoJson/Variant/VariantOperators.hpp new file mode 100644 index 0000000..54174a4 --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantOperators.hpp @@ -0,0 +1,180 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Misc/Visitable.hpp> +#include <ArduinoJson/Numbers/arithmeticCompare.hpp> +#include <ArduinoJson/Polyfills/attributes.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Variant/VariantTag.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename T1, typename T2> +CompareResult compare(const T1 &lhs, const T2 &rhs); // VariantCompare.cpp + +template <typename TVariant> +struct VariantOperators { + // Returns the default value if the VariantRef is undefined or incompatible + // + // int operator|(JsonVariant, int) + // float operator|(JsonVariant, float) + // bool operator|(JsonVariant, bool) + template <typename T> + friend + typename enable_if<!IsVariant<T>::value && !is_array<T>::value, T>::type + operator|(const TVariant &variant, const T &defaultValue) { + if (variant.template is<T>()) + return variant.template as<T>(); + else + return defaultValue; + } + // + // const char* operator|(JsonVariant, const char*) + friend const char *operator|(const TVariant &variant, + const char *defaultValue) { + if (variant.template is<const char *>()) + return variant.template as<const char *>(); + else + return defaultValue; + } + // + // JsonVariant operator|(JsonVariant, JsonVariant) + template <typename T> + friend typename enable_if<IsVariant<T>::value, typename T::variant_type>::type + operator|(const TVariant &variant, T defaultValue) { + if (variant) + return variant; + else + return defaultValue; + } + + // value == TVariant + template <typename T> + friend bool operator==(T *lhs, TVariant rhs) { + return compare(rhs, lhs) == COMPARE_RESULT_EQUAL; + } + template <typename T> + friend bool operator==(const T &lhs, TVariant rhs) { + return compare(rhs, lhs) == COMPARE_RESULT_EQUAL; + } + + // TVariant == value + template <typename T> + friend bool operator==(TVariant lhs, T *rhs) { + return compare(lhs, rhs) == COMPARE_RESULT_EQUAL; + } + template <typename T> + friend typename enable_if<!IsVisitable<T>::value, bool>::type operator==( + TVariant lhs, const T &rhs) { + return compare(lhs, rhs) == COMPARE_RESULT_EQUAL; + } + + // value != TVariant + template <typename T> + friend bool operator!=(T *lhs, TVariant rhs) { + return compare(rhs, lhs) != COMPARE_RESULT_EQUAL; + } + template <typename T> + friend bool operator!=(const T &lhs, TVariant rhs) { + return compare(rhs, lhs) != COMPARE_RESULT_EQUAL; + } + + // TVariant != value + template <typename T> + friend bool operator!=(TVariant lhs, T *rhs) { + return compare(lhs, rhs) != COMPARE_RESULT_EQUAL; + } + template <typename T> + friend typename enable_if<!IsVisitable<T>::value, bool>::type operator!=( + TVariant lhs, const T &rhs) { + return compare(lhs, rhs) != COMPARE_RESULT_EQUAL; + } + + // value < TVariant + template <typename T> + friend bool operator<(T *lhs, TVariant rhs) { + return compare(rhs, lhs) == COMPARE_RESULT_GREATER; + } + template <typename T> + friend bool operator<(const T &lhs, TVariant rhs) { + return compare(rhs, lhs) == COMPARE_RESULT_GREATER; + } + + // TVariant < value + template <typename T> + friend bool operator<(TVariant lhs, T *rhs) { + return compare(lhs, rhs) == COMPARE_RESULT_LESS; + } + template <typename T> + friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<( + TVariant lhs, const T &rhs) { + return compare(lhs, rhs) == COMPARE_RESULT_LESS; + } + + // value <= TVariant + template <typename T> + friend bool operator<=(T *lhs, TVariant rhs) { + return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0; + } + template <typename T> + friend bool operator<=(const T &lhs, TVariant rhs) { + return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0; + } + + // TVariant <= value + template <typename T> + friend bool operator<=(TVariant lhs, T *rhs) { + return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0; + } + template <typename T> + friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<=( + TVariant lhs, const T &rhs) { + return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0; + } + + // value > TVariant + template <typename T> + friend bool operator>(T *lhs, TVariant rhs) { + return compare(rhs, lhs) == COMPARE_RESULT_LESS; + } + template <typename T> + friend bool operator>(const T &lhs, TVariant rhs) { + return compare(rhs, lhs) == COMPARE_RESULT_LESS; + } + + // TVariant > value + template <typename T> + friend bool operator>(TVariant lhs, T *rhs) { + return compare(lhs, rhs) == COMPARE_RESULT_GREATER; + } + template <typename T> + friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>( + TVariant lhs, const T &rhs) { + return compare(lhs, rhs) == COMPARE_RESULT_GREATER; + } + + // value >= TVariant + template <typename T> + friend bool operator>=(T *lhs, TVariant rhs) { + return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0; + } + template <typename T> + friend bool operator>=(const T &lhs, TVariant rhs) { + return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0; + } + + // TVariant >= value + template <typename T> + friend bool operator>=(TVariant lhs, T *rhs) { + return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0; + } + template <typename T> + friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>=( + TVariant lhs, const T &rhs) { + return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0; + } +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantRef.hpp b/include/lib/ArduinoJson/Variant/VariantRef.hpp new file mode 100644 index 0000000..8d4c410 --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantRef.hpp @@ -0,0 +1,375 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <stddef.h> +#include <stdint.h> // for uint8_t + +#include <ArduinoJson/Memory/MemoryPool.hpp> +#include <ArduinoJson/Misc/Visitable.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Strings/StringAdapters.hpp> +#include <ArduinoJson/Variant/Converter.hpp> +#include <ArduinoJson/Variant/VariantFunctions.hpp> +#include <ArduinoJson/Variant/VariantOperators.hpp> +#include <ArduinoJson/Variant/VariantRef.hpp> +#include <ArduinoJson/Variant/VariantShortcuts.hpp> +#include <ArduinoJson/Variant/VariantTag.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +// Forward declarations. +class ArrayRef; +class ObjectRef; + +// Contains the methods shared by VariantRef and VariantConstRef +template <typename TData> +class VariantRefBase : public VariantTag { + public: + FORCE_INLINE bool isNull() const { + return variantIsNull(_data); + } + + FORCE_INLINE bool isUndefined() const { + return !_data; + } + + FORCE_INLINE size_t memoryUsage() const { + return _data ? _data->memoryUsage() : 0; + } + + FORCE_INLINE size_t nesting() const { + return _data ? _data->nesting() : 0; + } + + size_t size() const { + return variantSize(_data); + } + + protected: + VariantRefBase(TData *data) : _data(data) {} + TData *_data; + + friend TData *getData(const VariantRefBase &variant) { + return variant._data; + } +}; + +// A variant that can be a any value serializable to a JSON value. +// +// It can be set to: +// - a boolean +// - a char, short, int or a long (signed or unsigned) +// - a string (const char*) +// - a reference to a ArrayRef or ObjectRef +class VariantRef : public VariantRefBase<VariantData>, + public VariantOperators<VariantRef>, + public VariantShortcuts<VariantRef>, + public Visitable { + typedef VariantRefBase<VariantData> base_type; + friend class VariantConstRef; + + public: + // Intenal use only + FORCE_INLINE VariantRef(MemoryPool *pool, VariantData *data) + : base_type(data), _pool(pool) {} + + // Creates an uninitialized VariantRef + FORCE_INLINE VariantRef() : base_type(0), _pool(0) {} + + FORCE_INLINE void clear() const { + return variantSetNull(_data); + } + + template <typename T> + FORCE_INLINE bool set(const T &value) const { + return Converter<T>::toJson(value, *this); + } + + FORCE_INLINE bool ARDUINOJSON_DEPRECATED( + "Support for char is deprecated, use int8_t or uint8_t instead") + set(char value) const { + return set<signed char>(value); + } + + template <typename T> + FORCE_INLINE bool set(T *value) const { + return Converter<T *>::toJson(value, *this); + } + + template <typename T> + FORCE_INLINE + typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value, + T>::type + as() const { + return Converter<T>::fromJson(*this); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type + ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()") + as() const { + return as<const char *>(); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type + ARDUINOJSON_DEPRECATED( + "Support for char is deprecated, use int8_t or uint8_t instead") + as() const { + return as<signed char>(); + } + + template <typename T> + FORCE_INLINE + typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value, + bool>::type + is() const { + return Converter<T>::checkJson(*this); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type + ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()") + is() const { + return is<const char *>(); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type + ARDUINOJSON_DEPRECATED( + "Support for char is deprecated, use int8_t or uint8_t instead") + is() const { + return is<signed char>(); + } + + template <typename T> + FORCE_INLINE operator T() const { + return as<T>(); + } + + template <typename TVisitor> + typename TVisitor::result_type accept(TVisitor &visitor) const { + return variantAccept(_data, visitor); + } + + // Change the type of the variant + // + // ArrayRef to<ArrayRef>() + template <typename T> + typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type to() const; + // + // ObjectRef to<ObjectRef>() + template <typename T> + typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type to() const; + // + // ObjectRef to<VariantRef>() + template <typename T> + typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type to() + const; + + VariantRef addElement() const; + + FORCE_INLINE VariantRef getElement(size_t) const; + + FORCE_INLINE VariantRef getOrAddElement(size_t) const; + + // getMember(const char*) const + // getMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantRef getMember(TChar *) const; + + // getMember(const std::string&) const + // getMember(const String&) const + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value, VariantRef>::type + getMember(const TString &) const; + + // getOrAddMember(char*) const + // getOrAddMember(const char*) const + // getOrAddMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantRef getOrAddMember(TChar *) const; + + // getOrAddMember(const std::string&) const + // getOrAddMember(const String&) const + template <typename TString> + FORCE_INLINE VariantRef getOrAddMember(const TString &) const; + + FORCE_INLINE void remove(size_t index) const { + if (_data) + _data->remove(index); + } + // remove(char*) const + // remove(const char*) const + // remove(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove( + TChar *key) const { + if (_data) + _data->remove(adaptString(key)); + } + // remove(const std::string&) const + // remove(const String&) const + template <typename TString> + FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove( + const TString &key) const { + if (_data) + _data->remove(adaptString(key)); + } + + private: + MemoryPool *_pool; + + friend MemoryPool *getPool(const VariantRef &variant) { + return variant._pool; + } +}; + +class VariantConstRef : public VariantRefBase<const VariantData>, + public VariantOperators<VariantConstRef>, + public VariantShortcuts<VariantConstRef>, + public Visitable { + typedef VariantRefBase<const VariantData> base_type; + friend class VariantRef; + + public: + VariantConstRef() : base_type(0) {} + VariantConstRef(const VariantData *data) : base_type(data) {} + VariantConstRef(VariantRef var) : base_type(var._data) {} + + template <typename TVisitor> + typename TVisitor::result_type accept(TVisitor &visitor) const { + return variantAccept(_data, visitor); + } + + template <typename T> + FORCE_INLINE + typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value, + T>::type + as() const { + return Converter<T>::fromJson(*this); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type + ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()") + as() const { + return as<const char *>(); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type + ARDUINOJSON_DEPRECATED( + "Support for char is deprecated, use int8_t or uint8_t instead") + as() const { + return as<signed char>(); + } + + template <typename T> + FORCE_INLINE + typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value, + bool>::type + is() const { + return Converter<T>::checkJson(*this); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type + ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()") + is() const { + return is<const char *>(); + } + + template <typename T> + FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type + ARDUINOJSON_DEPRECATED( + "Support for char is deprecated, use int8_t or uint8_t instead") + is() const { + return is<signed char>(); + } + + template <typename T> + FORCE_INLINE operator T() const { + return as<T>(); + } + + FORCE_INLINE VariantConstRef getElement(size_t) const; + + FORCE_INLINE VariantConstRef operator[](size_t index) const { + return getElement(index); + } + + // getMember(const std::string&) const + // getMember(const String&) const + template <typename TString> + FORCE_INLINE VariantConstRef getMember(const TString &key) const { + return VariantConstRef( + objectGetMember(variantAsObject(_data), adaptString(key))); + } + + // getMember(char*) const + // getMember(const char*) const + // getMember(const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE VariantConstRef getMember(TChar *key) const { + const CollectionData *obj = variantAsObject(_data); + return VariantConstRef(obj ? obj->getMember(adaptString(key)) : 0); + } + + // operator[](const std::string&) const + // operator[](const String&) const + template <typename TString> + FORCE_INLINE + typename enable_if<IsString<TString>::value, VariantConstRef>::type + operator[](const TString &key) const { + return getMember(key); + } + + // operator[](char*) const + // operator[](const char*) const + // operator[](const __FlashStringHelper*) const + template <typename TChar> + FORCE_INLINE + typename enable_if<IsString<TChar *>::value, VariantConstRef>::type + operator[](TChar *key) const { + return getMember(key); + } +}; + +template <> +struct Converter<VariantRef> { + static bool toJson(VariantRef src, VariantRef dst) { + return variantCopyFrom(getData(dst), getData(src), getPool(dst)); + } + static VariantRef fromJson(VariantRef src) { + return src; + } + static bool checkJson(VariantRef src) { + VariantData *data = getData(src); + return !!data; + } + static bool checkJson(VariantConstRef) { + return false; + } +}; + +template <> +struct Converter<VariantConstRef> { + static bool toJson(VariantConstRef src, VariantRef dst) { + return variantCopyFrom(getData(dst), getData(src), getPool(dst)); + } + + static VariantConstRef fromJson(VariantConstRef src) { + return VariantConstRef(getData(src)); + } + + static bool checkJson(VariantConstRef src) { + const VariantData *data = getData(src); + return !!data; + } +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantShortcuts.hpp b/include/lib/ArduinoJson/Variant/VariantShortcuts.hpp new file mode 100644 index 0000000..e62847f --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantShortcuts.hpp @@ -0,0 +1,23 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Array/ArrayShortcuts.hpp> +#include <ArduinoJson/Object/ObjectShortcuts.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TVariant> +class VariantShortcuts : public ObjectShortcuts<TVariant>, + public ArrayShortcuts<TVariant> { + public: + using ArrayShortcuts<TVariant>::createNestedArray; + using ArrayShortcuts<TVariant>::createNestedObject; + using ArrayShortcuts<TVariant>::operator[]; + using ObjectShortcuts<TVariant>::createNestedArray; + using ObjectShortcuts<TVariant>::createNestedObject; + using ObjectShortcuts<TVariant>::operator[]; +}; +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantSlot.hpp b/include/lib/ArduinoJson/Variant/VariantSlot.hpp new file mode 100644 index 0000000..a271c1e --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantSlot.hpp @@ -0,0 +1,116 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Polyfills/integer.hpp> +#include <ArduinoJson/Polyfills/limits.hpp> +#include <ArduinoJson/Polyfills/type_traits.hpp> +#include <ArduinoJson/Strings/StoragePolicy.hpp> +#include <ArduinoJson/Variant/VariantContent.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +typedef int_t<ARDUINOJSON_SLOT_OFFSET_SIZE * 8>::type VariantSlotDiff; + +class VariantSlot { + // CAUTION: same layout as VariantData + // we cannot use composition because it adds padding + // (+20% on ESP8266 for example) + VariantContent _content; + uint8_t _flags; + VariantSlotDiff _next; + const char* _key; + + public: + // Must be a POD! + // - no constructor + // - no destructor + // - no virtual + // - no inheritance + + VariantData* data() { + return reinterpret_cast<VariantData*>(&_content); + } + + const VariantData* data() const { + return reinterpret_cast<const VariantData*>(&_content); + } + + VariantSlot* next() { + return _next ? this + _next : 0; + } + + const VariantSlot* next() const { + return const_cast<VariantSlot*>(this)->next(); + } + + VariantSlot* next(size_t distance) { + VariantSlot* slot = this; + while (distance--) { + if (!slot->_next) + return 0; + slot += slot->_next; + } + return slot; + } + + const VariantSlot* next(size_t distance) const { + return const_cast<VariantSlot*>(this)->next(distance); + } + + void setNext(VariantSlot* slot) { + ARDUINOJSON_ASSERT(!slot || slot - this >= + numeric_limits<VariantSlotDiff>::lowest()); + ARDUINOJSON_ASSERT(!slot || slot - this <= + numeric_limits<VariantSlotDiff>::highest()); + _next = VariantSlotDiff(slot ? slot - this : 0); + } + + void setNextNotNull(VariantSlot* slot) { + ARDUINOJSON_ASSERT(slot != 0); + ARDUINOJSON_ASSERT(slot - this >= + numeric_limits<VariantSlotDiff>::lowest()); + ARDUINOJSON_ASSERT(slot - this <= + numeric_limits<VariantSlotDiff>::highest()); + _next = VariantSlotDiff(slot - this); + } + + void setKey(const char* k, storage_policies::store_by_copy) { + ARDUINOJSON_ASSERT(k != NULL); + _flags |= OWNED_KEY_BIT; + _key = k; + } + + void setKey(const char* k, storage_policies::store_by_address) { + ARDUINOJSON_ASSERT(k != NULL); + _flags &= VALUE_MASK; + _key = k; + } + + const char* key() const { + return _key; + } + + bool ownsKey() const { + return (_flags & OWNED_KEY_BIT) != 0; + } + + void clear() { + _next = 0; + _flags = 0; + _key = 0; + } + + void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance) { + if (_flags & OWNED_KEY_BIT) + _key += stringDistance; + if (_flags & OWNED_VALUE_BIT) + _content.asString += stringDistance; + if (_flags & COLLECTION_MASK) + _content.asCollection.movePointers(stringDistance, variantDistance); + } +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantTag.hpp b/include/lib/ArduinoJson/Variant/VariantTag.hpp new file mode 100644 index 0000000..7164164 --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantTag.hpp @@ -0,0 +1,16 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +struct VariantTag {}; + +template <typename T> +struct IsVariant : is_base_of<VariantTag, T> {}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/VariantTo.hpp b/include/lib/ArduinoJson/Variant/VariantTo.hpp new file mode 100644 index 0000000..352ecba --- /dev/null +++ b/include/lib/ArduinoJson/Variant/VariantTo.hpp @@ -0,0 +1,32 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Namespace.hpp> + +namespace ARDUINOJSON_NAMESPACE { +class ArrayRef; +class ObjectRef; +class VariantRef; + +// A metafunction that returns the type of the value returned by +// VariantRef::to<T>() +template <typename T> +struct VariantTo {}; + +template <> +struct VariantTo<ArrayRef> { + typedef ArrayRef type; +}; +template <> +struct VariantTo<ObjectRef> { + typedef ObjectRef type; +}; +template <> +struct VariantTo<VariantRef> { + typedef VariantRef type; +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/Variant/Visitor.hpp b/include/lib/ArduinoJson/Variant/Visitor.hpp new file mode 100644 index 0000000..33237dd --- /dev/null +++ b/include/lib/ArduinoJson/Variant/Visitor.hpp @@ -0,0 +1,54 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#include <ArduinoJson/Collection/CollectionData.hpp> +#include <ArduinoJson/Numbers/Float.hpp> +#include <ArduinoJson/Numbers/Integer.hpp> + +namespace ARDUINOJSON_NAMESPACE { + +template <typename TResult> +struct Visitor { + typedef TResult result_type; + + TResult visitArray(const CollectionData &) { + return TResult(); + } + + TResult visitBoolean(bool) { + return TResult(); + } + + TResult visitFloat(Float) { + return TResult(); + } + + TResult visitSignedInteger(Integer) { + return TResult(); + } + + TResult visitNull() { + return TResult(); + } + + TResult visitObject(const CollectionData &) { + return TResult(); + } + + TResult visitUnsignedInteger(UInt) { + return TResult(); + } + + TResult visitRawJson(const char *, size_t) { + return TResult(); + } + + TResult visitString(const char *) { + return TResult(); + } +}; + +} // namespace ARDUINOJSON_NAMESPACE diff --git a/include/lib/ArduinoJson/compatibility.hpp b/include/lib/ArduinoJson/compatibility.hpp new file mode 100644 index 0000000..cca477e --- /dev/null +++ b/include/lib/ArduinoJson/compatibility.hpp @@ -0,0 +1,23 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License +// +// clang-format off + +#ifdef __GNUC__ + +#define ARDUINOJSON_PRAGMA(x) _Pragma(#x) + +#define ARDUINOJSON_COMPILE_ERROR(msg) ARDUINOJSON_PRAGMA(GCC error msg) + +#define ARDUINOJSON_STRINGIFY(S) #S + +#define ARDUINOJSON_DEPRECATION_ERROR(X, Y) \ + ARDUINOJSON_COMPILE_ERROR(ARDUINOJSON_STRINGIFY(X is a Y from ArduinoJson 5. Please see https:/\/arduinojson.org/upgrade to learn how to upgrade your program to ArduinoJson version 6)) + +#define StaticJsonBuffer ARDUINOJSON_DEPRECATION_ERROR(StaticJsonBuffer, class) +#define DynamicJsonBuffer ARDUINOJSON_DEPRECATION_ERROR(DynamicJsonBuffer, class) +#define JsonBuffer ARDUINOJSON_DEPRECATION_ERROR(JsonBuffer, class) +#define RawJson ARDUINOJSON_DEPRECATION_ERROR(RawJson, function) + +#endif diff --git a/include/lib/ArduinoJson/version.hpp b/include/lib/ArduinoJson/version.hpp new file mode 100644 index 0000000..d8aaf77 --- /dev/null +++ b/include/lib/ArduinoJson/version.hpp @@ -0,0 +1,10 @@ +// ArduinoJson - https://arduinojson.org +// Copyright Benoit Blanchon 2014-2021 +// MIT License + +#pragma once + +#define ARDUINOJSON_VERSION "6.18.0" +#define ARDUINOJSON_VERSION_MAJOR 6 +#define ARDUINOJSON_VERSION_MINOR 18 +#define ARDUINOJSON_VERSION_REVISION 0 |