@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Variant/VariantImpl.hpp

@@ -0,0 +1,146 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+inline void VariantData::setRawString(SerializedValue<T> value,
+                                      ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  auto dup = resources->saveString(adaptString(value.data(), value.size()));
+  if (dup)
+    setRawString(dup);
+}
+
+template <typename TAdaptedString>
+inline bool VariantData::setString(TAdaptedString value,
+                                   ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+
+  if (value.isNull())
+    return false;
+
+  if (value.isStatic()) {
+    setLinkedString(value.data());
+    return true;
+  }
+
+  if (isTinyString(value, value.size())) {
+    setTinyString(value);
+    return true;
+  }
+
+  auto dup = resources->saveString(value);
+  if (dup) {
+    setOwnedString(dup);
+    return true;
+  }
+
+  return false;
+}
+
+inline void VariantData::clear(ResourceManager* resources) {
+  if (type_ & VariantTypeBits::OwnedStringBit)
+    resources->dereferenceString(content_.asOwnedString->data);
+
+#if ARDUINOJSON_USE_EXTENSIONS
+  if (type_ & VariantTypeBits::ExtensionBit)
+    resources->freeExtension(content_.asSlotId);
+#endif
+
+  auto collection = asCollection();
+  if (collection)
+    collection->clear(resources);
+
+  type_ = VariantType::Null;
+}
+
+#if ARDUINOJSON_USE_EXTENSIONS
+inline const VariantExtension* VariantData::getExtension(
+    const ResourceManager* resources) const {
+  return type_ & VariantTypeBits::ExtensionBit
+             ? resources->getExtension(content_.asSlotId)
+             : nullptr;
+}
+#endif
+
+template <typename T>
+enable_if_t<sizeof(T) == 8, bool> VariantData::setFloat(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  float valueAsFloat = static_cast<float>(value);
+
+#if ARDUINOJSON_USE_DOUBLE
+  if (value == valueAsFloat) {
+    type_ = VariantType::Float;
+    content_.asFloat = valueAsFloat;
+  } else {
+    auto extension = resources->allocExtension();
+    if (!extension)
+      return false;
+    type_ = VariantType::Double;
+    content_.asSlotId = extension.id();
+    extension->asDouble = value;
+  }
+#else
+  type_ = VariantType::Float;
+  content_.asFloat = valueAsFloat;
+#endif
+  return true;
+}
+
+template <typename T>
+enable_if_t<is_signed<T>::value, bool> VariantData::setInteger(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  if (canConvertNumber<int32_t>(value)) {
+    type_ = VariantType::Int32;
+    content_.asInt32 = static_cast<int32_t>(value);
+  }
+#if ARDUINOJSON_USE_LONG_LONG
+  else {
+    auto extension = resources->allocExtension();
+    if (!extension)
+      return false;
+    type_ = VariantType::Int64;
+    content_.asSlotId = extension.id();
+    extension->asInt64 = value;
+  }
+#endif
+  return true;
+}
+
+template <typename T>
+enable_if_t<is_unsigned<T>::value, bool> VariantData::setInteger(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  if (canConvertNumber<uint32_t>(value)) {
+    type_ = VariantType::Uint32;
+    content_.asUint32 = static_cast<uint32_t>(value);
+  }
+#if ARDUINOJSON_USE_LONG_LONG
+  else {
+    auto extension = resources->allocExtension();
+    if (!extension)
+      return false;
+    type_ = VariantType::Uint64;
+    content_.asSlotId = extension.id();
+    extension->asUint64 = value;
+  }
+#endif
+  return true;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Variant/VariantOperators.hpp

@@ -0,0 +1,188 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Numbers/arithmeticCompare.hpp>
+#include <ArduinoJson/Polyfills/attributes.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Variant/VariantTag.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class JsonVariantConst;
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+CompareResult compare(JsonVariantConst lhs,
+                      const T& rhs);  // VariantCompare.cpp
+
+struct VariantOperatorTag {};
+
+template <typename TVariant>
+struct VariantOperators : VariantOperatorTag {
+  // Returns the default value if the JsonVariant is unbound or incompatible
+  //
+  // int operator|(JsonVariant, int)
+  // float operator|(JsonVariant, float)
+  // bool operator|(JsonVariant, bool)
+  template <typename T,
+            enable_if_t<!IsVariant<T>::value && !is_array<T>::value, int> = 0>
+  friend T 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 enable_if_t<IsVariant<T>::value, JsonVariantConst> operator|(
+      const TVariant& variant, const T& defaultValue) {
+    if (variant)
+      return variant;
+    else
+      return defaultValue;
+  }
+
+  // value == TVariant
+  template <typename T>
+  friend bool operator==(T* lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
+  }
+  template <typename T>
+  friend bool operator==(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
+  }
+
+  // TVariant == value
+  template <typename T>
+  friend bool operator==(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator==(const TVariant& lhs, const T& rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
+  }
+
+  // value != TVariant
+  template <typename T>
+  friend bool operator!=(T* lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
+  }
+  template <typename T>
+  friend bool operator!=(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
+  }
+
+  // TVariant != value
+  template <typename T>
+  friend bool operator!=(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator!=(TVariant lhs, const T& rhs) {
+    return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
+  }
+
+  // value < TVariant
+  template <typename T>
+  friend bool operator<(T* lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
+  }
+  template <typename T>
+  friend bool operator<(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
+  }
+
+  // TVariant < value
+  template <typename T>
+  friend bool operator<(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_LESS;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator<(TVariant lhs, const T& rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_LESS;
+  }
+
+  // value <= TVariant
+  template <typename T>
+  friend bool operator<=(T* lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+  template <typename T>
+  friend bool operator<=(const T& lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+
+  // TVariant <= value
+  template <typename T>
+  friend bool operator<=(const TVariant& lhs, T* rhs) {
+    return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool 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, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_LESS;
+  }
+  template <typename T>
+  friend bool operator>(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_LESS;
+  }
+
+  // TVariant > value
+  template <typename T>
+  friend bool operator>(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator>(TVariant lhs, const T& rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
+  }
+
+  // value >= TVariant
+  template <typename T>
+  friend bool operator>=(T* lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
+  }
+  template <typename T>
+  friend bool operator>=(const T& lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
+  }
+
+  // TVariant >= value
+  template <typename T>
+  friend bool operator>=(const TVariant& lhs, T* rhs) {
+    return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator>=(const TVariant& lhs, const T& rhs) {
+    return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Variant/VariantRefBase.hpp

@@ -0,0 +1,313 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Variant/Converter.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+#include <ArduinoJson/Variant/VariantOperators.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+class JsonVariant;
+ARDUINOJSON_END_PUBLIC_NAMESPACE
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+template <typename>
+class ElementProxy;
+
+template <typename, typename>
+class MemberProxy;
+
+template <typename TDerived>
+class VariantRefBase : public VariantTag {
+  friend class VariantAttorney;
+
+ public:
+  // Sets the value to null.
+  // https://arduinojson.org/v7/api/jsonvariant/clear/
+  void clear() const {
+    VariantData::clear(getOrCreateData(), getResourceManager());
+  }
+
+  // Returns true if the value is null or the reference is unbound.
+  // https://arduinojson.org/v7/api/jsonvariant/isnull/
+  bool isNull() const {
+    return VariantData::isNull(getData());
+  }
+
+  // Returns true if the reference is unbound.
+  bool isUnbound() const {
+    return !getData();
+  }
+
+  // Casts the value to the specified type.
+  // https://arduinojson.org/v7/api/jsonvariant/as/
+  template <typename T>
+  T as() const;
+
+  template <typename T, enable_if_t<!is_same<T, TDerived>::value, int> = 0>
+  operator T() const {
+    return as<T>();
+  }
+
+  // Sets the value to an empty array.
+  // https://arduinojson.org/v7/api/jsonvariant/to/
+  template <typename T, enable_if_t<is_same<T, JsonArray>::value, int> = 0>
+  JsonArray to() const;
+
+  // Sets the value to an empty object.
+  // https://arduinojson.org/v7/api/jsonvariant/to/
+  template <typename T, enable_if_t<is_same<T, JsonObject>::value, int> = 0>
+  JsonObject to() const;
+
+  // Sets the value to null.
+  // https://arduinojson.org/v7/api/jsonvariant/to/
+  template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int> = 0>
+  JsonVariant to() const;
+
+  // Returns true if the value is of the specified type.
+  // https://arduinojson.org/v7/api/jsonvariant/is/
+  template <typename T>
+  FORCE_INLINE bool is() const;
+
+  // Copies the specified value.
+  // https://arduinojson.org/v7/api/jsonvariant/set/
+  template <typename T>
+  bool set(const T& value) const {
+    using TypeForConverter = conditional_t<IsStringLiteral<T>::value, T,
+                                           remove_cv_t<remove_reference_t<T>>>;
+    return doSet<Converter<TypeForConverter>>(value);
+  }
+
+  // Copies the specified value.
+  // https://arduinojson.org/v7/api/jsonvariant/set/
+  template <typename T,
+            detail::enable_if_t<!detail::is_const<T>::value, int> = 0>
+  bool set(T* value) const {
+    return doSet<Converter<T*>>(value);
+  }
+
+  // Returns the size of the array or object.
+  // https://arduinojson.org/v7/api/jsonvariant/size/
+  size_t size() const {
+    return VariantData::size(getData(), getResourceManager());
+  }
+
+  // Returns the depth (nesting level) of the value.
+  // https://arduinojson.org/v7/api/jsonvariant/nesting/
+  size_t nesting() const {
+    return VariantData::nesting(getData(), getResourceManager());
+  }
+
+  // Appends a new (empty) element to the array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T, enable_if_t<!is_same<T, JsonVariant>::value, int> = 0>
+  T add() const {
+    return add<JsonVariant>().template to<T>();
+  }
+
+  // Appends a new (null) element to the array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int> = 0>
+  T add() const;
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T>
+  bool add(const T& value) const {
+    return detail::VariantData::addValue(getOrCreateData(), value,
+                                         getResourceManager());
+  }
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
+  bool add(T* value) const {
+    return detail::VariantData::addValue(getOrCreateData(), value,
+                                         getResourceManager());
+  }
+
+  // Removes an element of the array.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  void remove(size_t index) const {
+    VariantData::removeElement(getData(), index, getResourceManager());
+  }
+
+  // Removes a member of the object.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
+  void remove(TChar* key) const {
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
+  }
+
+  // Removes a member of the object.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
+  void remove(const TString& key) const {
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
+  }
+
+  // Removes a member of the object or an element of the array.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int> = 0>
+  void remove(const TVariant& key) const {
+    if (key.template is<size_t>())
+      remove(key.template as<size_t>());
+    else
+      remove(key.template as<const char*>());
+  }
+
+  // Gets or sets an array element.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  ElementProxy<TDerived> operator[](size_t index) const;
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariant/containskey/
+  template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TString& key) const;
+
+  // DEPRECATED: use obj["key"].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariant/containskey/
+  template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
+  bool containsKey(TChar* key) const;
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariant/containskey/
+  template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TVariant& key) const;
+
+  // Gets or sets an object member.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
+  FORCE_INLINE MemberProxy<TDerived, AdaptedString<TString>> operator[](
+      const TString& key) const;
+
+  // Gets or sets an object member.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  template <
+      typename TChar,
+      enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int> = 0>
+  FORCE_INLINE MemberProxy<TDerived, AdaptedString<TChar*>> operator[](
+      TChar* key) const;
+
+  // Gets an object member or an array element.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int> = 0>
+  JsonVariantConst operator[](const TVariant& key) const {
+    if (key.template is<size_t>())
+      return operator[](key.template as<size_t>());
+    else
+      return operator[](key.template as<JsonString>());
+  }
+
+  // DEPRECATED: use add<JsonVariant>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonVariant>() instead")
+  JsonVariant add() const;
+
+  // DEPRECATED: use add<JsonArray>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonArray>() instead")
+  JsonArray createNestedArray() const;
+
+  // DEPRECATED: use var[key].to<JsonArray>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(TChar* key) const;
+
+  // DEPRECATED: use var[key].to<JsonArray>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(const TString& key) const;
+
+  // DEPRECATED: use add<JsonObject>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonObject>() instead")
+  JsonObject createNestedObject() const;
+
+  // DEPRECATED: use var[key].to<JsonObject>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(TChar* key) const;
+
+  // DEPRECATED: use var[key].to<JsonObject>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(const TString& key) const;
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+  // DEPRECATED: performs a deep copy
+  ARDUINOJSON_DEPRECATED("performs a deep copy")
+  void shallowCopy(JsonVariantConst src) const {
+    set(src);
+  }
+
+ private:
+  TDerived& derived() {
+    return static_cast<TDerived&>(*this);
+  }
+
+  const TDerived& derived() const {
+    return static_cast<const TDerived&>(*this);
+  }
+
+  ResourceManager* getResourceManager() const {
+    return VariantAttorney::getResourceManager(derived());
+  }
+
+  VariantData* getData() const {
+    return VariantAttorney::getData(derived());
+  }
+
+  VariantData* getOrCreateData() const {
+    return VariantAttorney::getOrCreateData(derived());
+  }
+
+  FORCE_INLINE ArduinoJson::JsonVariant getVariant() const;
+
+  FORCE_INLINE ArduinoJson::JsonVariantConst getVariantConst() const {
+    return ArduinoJson::JsonVariantConst(getData(), getResourceManager());
+  }
+
+  template <typename T>
+  FORCE_INLINE enable_if_t<is_same<T, JsonVariantConst>::value, T> getVariant()
+      const {
+    return getVariantConst();
+  }
+
+  template <typename T>
+  FORCE_INLINE enable_if_t<is_same<T, JsonVariant>::value, T> getVariant()
+      const {
+    return getVariant();
+  }
+
+  template <typename TConverter, typename T>
+  bool doSet(const T& value) const {
+    return doSet<TConverter>(
+        value, is_same<typename function_traits<
+                           decltype(&TConverter::toJson)>::return_type,
+                       bool>{});
+  }
+
+  template <typename TConverter, typename T>
+  bool doSet(const T& value, false_type) const;
+
+  template <typename TConverter, typename T>
+  bool doSet(const T& value, true_type) const;
+
+  ArduinoJson::JsonVariant getOrCreateVariant() const;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE