@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Object/ObjectData.hpp

@@ -0,0 +1,70 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Collection/CollectionData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class ObjectData : public CollectionData {
+ public:
+  template <typename TAdaptedString>
+  VariantData* addMember(TAdaptedString key, ResourceManager* resources);
+
+  VariantData* addPair(VariantData** value, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  VariantData* getOrAddMember(TAdaptedString key, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  VariantData* getMember(TAdaptedString key,
+                         const ResourceManager* resources) const;
+
+  template <typename TAdaptedString>
+  static VariantData* getMember(const ObjectData* object, TAdaptedString key,
+                                const ResourceManager* resources) {
+    if (!object)
+      return nullptr;
+    return object->getMember(key, resources);
+  }
+
+  template <typename TAdaptedString>
+  void removeMember(TAdaptedString key, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  static void removeMember(ObjectData* obj, TAdaptedString key,
+                           ResourceManager* resources) {
+    if (!obj)
+      return;
+    obj->removeMember(key, resources);
+  }
+
+  void remove(iterator it, ResourceManager* resources) {
+    CollectionData::removePair(it, resources);
+  }
+
+  static void remove(ObjectData* obj, ObjectData::iterator it,
+                     ResourceManager* resources) {
+    if (!obj)
+      return;
+    obj->remove(it, resources);
+  }
+
+  size_t size(const ResourceManager* resources) const {
+    return CollectionData::size(resources) / 2;
+  }
+
+  static size_t size(const ObjectData* obj, const ResourceManager* resources) {
+    if (!obj)
+      return 0;
+    return obj->size(resources);
+  }
+
+ private:
+  template <typename TAdaptedString>
+  iterator findKey(TAdaptedString key, const ResourceManager* resources) const;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Object/ObjectImpl.hpp

@@ -0,0 +1,92 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/ObjectData.hpp>
+#include <ArduinoJson/Variant/VariantCompare.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TAdaptedString>
+inline VariantData* ObjectData::getMember(
+    TAdaptedString key, const ResourceManager* resources) const {
+  auto it = findKey(key, resources);
+  if (it.done())
+    return nullptr;
+  it.next(resources);
+  return it.data();
+}
+
+template <typename TAdaptedString>
+VariantData* ObjectData::getOrAddMember(TAdaptedString key,
+                                        ResourceManager* resources) {
+  auto data = getMember(key, resources);
+  if (data)
+    return data;
+  return addMember(key, resources);
+}
+
+template <typename TAdaptedString>
+inline ObjectData::iterator ObjectData::findKey(
+    TAdaptedString key, const ResourceManager* resources) const {
+  if (key.isNull())
+    return iterator();
+  bool isKey = true;
+  for (auto it = createIterator(resources); !it.done(); it.next(resources)) {
+    if (isKey && stringEquals(key, adaptString(it->asString())))
+      return it;
+    isKey = !isKey;
+  }
+  return iterator();
+}
+
+template <typename TAdaptedString>
+inline void ObjectData::removeMember(TAdaptedString key,
+                                     ResourceManager* resources) {
+  remove(findKey(key, resources), resources);
+}
+
+template <typename TAdaptedString>
+inline VariantData* ObjectData::addMember(TAdaptedString key,
+                                          ResourceManager* resources) {
+  auto keySlot = resources->allocVariant();
+  if (!keySlot)
+    return nullptr;
+
+  auto valueSlot = resources->allocVariant();
+  if (!valueSlot)
+    return nullptr;
+
+  if (!keySlot->setString(key, resources))
+    return nullptr;
+
+  CollectionData::appendPair(keySlot, valueSlot, resources);
+
+  return valueSlot.ptr();
+}
+
+inline VariantData* ObjectData::addPair(VariantData** value,
+                                        ResourceManager* resources) {
+  auto keySlot = resources->allocVariant();
+  if (!keySlot)
+    return nullptr;
+
+  auto valueSlot = resources->allocVariant();
+  if (!valueSlot)
+    return nullptr;
+  *value = valueSlot.ptr();
+
+  CollectionData::appendPair(keySlot, valueSlot, resources);
+
+  return keySlot.ptr();
+}
+
+// Returns the size (in bytes) of an object with n members.
+constexpr size_t sizeofObject(size_t n) {
+  return 2 * n * ResourceManager::slotSize;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/alias_cast.hpp

@@ -0,0 +1,30 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>  // for size_t
+
+#include <ArduinoJson/Configuration.hpp>
+#include "math.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_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;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/assert.hpp

@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// 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

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/attributes.hpp

@@ -0,0 +1,45 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#ifdef _MSC_VER  // Visual Studio
+
+#  define FORCE_INLINE  // __forceinline causes C4714 when returning std::string
+
+#  ifndef ARDUINOJSON_DEPRECATED
+#    define ARDUINOJSON_DEPRECATED(msg) __declspec(deprecated(msg))
+#  endif
+
+#elif defined(__GNUC__)  // GCC or Clang
+
+#  define FORCE_INLINE __attribute__((always_inline))
+
+#  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
+
+#  ifndef ARDUINOJSON_DEPRECATED
+#    define ARDUINOJSON_DEPRECATED(msg)
+#  endif
+
+#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

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/ctype.hpp

@@ -0,0 +1,21 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+#ifndef isdigit
+inline bool isdigit(char c) {
+  return '0' <= c && c <= '9';
+}
+#endif
+
+inline bool issign(char c) {
+  return '-' == c || c == '+';
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/integer.hpp

@@ -0,0 +1,34 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>  // int8_t, int16_t
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <int Bits>
+struct uint_;
+
+template <>
+struct uint_<8> {
+  using type = uint8_t;
+};
+
+template <>
+struct uint_<16> {
+  using type = uint16_t;
+};
+
+template <>
+struct uint_<32> {
+  using type = uint32_t;
+};
+
+template <int Bits>
+using uint_t = typename uint_<Bits>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/limits.hpp

@@ -0,0 +1,45 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_traits.hpp"
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable : 4310)
+#endif
+
+ARDUINOJSON_BEGIN_PRIVATE_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, enable_if_t<is_unsigned<T>::value>> {
+  static constexpr T lowest() {
+    return 0;
+  }
+  static constexpr T highest() {
+    return T(-1);
+  }
+};
+
+template <typename T>
+struct numeric_limits<
+    T, enable_if_t<is_integral<T>::value && is_signed<T>::value>> {
+  static constexpr T lowest() {
+    return T(T(1) << (sizeof(T) * 8 - 1));
+  }
+  static constexpr T highest() {
+    return T(~lowest());
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/math.hpp

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

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/mpl/max.hpp

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

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace.hpp

@@ -0,0 +1,144 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#ifdef ARDUINO
+#  include <Arduino.h>
+#else
+// Allow using PROGMEM outside of Arduino (issue #1903)
+class __FlashStringHelper;
+#  include <avr/pgmspace.h>
+#endif
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+// Wraps a const char* so that the our functions are picked only if the
+// originals are missing
+struct pgm_p {
+  pgm_p(const void* p) : address(reinterpret_cast<const char*>(p)) {}
+  const char* address;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#ifndef strlen_P
+inline size_t strlen_P(ArduinoJson::detail::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::detail::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::detail::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 memcmp_P
+inline int memcmp_P(const void* a, ArduinoJson::detail::pgm_p b, size_t n) {
+  const uint8_t* p1 = reinterpret_cast<const uint8_t*>(a);
+  const char* p2 = b.address;
+  ARDUINOJSON_ASSERT(p1 != NULL);
+  ARDUINOJSON_ASSERT(p2 != NULL);
+  while (n-- > 0) {
+    uint8_t v1 = *p1++;
+    uint8_t v2 = pgm_read_byte(p2++);
+    if (v1 != v2)
+      return v1 - v2;
+  }
+  return 0;
+}
+#endif
+
+#ifndef memcpy_P
+inline void* memcpy_P(void* dst, ArduinoJson::detail::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
+
+#ifndef pgm_read_dword
+inline uint32_t pgm_read_dword(ArduinoJson::detail::pgm_p p) {
+  uint32_t result;
+  memcpy_P(&result, p.address, 4);
+  return result;
+}
+#endif
+
+#ifndef pgm_read_float
+inline float pgm_read_float(ArduinoJson::detail::pgm_p p) {
+  float result;
+  memcpy_P(&result, p.address, sizeof(float));
+  return result;
+}
+#endif
+
+#ifndef pgm_read_double
+#  if defined(__SIZEOF_DOUBLE__) && defined(__SIZEOF_FLOAT__) && \
+      __SIZEOF_DOUBLE__ == __SIZEOF_FLOAT__
+inline double pgm_read_double(ArduinoJson::detail::pgm_p p) {
+  return pgm_read_float(p.address);
+}
+#  else
+inline double pgm_read_double(ArduinoJson::detail::pgm_p p) {
+  double result;
+  memcpy_P(&result, p.address, sizeof(double));
+  return result;
+}
+#  endif
+#endif
+
+#ifndef pgm_read_ptr
+inline void* pgm_read_ptr(ArduinoJson::detail::pgm_p p) {
+  void* result;
+  memcpy_P(&result, p.address, sizeof(result));
+  return result;
+}
+#endif

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace_generic.hpp

@@ -0,0 +1,67 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+#  include <ArduinoJson/Polyfills/pgmspace.hpp>
+#  include <ArduinoJson/Polyfills/type_traits.hpp>
+#endif
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+
+#  ifndef ARDUINOJSON_DEFINE_PROGMEM_ARRAY
+#    define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, ...) \
+      static type const name[] PROGMEM = __VA_ARGS__;
+#  endif
+
+template <typename T>
+inline const T* pgm_read(const T* const* p) {
+  return reinterpret_cast<const T*>(pgm_read_ptr(p));
+}
+
+inline uint32_t pgm_read(const uint32_t* p) {
+  return pgm_read_dword(p);
+}
+
+inline double pgm_read(const double* p) {
+  return pgm_read_double(p);
+}
+
+inline float pgm_read(const float* p) {
+  return pgm_read_float(p);
+}
+
+#else
+
+#  ifndef ARDUINOJSON_DEFINE_PROGMEM_ARRAY
+#    define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, ...) \
+      static type const name[] = __VA_ARGS__;
+#  endif
+
+template <typename T>
+inline T pgm_read(const T* p) {
+  return *p;
+}
+
+#endif
+
+template <typename T>
+class pgm_ptr {
+ public:
+  explicit pgm_ptr(const T* ptr) : ptr_(ptr) {}
+
+  T operator[](intptr_t index) const {
+    return pgm_read(ptr_ + index);
+  }
+
+ private:
+  const T* ptr_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/preprocessor.hpp

@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#define ARDUINOJSON_CONCAT_(A, B) A##B
+#define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B)
+#define ARDUINOJSON_CONCAT3(A, B, C) \
+  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), C)
+#define ARDUINOJSON_CONCAT4(A, B, C, D) \
+  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT3(A, B, C), D)
+#define ARDUINOJSON_CONCAT5(A, B, C, D, E) \
+  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT4(A, B, C, D), E)
+
+#define ARDUINOJSON_BIN2ALPHA_0000() A
+#define ARDUINOJSON_BIN2ALPHA_0001() B
+#define ARDUINOJSON_BIN2ALPHA_0010() C
+#define ARDUINOJSON_BIN2ALPHA_0011() D
+#define ARDUINOJSON_BIN2ALPHA_0100() E
+#define ARDUINOJSON_BIN2ALPHA_0101() F
+#define ARDUINOJSON_BIN2ALPHA_0110() G
+#define ARDUINOJSON_BIN2ALPHA_0111() H
+#define ARDUINOJSON_BIN2ALPHA_1000() I
+#define ARDUINOJSON_BIN2ALPHA_1001() J
+#define ARDUINOJSON_BIN2ALPHA_1010() K
+#define ARDUINOJSON_BIN2ALPHA_1011() L
+#define ARDUINOJSON_BIN2ALPHA_1100() M
+#define ARDUINOJSON_BIN2ALPHA_1101() N
+#define ARDUINOJSON_BIN2ALPHA_1110() O
+#define ARDUINOJSON_BIN2ALPHA_1111() P
+#define ARDUINOJSON_BIN2ALPHA_(A, B, C, D) ARDUINOJSON_BIN2ALPHA_##A##B##C##D()
+#define ARDUINOJSON_BIN2ALPHA(A, B, C, D) ARDUINOJSON_BIN2ALPHA_(A, B, C, D)

package/examples/alteriom/.pio/libdeps/esp32/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/conditional.hpp

@@ -0,0 +1,25 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <bool Condition, class TrueType, class FalseType>
+struct conditional {
+  using type = TrueType;
+};
+
+template <class TrueType, class FalseType>
+struct conditional<false, TrueType, FalseType> {
+  using type = FalseType;
+};
+
+template <bool Condition, class TrueType, class FalseType>
+using conditional_t =
+    typename conditional<Condition, TrueType, FalseType>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE