@alteriom/painlessmesh 1.7.2 → 1.7.4

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Json/JsonSerializer.hpp

@@ -0,0 +1,165 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Json/TextFormatter.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+#include <ArduinoJson/Variant/VariantDataVisitor.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class JsonSerializer : public VariantDataVisitor<size_t> {
+ public:
+  static const bool producesText = true;
+
+  JsonSerializer(TWriter writer, const ResourceManager* resources)
+      : formatter_(writer), resources_(resources) {}
+
+  size_t visit(const ArrayData& array) {
+    write('[');
+
+    auto slotId = array.head();
+
+    while (slotId != NULL_SLOT) {
+      auto slot = resources_->getVariant(slotId);
+
+      slot->accept(*this, resources_);
+
+      slotId = slot->next();
+
+      if (slotId != NULL_SLOT)
+        write(',');
+    }
+
+    write(']');
+    return bytesWritten();
+  }
+
+  size_t visit(const ObjectData& object) {
+    write('{');
+
+    auto slotId = object.head();
+
+    bool isKey = true;
+
+    while (slotId != NULL_SLOT) {
+      auto slot = resources_->getVariant(slotId);
+      slot->accept(*this, resources_);
+
+      slotId = slot->next();
+
+      if (slotId != NULL_SLOT)
+        write(isKey ? ':' : ',');
+
+      isKey = !isKey;
+    }
+
+    write('}');
+    return bytesWritten();
+  }
+
+  template <typename T>
+  enable_if_t<is_floating_point<T>::value, size_t> visit(T value) {
+    formatter_.writeFloat(value);
+    return bytesWritten();
+  }
+
+  size_t visit(const char* value) {
+    formatter_.writeString(value);
+    return bytesWritten();
+  }
+
+  size_t visit(JsonString value) {
+    formatter_.writeString(value.c_str(), value.size());
+    return bytesWritten();
+  }
+
+  size_t visit(RawString value) {
+    formatter_.writeRaw(value.data(), value.size());
+    return bytesWritten();
+  }
+
+  size_t visit(JsonInteger value) {
+    formatter_.writeInteger(value);
+    return bytesWritten();
+  }
+
+  size_t visit(JsonUInt value) {
+    formatter_.writeInteger(value);
+    return bytesWritten();
+  }
+
+  size_t visit(bool value) {
+    formatter_.writeBoolean(value);
+    return bytesWritten();
+  }
+
+  size_t visit(nullptr_t) {
+    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_;
+
+ protected:
+  const ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Produces a minified JSON document.
+// https://arduinojson.org/v7/api/json/serializejson/
+template <
+    typename TDestination,
+    detail::enable_if_t<!detail::is_pointer<TDestination>::value, int> = 0>
+size_t serializeJson(JsonVariantConst source, TDestination& destination) {
+  using namespace detail;
+  return serialize<JsonSerializer>(source, destination);
+}
+
+// Produces a minified JSON document.
+// https://arduinojson.org/v7/api/json/serializejson/
+inline size_t serializeJson(JsonVariantConst source, void* buffer,
+                            size_t bufferSize) {
+  using namespace detail;
+  return serialize<JsonSerializer>(source, buffer, bufferSize);
+}
+
+// Computes the length of the document that serializeJson() produces.
+// https://arduinojson.org/v7/api/json/measurejson/
+inline size_t measureJson(JsonVariantConst source) {
+  using namespace detail;
+  return measure<JsonSerializer>(source);
+}
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+template <typename T,
+          detail::enable_if_t<
+              detail::is_convertible<T, JsonVariantConst>::value, int> = 0>
+inline std::ostream& operator<<(std::ostream& os, const T& source) {
+  serializeJson(source, os);
+  return os;
+}
+#endif
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Json/Latch.hpp

@@ -0,0 +1,56 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_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_;  // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject)
+                  // Not initialized in constructor (+10 bytes on AVR)
+  bool loaded_;
+#if ARDUINOJSON_DEBUG
+  bool ended_;
+#endif
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Json/PrettyJsonSerializer.hpp

@@ -0,0 +1,110 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Json/JsonSerializer.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class PrettyJsonSerializer : public JsonSerializer<TWriter> {
+  using base = JsonSerializer<TWriter>;
+
+ public:
+  PrettyJsonSerializer(TWriter writer, const ResourceManager* resources)
+      : base(writer, resources), nesting_(0) {}
+
+  size_t visit(const ArrayData& array) {
+    auto it = array.createIterator(base::resources_);
+    if (!it.done()) {
+      base::write("[\r\n");
+      nesting_++;
+      while (!it.done()) {
+        indent();
+        it->accept(*this, base::resources_);
+
+        it.next(base::resources_);
+        base::write(it.done() ? "\r\n" : ",\r\n");
+      }
+      nesting_--;
+      indent();
+      base::write("]");
+    } else {
+      base::write("[]");
+    }
+    return this->bytesWritten();
+  }
+
+  size_t visit(const ObjectData& object) {
+    auto it = object.createIterator(base::resources_);
+    if (!it.done()) {
+      base::write("{\r\n");
+      nesting_++;
+      bool isKey = true;
+      while (!it.done()) {
+        if (isKey)
+          indent();
+        it->accept(*this, base::resources_);
+        it.next(base::resources_);
+        if (isKey)
+          base::write(": ");
+        else
+          base::write(it.done() ? "\r\n" : ",\r\n");
+        isKey = !isKey;
+      }
+      nesting_--;
+      indent();
+      base::write("}");
+    } else {
+      base::write("{}");
+    }
+    return this->bytesWritten();
+  }
+
+  using base::visit;
+
+ private:
+  void indent() {
+    for (uint8_t i = 0; i < nesting_; i++)
+      base::write(ARDUINOJSON_TAB);
+  }
+
+  uint8_t nesting_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Produces JsonDocument to create a prettified JSON document.
+// https://arduinojson.org/v7/api/json/serializejsonpretty/
+template <
+    typename TDestination,
+    detail::enable_if_t<!detail::is_pointer<TDestination>::value, int> = 0>
+inline size_t serializeJsonPretty(JsonVariantConst source,
+                                  TDestination& destination) {
+  using namespace ArduinoJson::detail;
+  return serialize<PrettyJsonSerializer>(source, destination);
+}
+
+// Produces JsonDocument to create a prettified JSON document.
+// https://arduinojson.org/v7/api/json/serializejsonpretty/
+inline size_t serializeJsonPretty(JsonVariantConst source, void* buffer,
+                                  size_t bufferSize) {
+  using namespace ArduinoJson::detail;
+  return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
+}
+
+// Computes the length of the document that serializeJsonPretty() produces.
+// https://arduinojson.org/v7/api/json/measurejsonpretty/
+inline size_t measureJsonPretty(JsonVariantConst source) {
+  using namespace ArduinoJson::detail;
+  return measure<PrettyJsonSerializer>(source);
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Json/TextFormatter.hpp

@@ -0,0 +1,177 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// 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/JsonInteger.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/attributes.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Serialization/CountingDecorator.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class TextFormatter {
+ public:
+  explicit TextFormatter(TWriter writer) : writer_(writer) {}
+
+  TextFormatter& operator=(const TextFormatter&) = delete;
+
+  // 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 writeString(const char* value, size_t n) {
+    ARDUINOJSON_ASSERT(value != NULL);
+    writeRaw('\"');
+    while (n--)
+      writeChar(*value++);
+    writeRaw('\"');
+  }
+
+  void writeChar(char c) {
+    char specialChar = EscapeSequence::escapeChar(c);
+    if (specialChar) {
+      writeRaw('\\');
+      writeRaw(specialChar);
+    } else if (c) {
+      writeRaw(c);
+    } else {
+      writeRaw("\\u0000");
+    }
+  }
+
+  template <typename T>
+  void writeFloat(T value) {
+    writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6);
+  }
+
+  void writeFloat(JsonFloat value, int8_t decimalPlaces) {
+    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
+
+    auto parts = decomposeFloat(value, decimalPlaces);
+
+    writeInteger(parts.integral);
+    if (parts.decimalPlaces)
+      writeDecimals(parts.decimal, parts.decimalPlaces);
+
+    if (parts.exponent) {
+      writeRaw('e');
+      writeInteger(parts.exponent);
+    }
+  }
+
+  template <typename T>
+  enable_if_t<is_signed<T>::value> writeInteger(T value) {
+    using unsigned_type = make_unsigned_t<T>;
+    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>
+  enable_if_t<is_unsigned<T>::value> 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_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Json/Utf16.hpp

@@ -0,0 +1,67 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// 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
+
+ARDUINOJSON_BEGIN_PRIVATE_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), codepoint_(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
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#if defined(__GNUC__)
+#  if __GNUC__ >= 8
+#    pragma GCC diagnostic pop
+#  endif
+#endif

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Json/Utf8.hpp

@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+namespace Utf8 {
+template <typename TStringBuilder>
+inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) {
+  // this function was optimize for code size on AVR
+
+  if (codepoint32 < 0x80) {
+    str.append(char(codepoint32));
+  } else {
+    // a buffer to store the string in reverse
+    char buf[5];
+    char* p = buf;
+
+    *(p++) = 0;
+    *(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
+ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/basic/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Memory/Alignment.hpp

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