@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Filter.hpp

@@ -0,0 +1,77 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+#include <ArduinoJson/Variant/VariantAttorney.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+namespace DeserializationOption {
+class Filter {
+ public:
+#if ARDUINOJSON_AUTO_SHRINK
+  explicit Filter(JsonDocument& doc) : variant_(doc) {
+    doc.shrinkToFit();
+  }
+#endif
+
+  explicit Filter(JsonVariantConst variant) : variant_(variant) {}
+
+  bool allow() const {
+    return variant_;
+  }
+
+  bool allowArray() const {
+    return variant_ == true || variant_.is<JsonArrayConst>();
+  }
+
+  bool allowObject() const {
+    return variant_ == true || variant_.is<JsonObjectConst>();
+  }
+
+  bool allowValue() const {
+    return variant_ == true;
+  }
+
+  template <typename TKey>
+  Filter operator[](const TKey& key) const {
+    if (variant_ == true)  // "true" means "allow recursively"
+      return *this;
+    JsonVariantConst member = variant_[key];
+    return Filter(member.isNull() ? variant_["*"] : member);
+  }
+
+ private:
+  JsonVariantConst variant_;
+};
+}  // namespace DeserializationOption
+
+namespace detail {
+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 detail
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/NestingLimit.hpp

@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+namespace DeserializationOption {
+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 DeserializationOption
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Reader.hpp

@@ -0,0 +1,74 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+
+#include <stdlib.h>  // for size_t
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// The default reader is a simple wrapper for Readers that are not copyable
+template <typename TSource, typename Enable = void>
+struct Reader {
+ public:
+  Reader(TSource& source) : source_(&source) {}
+
+  int read() {
+    // clang-format off
+    return source_->read();  // Error here? See https://arduinojson.org/v7/invalid-input/
+    // clang-format on
+  }
+
+  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
+};
+
+ARDUINOJSON_END_PRIVATE_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
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TInput>
+Reader<remove_reference_t<TInput>> makeReader(TInput&& input) {
+  return Reader<remove_reference_t<TInput>>{detail::forward<TInput>(input)};
+}
+
+template <typename TChar>
+BoundedReader<TChar*> makeReader(TChar* input, size_t inputSize) {
+  return BoundedReader<TChar*>{input, inputSize};
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp

@@ -0,0 +1,30 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TSource>
+struct Reader<TSource, enable_if_t<is_base_of<Stream, TSource>::value>> {
+ 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_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp

@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TSource>
+struct Reader<TSource, enable_if_t<is_base_of<::String, TSource>::value>>
+    : BoundedReader<const char*> {
+  explicit Reader(const ::String& s)
+      : BoundedReader<const char*>(s.c_str(), s.length()) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp

@@ -0,0 +1,56 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/pgmspace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_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;
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp

@@ -0,0 +1,42 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_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 TSource>
+struct Reader<TSource, void_t<typename TSource::const_iterator>>
+    : IteratorReader<typename TSource::const_iterator> {
+  explicit Reader(const TSource& source)
+      : IteratorReader<typename TSource::const_iterator>(source.begin(),
+                                                         source.end()) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Readers/RamReader.hpp

@@ -0,0 +1,49 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_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*, enable_if_t<IsCharOrVoid<TSource>::value>> {
+  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*, enable_if_t<IsCharOrVoid<TSource>::value>>
+    : 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) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp

@@ -0,0 +1,29 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <istream>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TSource>
+struct Reader<TSource, enable_if_t<is_base_of<std::istream, TSource>::value>> {
+ 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_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/Readers/VariantReader.hpp

@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/MemberProxy.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TVariant>
+struct Reader<TVariant, enable_if_t<IsVariant<TVariant>::value>>
+    : Reader<char*, void> {
+  explicit Reader(const TVariant& x)
+      : Reader<char*, void>(x.template as<const char*>()) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Deserialization/deserialize.hpp

@@ -0,0 +1,79 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/DeserializationError.hpp>
+#include <ArduinoJson/Deserialization/DeserializationOptions.hpp>
+#include <ArduinoJson/Deserialization/Reader.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that returns the first type of the parameter pack
+// or void if empty
+template <typename...>
+struct first_or_void {
+  using type = void;
+};
+template <typename T, typename... Rest>
+struct first_or_void<T, Rest...> {
+  using type = T;
+};
+
+// A meta-function that returns true if T is a valid destination type for
+// deserialize()
+template <class T>
+using is_deserialize_destination =
+    bool_constant<is_base_of<JsonDocument, remove_cv_t<T>>::value ||
+                  IsVariant<T>::value>;
+
+template <typename TDestination>
+inline void shrinkJsonDocument(TDestination&) {
+  // no-op by default
+}
+
+#if ARDUINOJSON_AUTO_SHRINK
+inline void shrinkJsonDocument(JsonDocument& doc) {
+  doc.shrinkToFit();
+}
+#endif
+
+template <template <typename> class TDeserializer, typename TDestination,
+          typename TReader, typename TOptions>
+DeserializationError doDeserialize(TDestination&& dst, TReader reader,
+                                   TOptions options) {
+  auto data = VariantAttorney::getOrCreateData(dst);
+  if (!data)
+    return DeserializationError::NoMemory;
+  auto resources = VariantAttorney::getResourceManager(dst);
+  dst.clear();
+  auto err = TDeserializer<TReader>(resources, reader)
+                 .parse(*data, options.filter, options.nestingLimit);
+  shrinkJsonDocument(dst);
+  return err;
+}
+
+template <
+    template <typename> class TDeserializer, typename TDestination,
+    typename TStream, typename... Args,
+    enable_if_t<  // issue #1897
+        !is_integral<typename first_or_void<Args...>::type>::value, int> = 0>
+DeserializationError deserialize(TDestination&& dst, TStream&& input,
+                                 Args... args) {
+  return doDeserialize<TDeserializer>(
+      dst, makeReader(detail::forward<TStream>(input)),
+      makeDeserializationOptions(args...));
+}
+
+template <template <typename> class TDeserializer, typename TDestination,
+          typename TChar, typename Size, typename... Args,
+          enable_if_t<is_integral<Size>::value, int> = 0>
+DeserializationError deserialize(TDestination&& dst, TChar* input,
+                                 Size inputSize, Args... args) {
+  return doDeserialize<TDeserializer>(dst, makeReader(input, size_t(inputSize)),
+                                      makeDeserializationOptions(args...));
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE