@alteriom/painlessmesh 1.7.4 → 1.7.6

package/examples/alteriom/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Memory/Allocator.hpp

@@ -1,49 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Namespace.hpp>
-
-#include <stdlib.h>  // malloc, free
-
-ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
-
-class Allocator {
- public:
-  virtual void* allocate(size_t size) = 0;
-  virtual void deallocate(void* ptr) = 0;
-  virtual void* reallocate(void* ptr, size_t new_size) = 0;
-
- protected:
-  ~Allocator() = default;
-};
-
-namespace detail {
-class DefaultAllocator : public Allocator {
- public:
-  void* allocate(size_t size) override {
-    return malloc(size);
-  }
-
-  void deallocate(void* ptr) override {
-    free(ptr);
-  }
-
-  void* reallocate(void* ptr, size_t new_size) override {
-    return realloc(ptr, new_size);
-  }
-
-  static Allocator* instance() {
-    static DefaultAllocator allocator;
-    return &allocator;
-  }
-
- private:
-  DefaultAllocator() = default;
-  ~DefaultAllocator() = default;
-};
-}  // namespace detail
-
-ARDUINOJSON_END_PUBLIC_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Memory/MemoryPool.hpp

@@ -1,110 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Memory/Allocator.hpp>
-#include <ArduinoJson/Polyfills/assert.hpp>
-#include <ArduinoJson/Polyfills/integer.hpp>
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-using SlotId = uint_t<ARDUINOJSON_SLOT_ID_SIZE * 8>;
-using SlotCount = SlotId;
-const SlotId NULL_SLOT = SlotId(-1);
-
-template <typename T>
-class Slot {
- public:
-  Slot() : ptr_(nullptr), id_(NULL_SLOT) {}
-  Slot(T* p, SlotId id) : ptr_(p), id_(id) {
-    ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT));
-  }
-
-  explicit operator bool() const {
-    return ptr_ != nullptr;
-  }
-
-  SlotId id() const {
-    return id_;
-  }
-
-  T* ptr() const {
-    return ptr_;
-  }
-
-  T* operator->() const {
-    ARDUINOJSON_ASSERT(ptr_ != nullptr);
-    return ptr_;
-  }
-
- private:
-  T* ptr_;
-  SlotId id_;
-};
-
-template <typename T>
-class MemoryPool {
- public:
-  void create(SlotCount cap, Allocator* allocator) {
-    ARDUINOJSON_ASSERT(cap > 0);
-    slots_ = reinterpret_cast<T*>(allocator->allocate(slotsToBytes(cap)));
-    capacity_ = slots_ ? cap : 0;
-    usage_ = 0;
-  }
-
-  void destroy(Allocator* allocator) {
-    if (slots_)
-      allocator->deallocate(slots_);
-    slots_ = nullptr;
-    capacity_ = 0;
-    usage_ = 0;
-  }
-
-  Slot<T> allocSlot() {
-    if (!slots_)
-      return {};
-    if (usage_ >= capacity_)
-      return {};
-    auto index = usage_++;
-    return {slots_ + index, SlotId(index)};
-  }
-
-  T* getSlot(SlotId id) const {
-    ARDUINOJSON_ASSERT(id < usage_);
-    return slots_ + id;
-  }
-
-  void clear() {
-    usage_ = 0;
-  }
-
-  void shrinkToFit(Allocator* allocator) {
-    auto newSlots = reinterpret_cast<T*>(
-        allocator->reallocate(slots_, slotsToBytes(usage_)));
-    if (newSlots) {
-      slots_ = newSlots;
-      capacity_ = usage_;
-    }
-  }
-
-  SlotCount usage() const {
-    return usage_;
-  }
-
-  static SlotCount bytesToSlots(size_t n) {
-    return static_cast<SlotCount>(n / sizeof(T));
-  }
-
-  static size_t slotsToBytes(SlotCount n) {
-    return n * sizeof(T);
-  }
-
- private:
-  SlotCount capacity_;
-  SlotCount usage_;
-  T* slots_;
-};
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Memory/MemoryPoolList.hpp

@@ -1,214 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Memory/MemoryPool.hpp>
-#include <ArduinoJson/Polyfills/assert.hpp>
-#include <ArduinoJson/Polyfills/utility.hpp>
-
-#include <string.h>  // memcpy
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-using PoolCount = SlotId;
-
-template <typename T>
-class MemoryPoolList {
-  struct FreeSlot {
-    SlotId next;
-  };
-
-  static_assert(sizeof(FreeSlot) <= sizeof(T), "T is too small");
-
- public:
-  using Pool = MemoryPool<T>;
-
-  MemoryPoolList() = default;
-
-  ~MemoryPoolList() {
-    ARDUINOJSON_ASSERT(count_ == 0);
-  }
-
-  friend void swap(MemoryPoolList& a, MemoryPoolList& b) {
-    bool aUsedPreallocated = a.pools_ == a.preallocatedPools_;
-    bool bUsedPreallocated = b.pools_ == b.preallocatedPools_;
-
-    // Who is using preallocated pools?
-    if (aUsedPreallocated && bUsedPreallocated) {
-      // both of us => swap preallocated pools
-      for (PoolCount i = 0; i < ARDUINOJSON_INITIAL_POOL_COUNT; i++)
-        swap_(a.preallocatedPools_[i], b.preallocatedPools_[i]);
-    } else if (bUsedPreallocated) {
-      // only b => copy b's preallocated pools and give him a's pointer
-      for (PoolCount i = 0; i < b.count_; i++)
-        a.preallocatedPools_[i] = b.preallocatedPools_[i];
-      b.pools_ = a.pools_;
-      a.pools_ = a.preallocatedPools_;
-    } else if (aUsedPreallocated) {
-      // only a => copy a's preallocated pools and give him b's pointer
-      for (PoolCount i = 0; i < a.count_; i++)
-        b.preallocatedPools_[i] = a.preallocatedPools_[i];
-      a.pools_ = b.pools_;
-      b.pools_ = b.preallocatedPools_;
-    } else {
-      // neither => swap pointers
-      swap_(a.pools_, b.pools_);
-    }
-
-    swap_(a.count_, b.count_);
-    swap_(a.capacity_, b.capacity_);
-    swap_(a.freeList_, b.freeList_);
-  }
-
-  MemoryPoolList& operator=(MemoryPoolList&& src) {
-    ARDUINOJSON_ASSERT(count_ == 0);
-    if (src.pools_ == src.preallocatedPools_) {
-      memcpy(preallocatedPools_, src.preallocatedPools_,
-             sizeof(preallocatedPools_));
-      pools_ = preallocatedPools_;
-    } else {
-      pools_ = src.pools_;
-      src.pools_ = nullptr;
-    }
-    count_ = src.count_;
-    capacity_ = src.capacity_;
-    src.count_ = 0;
-    src.capacity_ = 0;
-    return *this;
-  }
-
-  Slot<T> allocSlot(Allocator* allocator) {
-    // try to allocate from free list
-    if (freeList_ != NULL_SLOT) {
-      return allocFromFreeList();
-    }
-
-    // try to allocate from last pool (other pools are full)
-    if (count_) {
-      auto slot = allocFromLastPool();
-      if (slot)
-        return slot;
-    }
-
-    // create a new pool and try again
-    auto pool = addPool(allocator);
-    if (!pool)
-      return {};
-
-    return allocFromLastPool();
-  }
-
-  void freeSlot(Slot<T> slot) {
-    reinterpret_cast<FreeSlot*>(slot.ptr())->next = freeList_;
-    freeList_ = slot.id();
-  }
-
-  T* getSlot(SlotId id) const {
-    if (id == NULL_SLOT)
-      return nullptr;
-    auto poolIndex = SlotId(id / ARDUINOJSON_POOL_CAPACITY);
-    auto indexInPool = SlotId(id % ARDUINOJSON_POOL_CAPACITY);
-    ARDUINOJSON_ASSERT(poolIndex < count_);
-    return pools_[poolIndex].getSlot(indexInPool);
-  }
-
-  void clear(Allocator* allocator) {
-    for (PoolCount i = 0; i < count_; i++)
-      pools_[i].destroy(allocator);
-    count_ = 0;
-    freeList_ = NULL_SLOT;
-    if (pools_ != preallocatedPools_) {
-      allocator->deallocate(pools_);
-      pools_ = preallocatedPools_;
-      capacity_ = ARDUINOJSON_INITIAL_POOL_COUNT;
-    }
-  }
-
-  SlotCount usage() const {
-    SlotCount total = 0;
-    for (PoolCount i = 0; i < count_; i++)
-      total = SlotCount(total + pools_[i].usage());
-    return total;
-  }
-
-  size_t size() const {
-    return Pool::slotsToBytes(usage());
-  }
-
-  void shrinkToFit(Allocator* allocator) {
-    if (count_ > 0)
-      pools_[count_ - 1].shrinkToFit(allocator);
-    if (pools_ != preallocatedPools_ && count_ != capacity_) {
-      pools_ = static_cast<Pool*>(
-          allocator->reallocate(pools_, count_ * sizeof(Pool)));
-      ARDUINOJSON_ASSERT(pools_ != nullptr);  // realloc to smaller can't fail
-      capacity_ = count_;
-    }
-  }
-
- private:
-  Slot<T> allocFromFreeList() {
-    ARDUINOJSON_ASSERT(freeList_ != NULL_SLOT);
-    auto id = freeList_;
-    auto slot = getSlot(freeList_);
-    freeList_ = reinterpret_cast<FreeSlot*>(slot)->next;
-    return {slot, id};
-  }
-
-  Slot<T> allocFromLastPool() {
-    ARDUINOJSON_ASSERT(count_ > 0);
-    auto poolIndex = SlotId(count_ - 1);
-    auto slot = pools_[poolIndex].allocSlot();
-    if (!slot)
-      return {};
-    return {slot.ptr(),
-            SlotId(poolIndex * ARDUINOJSON_POOL_CAPACITY + slot.id())};
-  }
-
-  Pool* addPool(Allocator* allocator) {
-    if (count_ == capacity_ && !increaseCapacity(allocator))
-      return nullptr;
-    auto pool = &pools_[count_++];
-    SlotCount poolCapacity = ARDUINOJSON_POOL_CAPACITY;
-    if (count_ == maxPools)  // last pool is smaller because of NULL_SLOT
-      poolCapacity--;
-    pool->create(poolCapacity, allocator);
-    return pool;
-  }
-
-  bool increaseCapacity(Allocator* allocator) {
-    if (capacity_ == maxPools)
-      return false;
-    void* newPools;
-    auto newCapacity = PoolCount(capacity_ * 2);
-
-    if (pools_ == preallocatedPools_) {
-      newPools = allocator->allocate(newCapacity * sizeof(Pool));
-      if (!newPools)
-        return false;
-      memcpy(newPools, preallocatedPools_, sizeof(preallocatedPools_));
-    } else {
-      newPools = allocator->reallocate(pools_, newCapacity * sizeof(Pool));
-      if (!newPools)
-        return false;
-    }
-
-    pools_ = static_cast<Pool*>(newPools);
-    capacity_ = newCapacity;
-    return true;
-  }
-
-  Pool preallocatedPools_[ARDUINOJSON_INITIAL_POOL_COUNT];
-  Pool* pools_ = preallocatedPools_;
-  PoolCount count_ = 0;
-  PoolCount capacity_ = ARDUINOJSON_INITIAL_POOL_COUNT;
-  SlotId freeList_ = NULL_SLOT;
-
- public:
-  static const PoolCount maxPools =
-      PoolCount(NULL_SLOT / ARDUINOJSON_POOL_CAPACITY + 1);
-};
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Memory/ResourceManager.hpp

@@ -1,131 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Memory/Allocator.hpp>
-#include <ArduinoJson/Memory/MemoryPoolList.hpp>
-#include <ArduinoJson/Memory/StringPool.hpp>
-#include <ArduinoJson/Polyfills/assert.hpp>
-#include <ArduinoJson/Polyfills/utility.hpp>
-#include <ArduinoJson/Strings/StringAdapters.hpp>
-#include <ArduinoJson/Variant/VariantData.hpp>
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-class VariantData;
-class VariantWithId;
-
-class ResourceManager {
-  union SlotData {
-    VariantData variant;
-#if ARDUINOJSON_USE_EXTENSIONS
-    VariantExtension extension;
-#endif
-  };
-
- public:
-  constexpr static size_t slotSize = sizeof(SlotData);
-
-  ResourceManager(Allocator* allocator = DefaultAllocator::instance())
-      : allocator_(allocator), overflowed_(false) {}
-
-  ~ResourceManager() {
-    stringPool_.clear(allocator_);
-    variantPools_.clear(allocator_);
-  }
-
-  ResourceManager(const ResourceManager&) = delete;
-  ResourceManager& operator=(const ResourceManager& src) = delete;
-
-  friend void swap(ResourceManager& a, ResourceManager& b) {
-    swap(a.stringPool_, b.stringPool_);
-    swap(a.variantPools_, b.variantPools_);
-    swap_(a.allocator_, b.allocator_);
-    swap_(a.overflowed_, b.overflowed_);
-  }
-
-  Allocator* allocator() const {
-    return allocator_;
-  }
-
-  size_t size() const {
-    return variantPools_.size() + stringPool_.size();
-  }
-
-  bool overflowed() const {
-    return overflowed_;
-  }
-
-  Slot<VariantData> allocVariant();
-  void freeVariant(Slot<VariantData> slot);
-  VariantData* getVariant(SlotId id) const;
-
-#if ARDUINOJSON_USE_EXTENSIONS
-  Slot<VariantExtension> allocExtension();
-  void freeExtension(SlotId slot);
-  VariantExtension* getExtension(SlotId id) const;
-#endif
-
-  template <typename TAdaptedString>
-  StringNode* saveString(TAdaptedString str) {
-    if (str.isNull())
-      return 0;
-
-    auto node = stringPool_.add(str, allocator_);
-    if (!node)
-      overflowed_ = true;
-
-    return node;
-  }
-
-  void saveString(StringNode* node) {
-    stringPool_.add(node);
-  }
-
-  template <typename TAdaptedString>
-  StringNode* getString(const TAdaptedString& str) const {
-    return stringPool_.get(str);
-  }
-
-  StringNode* createString(size_t length) {
-    auto node = StringNode::create(length, allocator_);
-    if (!node)
-      overflowed_ = true;
-    return node;
-  }
-
-  StringNode* resizeString(StringNode* node, size_t length) {
-    node = StringNode::resize(node, length, allocator_);
-    if (!node)
-      overflowed_ = true;
-    return node;
-  }
-
-  void destroyString(StringNode* node) {
-    StringNode::destroy(node, allocator_);
-  }
-
-  void dereferenceString(const char* s) {
-    stringPool_.dereference(s, allocator_);
-  }
-
-  void clear() {
-    variantPools_.clear(allocator_);
-    overflowed_ = false;
-    stringPool_.clear(allocator_);
-  }
-
-  void shrinkToFit() {
-    variantPools_.shrinkToFit(allocator_);
-  }
-
- private:
-  Allocator* allocator_;
-  bool overflowed_;
-  StringPool stringPool_;
-  MemoryPoolList<SlotData> variantPools_;
-};
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Memory/ResourceManagerImpl.hpp

@@ -1,52 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Collection/CollectionData.hpp>
-#include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Polyfills/alias_cast.hpp>
-#include <ArduinoJson/Variant/VariantData.hpp>
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-inline Slot<VariantData> ResourceManager::allocVariant() {
-  auto p = variantPools_.allocSlot(allocator_);
-  if (!p) {
-    overflowed_ = true;
-    return {};
-  }
-  return {new (&p->variant) VariantData, p.id()};
-}
-
-inline void ResourceManager::freeVariant(Slot<VariantData> variant) {
-  variant->clear(this);
-  variantPools_.freeSlot({alias_cast<SlotData*>(variant.ptr()), variant.id()});
-}
-
-inline VariantData* ResourceManager::getVariant(SlotId id) const {
-  return reinterpret_cast<VariantData*>(variantPools_.getSlot(id));
-}
-
-#if ARDUINOJSON_USE_EXTENSIONS
-inline Slot<VariantExtension> ResourceManager::allocExtension() {
-  auto p = variantPools_.allocSlot(allocator_);
-  if (!p) {
-    overflowed_ = true;
-    return {};
-  }
-  return {&p->extension, p.id()};
-}
-
-inline void ResourceManager::freeExtension(SlotId id) {
-  auto p = getExtension(id);
-  variantPools_.freeSlot({reinterpret_cast<SlotData*>(p), id});
-}
-
-inline VariantExtension* ResourceManager::getExtension(SlotId id) const {
-  return &variantPools_.getSlot(id)->extension;
-}
-#endif
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

package/examples/alteriom/.pio/libdeps/esp8266/ArduinoJson/src/ArduinoJson/Memory/StringBuffer.hpp

@@ -1,79 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Memory/ResourceManager.hpp>
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-class StringBuffer {
- public:
-  StringBuffer(ResourceManager* resources) : resources_(resources) {}
-
-  ~StringBuffer() {
-    if (node_)
-      resources_->destroyString(node_);
-  }
-
-  char* reserve(size_t capacity) {
-    if (node_ && capacity > node_->length) {
-      // existing buffer is too small, we need to reallocate
-      resources_->destroyString(node_);
-      node_ = nullptr;
-    }
-    if (!node_)
-      node_ = resources_->createString(capacity);
-    if (!node_)
-      return nullptr;
-    size_ = capacity;
-    node_->data[capacity] = 0;  // null-terminate the string
-    return node_->data;
-  }
-
-  JsonString str() const {
-    ARDUINOJSON_ASSERT(node_ != nullptr);
-    return JsonString(node_->data, node_->length);
-  }
-
-  void save(VariantData* data) {
-    ARDUINOJSON_ASSERT(node_ != nullptr);
-    const char* s = node_->data;
-    if (isTinyString(s, size_))
-      data->setTinyString(adaptString(s, size_));
-    else
-      data->setOwnedString(commitStringNode());
-  }
-
-  void saveRaw(VariantData* data) {
-    data->setRawString(commitStringNode());
-  }
-
- private:
-  StringNode* commitStringNode() {
-    ARDUINOJSON_ASSERT(node_ != nullptr);
-    node_->data[size_] = 0;
-    auto node = resources_->getString(adaptString(node_->data, size_));
-    if (node) {
-      node->references++;
-      return node;
-    }
-
-    if (node_->length != size_) {
-      node = resources_->resizeString(node_, size_);
-      ARDUINOJSON_ASSERT(node != nullptr);  // realloc to smaller can't fail
-    } else {
-      node = node_;
-    }
-    node_ = nullptr;
-    resources_->saveString(node);
-    return node;
-  }
-
-  ResourceManager* resources_;
-  StringNode* node_ = nullptr;
-  size_t size_ = 0;
-};
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE