helpers.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstdarg>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iterator>
#include <limits>
#include <memory>
#include <span>
#include <string>
#include <type_traits>
#include <vector>
#include <concepts>
#include <strings.h>
 
#include "esphome/core/optional.h"
 
#ifdef USE_ESP8266
#include <Esp.h>
#include <pgmspace.h>
#endif
 
#ifdef USE_RP2040
#include <Arduino.h>
#endif
 
#ifdef USE_ESP32
#include <esp_heap_caps.h>
#endif
 
#if defined(USE_ESP32)
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
#elif defined(USE_LIBRETINY)
#include <FreeRTOS.h>
#include <semphr.h>
#endif
 
#ifdef USE_HOST
#include <mutex>
#endif
 
#define HOT __attribute__((hot))
#define ESPDEPRECATED(msg, when) __attribute__((deprecated(msg)))
#define ESPHOME_ALWAYS_INLINE __attribute__((always_inline))
#define PACKED __attribute__((packed))
 
namespace esphome {
 
// Forward declaration to avoid circular dependency with string_ref.h
class StringRef;
 
 
// Keep "using" even after the removal of our backports, to avoid breaking existing code.
using std::to_string;
using std::is_trivially_copyable;
using std::make_unique;
using std::enable_if_t;
using std::clamp;
using std::is_invocable;
#if __cpp_lib_bit_cast >= 201806
using std::bit_cast;
#else
template<
    typename To, typename From,
    enable_if_t<sizeof(To) == sizeof(From) && is_trivially_copyable<From>::value && is_trivially_copyable<To>::value,
                int> = 0>
To bit_cast(const From &src) {
  To dst;
  memcpy(&dst, &src, sizeof(To));
  return dst;
}
#endif
 
// clang-format off
inline float lerp(float completion, float start, float end) = delete;  // Please use std::lerp. Notice that it has different order on arguments!
// clang-format on
 
// std::byteswap from C++23
template<typename T> constexpr T byteswap(T n) {
  T m;
  for (size_t i = 0; i < sizeof(T); i++)
    reinterpret_cast<uint8_t *>(&m)[i] = reinterpret_cast<uint8_t *>(&n)[sizeof(T) - 1 - i];
  return m;
}
template<> constexpr uint8_t byteswap(uint8_t n) { return n; }
#ifdef USE_LIBRETINY
// LibreTiny's Beken framework redefines __builtin_bswap functions as non-constexpr
template<> inline uint16_t byteswap(uint16_t n) { return __builtin_bswap16(n); }
template<> inline uint32_t byteswap(uint32_t n) { return __builtin_bswap32(n); }
template<> inline uint64_t byteswap(uint64_t n) { return __builtin_bswap64(n); }
template<> inline int8_t byteswap(int8_t n) { return n; }
template<> inline int16_t byteswap(int16_t n) { return __builtin_bswap16(n); }
template<> inline int32_t byteswap(int32_t n) { return __builtin_bswap32(n); }
template<> inline int64_t byteswap(int64_t n) { return __builtin_bswap64(n); }
#else
template<> constexpr uint16_t byteswap(uint16_t n) { return __builtin_bswap16(n); }
template<> constexpr uint32_t byteswap(uint32_t n) { return __builtin_bswap32(n); }
template<> constexpr uint64_t byteswap(uint64_t n) { return __builtin_bswap64(n); }
template<> constexpr int8_t byteswap(int8_t n) { return n; }
template<> constexpr int16_t byteswap(int16_t n) { return __builtin_bswap16(n); }
template<> constexpr int32_t byteswap(int32_t n) { return __builtin_bswap32(n); }
template<> constexpr int64_t byteswap(int64_t n) { return __builtin_bswap64(n); }
#endif
 
 
 
 
template<typename T> class ConstVector {
 public:
  constexpr ConstVector(const T *data, size_t size) : data_(data), size_(size) {}
 
  const constexpr T &operator[](size_t i) const { return data_[i]; }
  constexpr size_t size() const { return size_; }
  constexpr bool empty() const { return size_ == 0; }
 
 protected:
  const T *data_;
  size_t size_;
};
 
template<size_t InlineSize = 8> class SmallInlineBuffer {
 public:
  SmallInlineBuffer() = default;
  ~SmallInlineBuffer() {
    if (!this->is_inline_())
      delete[] this->heap_;
  }
 
  // Move constructor
  SmallInlineBuffer(SmallInlineBuffer &&other) noexcept : len_(other.len_) {
    if (other.is_inline_()) {
      memcpy(this->inline_, other.inline_, this->len_);
    } else {
      this->heap_ = other.heap_;
      other.heap_ = nullptr;
    }
    other.len_ = 0;
  }
 
  // Move assignment
  SmallInlineBuffer &operator=(SmallInlineBuffer &&other) noexcept {
    if (this != &other) {
      if (!this->is_inline_())
        delete[] this->heap_;
      this->len_ = other.len_;
      if (other.is_inline_()) {
        memcpy(this->inline_, other.inline_, this->len_);
      } else {
        this->heap_ = other.heap_;
        other.heap_ = nullptr;
      }
      other.len_ = 0;
    }
    return *this;
  }
 
  // Disable copy (would need deep copy of heap data)
  SmallInlineBuffer(const SmallInlineBuffer &) = delete;
  SmallInlineBuffer &operator=(const SmallInlineBuffer &) = delete;
 
  void set(const uint8_t *src, size_t size) {
    // Free existing heap allocation if switching from heap to inline or different heap size
    if (!this->is_inline_() && (size <= InlineSize || size != this->len_)) {
      delete[] this->heap_;
      this->heap_ = nullptr;  // Defensive: prevent use-after-free if logic changes
    }
    // Allocate new heap buffer if needed
    if (size > InlineSize && (this->is_inline_() || size != this->len_)) {
      this->heap_ = new uint8_t[size];  // NOLINT(cppcoreguidelines-owning-memory)
    }
    this->len_ = size;
    memcpy(this->data(), src, size);
  }
 
  uint8_t *data() { return this->is_inline_() ? this->inline_ : this->heap_; }
  const uint8_t *data() const { return this->is_inline_() ? this->inline_ : this->heap_; }
  size_t size() const { return this->len_; }
 
 protected:
  bool is_inline_() const { return this->len_ <= InlineSize; }
 
  size_t len_{0};
  union {
    uint8_t inline_[InlineSize]{};  // Zero-init ensures clean initial state
    uint8_t *heap_;
  };
};
 
template<typename T, size_t N> class StaticVector {
 public:
  using value_type = T;
  using iterator = typename std::array<T, N>::iterator;
  using const_iterator = typename std::array<T, N>::const_iterator;
  using reverse_iterator = std::reverse_iterator<iterator>;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
 private:
  std::array<T, N> data_;  // intentionally not value-initialized to avoid memset
  size_t count_{0};
 
 public:
  // Default constructor
  StaticVector() = default;
 
  // Iterator range constructor
  template<typename InputIt> StaticVector(InputIt first, InputIt last) {
    while (first != last && count_ < N) {
      data_[count_++] = *first++;
    }
  }
 
  // Initializer list constructor
  StaticVector(std::initializer_list<T> init) {
    for (const auto &val : init) {
      if (count_ >= N)
        break;
      data_[count_++] = val;
    }
  }
 
  // Minimal vector-compatible interface - only what we actually use
  void push_back(const T &value) {
    if (count_ < N) {
      data_[count_++] = value;
    }
  }
 
  // Clear all elements
  void clear() { count_ = 0; }
 
  // Assign from iterator range
  template<typename InputIt> void assign(InputIt first, InputIt last) {
    count_ = 0;
    while (first != last && count_ < N) {
      data_[count_++] = *first++;
    }
  }
 
  // Return reference to next element and increment count (with bounds checking)
  T &emplace_next() {
    if (count_ >= N) {
      // Should never happen with proper size calculation
      // Return reference to last element to avoid crash
      return data_[N - 1];
    }
    return data_[count_++];
  }
 
  size_t size() const { return count_; }
  bool empty() const { return count_ == 0; }
 
  // Direct access to underlying data
  T *data() { return data_.data(); }
  const T *data() const { return data_.data(); }
 
  T &operator[](size_t i) { return data_[i]; }
  const T &operator[](size_t i) const { return data_[i]; }
 
  // For range-based for loops
  iterator begin() { return data_.begin(); }
  iterator end() { return data_.begin() + count_; }
  const_iterator begin() const { return data_.begin(); }
  const_iterator end() const { return data_.begin() + count_; }
 
  // Reverse iterators
  reverse_iterator rbegin() { return reverse_iterator(end()); }
  reverse_iterator rend() { return reverse_iterator(begin()); }
  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 
  // Conversion to std::span for compatibility with span-based APIs
  operator std::span<T>() { return std::span<T>(data_.data(), count_); }
  operator std::span<const T>() const { return std::span<const T>(data_.data(), count_); }
};
 
template<typename T, size_t N> class StaticRingBuffer {
  using index_type = std::conditional_t<(N <= std::numeric_limits<uint8_t>::max()), uint8_t, uint16_t>;
 
 public:
  class Iterator {
   public:
    Iterator(StaticRingBuffer *buf, index_type pos) : buf_(buf), pos_(pos) {}
    T &operator*() { return buf_->data_[(buf_->head_ + pos_) % N]; }
    Iterator &operator++() {
      ++pos_;
      return *this;
    }
    bool operator!=(const Iterator &other) const { return pos_ != other.pos_; }
 
   private:
    StaticRingBuffer *buf_;
    index_type pos_;
  };
 
  class ConstIterator {
   public:
    ConstIterator(const StaticRingBuffer *buf, index_type pos) : buf_(buf), pos_(pos) {}
    const T &operator*() const { return buf_->data_[(buf_->head_ + pos_) % N]; }
    ConstIterator &operator++() {
      ++pos_;
      return *this;
    }
    bool operator!=(const ConstIterator &other) const { return pos_ != other.pos_; }
 
   private:
    const StaticRingBuffer *buf_;
    index_type pos_;
  };
 
  bool push(const T &value) {
    if (this->count_ >= N) {
      return false;
    }
    this->data_[this->tail_] = value;
    this->tail_ = (this->tail_ + 1) % N;
    ++this->count_;
    return true;
  }
 
  void pop() {
    if (this->count_ > 0) {
      this->head_ = (this->head_ + 1) % N;
      --this->count_;
    }
  }
 
  T &front() { return this->data_[this->head_]; }
  const T &front() const { return this->data_[this->head_]; }
  index_type size() const { return this->count_; }
  bool empty() const { return this->count_ == 0; }
 
  void clear() {
    this->head_ = 0;
    this->tail_ = 0;
    this->count_ = 0;
  }
 
  Iterator begin() { return Iterator(this, 0); }
  Iterator end() { return Iterator(this, this->count_); }
  ConstIterator begin() const { return ConstIterator(this, 0); }
  ConstIterator end() const { return ConstIterator(this, this->count_); }
 
 protected:
  T data_[N];
  index_type head_{0};
  index_type tail_{0};
  index_type count_{0};
};
 
template<typename T, size_t MAX_CAPACITY = std::numeric_limits<uint16_t>::max()> class FixedRingBuffer {
  using index_type = std::conditional_t<
      (MAX_CAPACITY <= std::numeric_limits<uint8_t>::max()), uint8_t,
      std::conditional_t<(MAX_CAPACITY <= std::numeric_limits<uint16_t>::max()), uint16_t, uint32_t>>;
 
 public:
  class Iterator {
   public:
    Iterator(FixedRingBuffer *buf, index_type pos) : buf_(buf), pos_(pos) {}
    T &operator*() { return buf_->data_[(buf_->head_ + pos_) % buf_->capacity_]; }
    Iterator &operator++() {
      ++pos_;
      return *this;
    }
    bool operator!=(const Iterator &other) const { return pos_ != other.pos_; }
 
   private:
    FixedRingBuffer *buf_;
    index_type pos_;
  };
 
  class ConstIterator {
   public:
    ConstIterator(const FixedRingBuffer *buf, index_type pos) : buf_(buf), pos_(pos) {}
    const T &operator*() const { return buf_->data_[(buf_->head_ + pos_) % buf_->capacity_]; }
    ConstIterator &operator++() {
      ++pos_;
      return *this;
    }
    bool operator!=(const ConstIterator &other) const { return pos_ != other.pos_; }
 
   private:
    const FixedRingBuffer *buf_;
    index_type pos_;
  };
 
  FixedRingBuffer() = default;
  ~FixedRingBuffer() {
    if constexpr (std::is_trivially_copyable<T>::value && std::is_trivially_default_constructible<T>::value) {
      ::operator delete(this->data_);
    } else {
      delete[] this->data_;
    }
  }
 
  // Disable copy
  FixedRingBuffer(const FixedRingBuffer &) = delete;
  FixedRingBuffer &operator=(const FixedRingBuffer &) = delete;
 
  void init(index_type capacity) {
    if constexpr (std::is_trivially_copyable<T>::value && std::is_trivially_default_constructible<T>::value) {
      // Raw allocation without initialization (elements are written before read)
      // NOLINTNEXTLINE(bugprone-sizeof-expression)
      this->data_ = static_cast<T *>(::operator new(capacity * sizeof(T)));
    } else {
      this->data_ = new T[capacity];
    }
    this->capacity_ = capacity;
  }
 
  bool push(const T &value) {
    if (this->count_ >= this->capacity_)
      return false;
    this->data_[this->tail_] = value;
    this->tail_ = (this->tail_ + 1) % this->capacity_;
    ++this->count_;
    return true;
  }
 
  void push_overwrite(const T &value) {
    this->data_[this->tail_] = value;
    this->tail_ = (this->tail_ + 1) % this->capacity_;
    if (this->count_ >= this->capacity_) {
      // Buffer full - advance head to drop oldest, count stays at capacity
      this->head_ = this->tail_;
    } else {
      ++this->count_;
    }
  }
 
  void pop() {
    if (this->count_ > 0) {
      this->head_ = (this->head_ + 1) % this->capacity_;
      --this->count_;
    }
  }
 
  T &front() { return this->data_[this->head_]; }
  const T &front() const { return this->data_[this->head_]; }
  index_type size() const { return this->count_; }
  bool empty() const { return this->count_ == 0; }
  index_type capacity() const { return this->capacity_; }
  bool full() const { return this->count_ == this->capacity_; }
 
  void clear() {
    this->head_ = 0;
    this->tail_ = 0;
    this->count_ = 0;
  }
 
  Iterator begin() { return Iterator(this, 0); }
  Iterator end() { return Iterator(this, this->count_); }
  ConstIterator begin() const { return ConstIterator(this, 0); }
  ConstIterator end() const { return ConstIterator(this, this->count_); }
 
 protected:
  T *data_{nullptr};
  index_type head_{0};
  index_type tail_{0};
  index_type count_{0};
  index_type capacity_{0};
};
 
template<typename T, size_t N> inline void init_array_from(std::array<T, N> &dest, std::initializer_list<T> src) {
#ifdef ESPHOME_DEBUG
  assert(src.size() == N);
#endif
  if constexpr (std::is_trivially_copyable_v<T>) {
    __builtin_memcpy(dest.data(), src.begin(), N * sizeof(T));
  } else {
    size_t i = 0;
    for (const auto &v : src) {
      dest[i++] = v;
    }
  }
}
 
template<typename T> class FixedVector {
 private:
  T *data_{nullptr};
  size_t size_{0};
  size_t capacity_{0};
 
  // Helper to destroy all elements without freeing memory
  void destroy_elements_() {
    // Only call destructors for non-trivially destructible types
    if constexpr (!std::is_trivially_destructible<T>::value) {
      for (size_t i = 0; i < size_; i++) {
        data_[i].~T();
      }
    }
  }
 
  // Helper to destroy elements and free memory
  void cleanup_() {
    if (data_ != nullptr) {
      destroy_elements_();
      // Free raw memory
      ::operator delete(data_);
    }
  }
 
  // Helper to reset pointers after cleanup
  void reset_() {
    data_ = nullptr;
    capacity_ = 0;
    size_ = 0;
  }
 
  // Helper to assign from initializer list (shared by constructor and assignment operator)
  void assign_from_initializer_list_(std::initializer_list<T> init_list) {
    init(init_list.size());
    size_t idx = 0;
    for (const auto &item : init_list) {
      new (data_ + idx) T(item);
      ++idx;
    }
    size_ = init_list.size();
  }
 
 public:
  FixedVector() = default;
 
  FixedVector(std::initializer_list<T> init_list) { assign_from_initializer_list_(init_list); }
 
  ~FixedVector() { cleanup_(); }
 
  // Disable copy operations (avoid accidental expensive copies)
  FixedVector(const FixedVector &) = delete;
  FixedVector &operator=(const FixedVector &) = delete;
 
  // Enable move semantics (allows use in move-only containers like std::vector)
  FixedVector(FixedVector &&other) noexcept : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {
    other.reset_();
  }
 
  // Allow conversion to std::vector
  operator std::vector<T>() const { return {data_, data_ + size_}; }
 
  FixedVector &operator=(FixedVector &&other) noexcept {
    if (this != &other) {
      // Delete our current data
      cleanup_();
      // Take ownership of other's data
      data_ = other.data_;
      size_ = other.size_;
      capacity_ = other.capacity_;
      // Leave other in valid empty state
      other.reset_();
    }
    return *this;
  }
 
  FixedVector &operator=(std::initializer_list<T> init_list) {
    cleanup_();
    reset_();
    assign_from_initializer_list_(init_list);
    return *this;
  }
 
  // Allocate capacity - can be called multiple times to reinit
  // IMPORTANT: After calling init(), you MUST use push_back() to add elements.
  // Direct assignment via operator[] does NOT update the size counter.
  void init(size_t n) {
    cleanup_();
    reset_();
    if (n > 0) {
      // Allocate raw memory without calling constructors
      // sizeof(T) is correct here for any type T (value types, pointers, etc.)
      // NOLINTNEXTLINE(bugprone-sizeof-expression)
      data_ = static_cast<T *>(::operator new(n * sizeof(T)));
      capacity_ = n;
    }
  }
 
  // Clear the vector (destroy all elements, reset size to 0, keep capacity)
  void clear() {
    destroy_elements_();
    size_ = 0;
  }
 
  // Release all memory (destroys elements and frees memory)
  void release() {
    cleanup_();
    reset_();
  }
 
  void push_back(const T &value) {
    if (size_ < capacity_) {
      // Use placement new to construct the object in pre-allocated memory
      new (&data_[size_]) T(value);
      size_++;
    }
  }
 
  void push_back(T &&value) {
    if (size_ < capacity_) {
      // Use placement new to move-construct the object in pre-allocated memory
      new (&data_[size_]) T(std::move(value));
      size_++;
    }
  }
 
  template<typename... Args> T &emplace_back(Args &&...args) {
    // Use placement new to construct the object in pre-allocated memory
    new (&data_[size_]) T(std::forward<Args>(args)...);
    size_++;
    return data_[size_ - 1];
  }
 
  T &front() { return data_[0]; }
  const T &front() const { return data_[0]; }
 
  T &back() { return data_[size_ - 1]; }
  const T &back() const { return data_[size_ - 1]; }
 
  size_t size() const { return size_; }
  bool empty() const { return size_ == 0; }
  size_t capacity() const { return capacity_; }
  bool full() const { return size_ == capacity_; }
 
  T &operator[](size_t i) { return data_[i]; }
  const T &operator[](size_t i) const { return data_[i]; }
 
  T &at(size_t i) { return data_[i]; }
  const T &at(size_t i) const { return data_[i]; }
 
  // Iterator support for range-based for loops
  T *begin() { return data_; }
  T *end() { return data_ + size_; }
  const T *begin() const { return data_; }
  const T *end() const { return data_ + size_; }
};
 
template<size_t STACK_SIZE, typename T = uint8_t> class SmallBufferWithHeapFallback {
 public:
  explicit SmallBufferWithHeapFallback(size_t size) {
    if (size <= STACK_SIZE) {
      this->buffer_ = this->stack_buffer_;
    } else {
      this->heap_buffer_ = new T[size];
      this->buffer_ = this->heap_buffer_;
    }
  }
  ~SmallBufferWithHeapFallback() { delete[] this->heap_buffer_; }
 
  // Delete copy and move operations to prevent double-delete
  SmallBufferWithHeapFallback(const SmallBufferWithHeapFallback &) = delete;
  SmallBufferWithHeapFallback &operator=(const SmallBufferWithHeapFallback &) = delete;
  SmallBufferWithHeapFallback(SmallBufferWithHeapFallback &&) = delete;
  SmallBufferWithHeapFallback &operator=(SmallBufferWithHeapFallback &&) = delete;
 
  T *get() { return this->buffer_; }
 
 private:
  T stack_buffer_[STACK_SIZE];
  T *heap_buffer_{nullptr};
  T *buffer_;
};
 
 
 
inline float pow10_int(int8_t exp) {
  float result = 1.0f;
  if (exp >= 0) {
    for (int8_t i = 0; i < exp; i++)
      result *= 10.0f;
  } else {
    for (int8_t i = exp; i < 0; i++)
      result /= 10.0f;
  }
  return result;
}
 
template<typename T, typename U> T remap(U value, U min, U max, T min_out, T max_out) {
  return (value - min) * (max_out - min_out) / (max - min) + min_out;
}
 
uint8_t crc8(const uint8_t *data, uint8_t len, uint8_t crc = 0x00, uint8_t poly = 0x8C, bool msb_first = false);
 
uint16_t crc16(const uint8_t *data, uint16_t len, uint16_t crc = 0xffff, uint16_t reverse_poly = 0xa001,
               bool refin = false, bool refout = false);
uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc = 0, uint16_t poly = 0x1021, bool refin = false,
                 bool refout = false);
 
uint32_t fnv1_hash(const char *str);
inline uint32_t fnv1_hash(const std::string &str) { return fnv1_hash(str.c_str()); }
 
constexpr uint32_t FNV1_OFFSET_BASIS = 2166136261UL;
constexpr uint32_t FNV1_PRIME = 16777619UL;
 
template<std::integral T> constexpr uint32_t fnv1_hash_extend(uint32_t hash, T value) {
  using UnsignedT = std::make_unsigned_t<T>;
  UnsignedT uvalue = static_cast<UnsignedT>(value);
  for (size_t i = 0; i < sizeof(T); i++) {
    hash *= FNV1_PRIME;
    hash ^= (uvalue >> (i * 8)) & 0xFF;
  }
  return hash;
}
constexpr uint32_t fnv1_hash_extend(uint32_t hash, const char *str) {
  if (str) {
    while (*str) {
      hash *= FNV1_PRIME;
      hash ^= *str++;
    }
  }
  return hash;
}
inline uint32_t fnv1_hash_extend(uint32_t hash, const std::string &str) { return fnv1_hash_extend(hash, str.c_str()); }
 
constexpr uint32_t fnv1a_hash_extend(uint32_t hash, const char *str) {
  if (str) {
    while (*str) {
      hash ^= *str++;
      hash *= FNV1_PRIME;
    }
  }
  return hash;
}
inline uint32_t fnv1a_hash_extend(uint32_t hash, const std::string &str) {
  return fnv1a_hash_extend(hash, str.c_str());
}
template<std::integral T> constexpr uint32_t fnv1a_hash_extend(uint32_t hash, T value) {
  using UnsignedT = std::make_unsigned_t<T>;
  UnsignedT uvalue = static_cast<UnsignedT>(value);
  for (size_t i = 0; i < sizeof(T); i++) {
    hash ^= (uvalue >> (i * 8)) & 0xFF;
    hash *= FNV1_PRIME;
  }
  return hash;
}
constexpr uint32_t fnv1a_hash(const char *str) { return fnv1a_hash_extend(FNV1_OFFSET_BASIS, str); }
inline uint32_t fnv1a_hash(const std::string &str) { return fnv1a_hash(str.c_str()); }
 
template<typename ReturnT = uint32_t> inline constexpr ESPHOME_ALWAYS_INLINE ReturnT micros_to_millis(uint64_t us) {
  constexpr uint32_t d = 125U;
  constexpr uint32_t q = static_cast<uint32_t>((1ULL << 32) / d);  // 34359738
  constexpr uint32_t r = static_cast<uint32_t>((1ULL << 32) % d);  // 46
  // 1000 = 8 * 125; divide-by-8 is a free shift
  uint64_t x = us >> 3;
  uint32_t lo = static_cast<uint32_t>(x);
  uint32_t hi = static_cast<uint32_t>(x >> 32);
  // Combine remainder term: hi * (2^32 % 125) + lo
  uint32_t adj = hi * r + lo;
  // If adj overflowed, the true value is 2^32 + adj; apply the identity again
  // static_cast<ReturnT>(hi) widens to 64-bit when ReturnT=uint64_t, preserving upper bits of hi*q
  return static_cast<ReturnT>(hi) * q + (adj < lo ? (adj + r) / d + q : adj / d);
}
 
uint32_t random_uint32();
float random_float();
bool random_bytes(uint8_t *data, size_t len);
 
 
 
constexpr uint16_t encode_uint16(uint8_t msb, uint8_t lsb) {
  return (static_cast<uint16_t>(msb) << 8) | (static_cast<uint16_t>(lsb));
}
constexpr uint32_t encode_uint24(uint8_t byte1, uint8_t byte2, uint8_t byte3) {
  return (static_cast<uint32_t>(byte1) << 16) | (static_cast<uint32_t>(byte2) << 8) | (static_cast<uint32_t>(byte3));
}
constexpr uint32_t encode_uint32(uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4) {
  return (static_cast<uint32_t>(byte1) << 24) | (static_cast<uint32_t>(byte2) << 16) |
         (static_cast<uint32_t>(byte3) << 8) | (static_cast<uint32_t>(byte4));
}
 
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> constexpr T encode_value(const uint8_t *bytes) {
  T val = 0;
  for (size_t i = 0; i < sizeof(T); i++) {
    val <<= 8;
    val |= bytes[i];
  }
  return val;
}
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
constexpr T encode_value(const std::array<uint8_t, sizeof(T)> bytes) {
  return encode_value<T>(bytes.data());
}
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
constexpr std::array<uint8_t, sizeof(T)> decode_value(T val) {
  std::array<uint8_t, sizeof(T)> ret{};
  for (size_t i = sizeof(T); i > 0; i--) {
    ret[i - 1] = val & 0xFF;
    val >>= 8;
  }
  return ret;
}
 
inline uint8_t reverse_bits(uint8_t x) {
  x = ((x & 0xAA) >> 1) | ((x & 0x55) << 1);
  x = ((x & 0xCC) >> 2) | ((x & 0x33) << 2);
  x = ((x & 0xF0) >> 4) | ((x & 0x0F) << 4);
  return x;
}
inline uint16_t reverse_bits(uint16_t x) {
  return (reverse_bits(static_cast<uint8_t>(x & 0xFF)) << 8) | reverse_bits(static_cast<uint8_t>((x >> 8) & 0xFF));
}
inline uint32_t reverse_bits(uint32_t x) {
  return (reverse_bits(static_cast<uint16_t>(x & 0xFFFF)) << 16) |
         reverse_bits(static_cast<uint16_t>((x >> 16) & 0xFFFF));
}
 
template<typename T> constexpr T convert_big_endian(T val) {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  return byteswap(val);
#else
  return val;
#endif
}
 
template<typename T> constexpr T convert_little_endian(T val) {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  return val;
#else
  return byteswap(val);
#endif
}
 
 
 
bool str_equals_case_insensitive(const std::string &a, const std::string &b);
bool str_equals_case_insensitive(StringRef a, StringRef b);
inline bool str_equals_case_insensitive(const char *a, const char *b) { return strcasecmp(a, b) == 0; }
inline bool str_equals_case_insensitive(const std::string &a, const char *b) { return strcasecmp(a.c_str(), b) == 0; }
inline bool str_equals_case_insensitive(const char *a, const std::string &b) { return strcasecmp(a, b.c_str()) == 0; }
 
bool str_startswith(const std::string &str, const std::string &start);
bool str_endswith(const std::string &str, const std::string &end);
 
bool str_endswith_ignore_case(const char *str, size_t str_len, const char *suffix, size_t suffix_len);
inline bool str_endswith_ignore_case(const char *str, const char *suffix) {
  return str_endswith_ignore_case(str, strlen(str), suffix, strlen(suffix));
}
inline bool str_endswith_ignore_case(const std::string &str, const char *suffix) {
  return str_endswith_ignore_case(str.c_str(), str.size(), suffix, strlen(suffix));
}
 
std::string str_truncate(const std::string &str, size_t length);
 
std::string str_until(const char *str, char ch);
std::string str_until(const std::string &str, char ch);
 
std::string str_lower_case(const std::string &str);
std::string str_upper_case(const std::string &str);
 
constexpr char to_snake_case_char(char c) { return (c == ' ') ? '_' : (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c; }
std::string str_snake_case(const std::string &str);
 
constexpr char to_sanitized_char(char c) {
  return (c == '-' || c == '_' || (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) ? c : '_';
}
 
char *str_sanitize_to(char *buffer, size_t buffer_size, const char *str);
 
template<size_t N> inline char *str_sanitize_to(char (&buffer)[N], const char *str) {
  return str_sanitize_to(buffer, N, str);
}
 
std::string str_sanitize(const std::string &str);
 
inline uint32_t fnv1_hash_object_id(const char *str, size_t len) {
  uint32_t hash = FNV1_OFFSET_BASIS;
  for (size_t i = 0; i < len; i++) {
    hash *= FNV1_PRIME;
    // Apply snake_case (space->underscore, uppercase->lowercase) then sanitize
    hash ^= static_cast<uint8_t>(to_sanitized_char(to_snake_case_char(str[i])));
  }
  return hash;
}
 
std::string __attribute__((format(printf, 1, 3))) str_snprintf(const char *fmt, size_t len, ...);
 
std::string __attribute__((format(printf, 1, 2))) str_sprintf(const char *fmt, ...);
 
#ifdef USE_ESP8266
// ESP8266: Use vsnprintf_P to keep format strings in flash (PROGMEM)
// Format strings must be wrapped with PSTR() macro
inline size_t buf_append_printf_p(char *buf, size_t size, size_t pos, PGM_P fmt, ...) {
  if (pos >= size) {
    return size;
  }
  va_list args;
  va_start(args, fmt);
  int written = vsnprintf_P(buf + pos, size - pos, fmt, args);
  va_end(args);
  if (written < 0) {
    return pos;  // encoding error
  }
  return std::min(pos + static_cast<size_t>(written), size);
}
#define buf_append_printf(buf, size, pos, fmt, ...) buf_append_printf_p(buf, size, pos, PSTR(fmt), ##__VA_ARGS__)
#else
__attribute__((format(printf, 4, 5))) inline size_t buf_append_printf(char *buf, size_t size, size_t pos,
                                                                      const char *fmt, ...) {
  if (pos >= size) {
    return size;
  }
  va_list args;
  va_start(args, fmt);
  int written = vsnprintf(buf + pos, size - pos, fmt, args);
  va_end(args);
  if (written < 0) {
    return pos;  // encoding error
  }
  return std::min(pos + static_cast<size_t>(written), size);
}
#endif
 
inline size_t buf_append_str(char *buf, size_t size, size_t pos, const char *str) {
  if (pos >= size) {
    return size;
  }
  size_t remaining = size - pos - 1;  // reserve space for null terminator
  size_t len = strlen(str);
  if (len > remaining) {
    len = remaining;
  }
  memcpy(buf + pos, str, len);
  pos += len;
  buf[pos] = '\0';
  return pos;
}
 
std::string make_name_with_suffix(const std::string &name, char sep, const char *suffix_ptr, size_t suffix_len);
 
std::string make_name_with_suffix(const char *name, size_t name_len, char sep, const char *suffix_ptr,
                                  size_t suffix_len);
 
size_t make_name_with_suffix_to(char *buffer, size_t buffer_size, const char *name, size_t name_len, char sep,
                                const char *suffix_ptr, size_t suffix_len);
 
 
 
template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_unsigned<T>::value), int> = 0>
optional<T> parse_number(const char *str) {
  char *end = nullptr;
  unsigned long value = ::strtoul(str, &end, 10);  // NOLINT(google-runtime-int)
  if (end == str || *end != '\0' || value > std::numeric_limits<T>::max())
    return {};
  return value;
}
template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_unsigned<T>::value), int> = 0>
optional<T> parse_number(const std::string &str) {
  return parse_number<T>(str.c_str());
}
template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), int> = 0>
optional<T> parse_number(const char *str) {
  char *end = nullptr;
  signed long value = ::strtol(str, &end, 10);  // NOLINT(google-runtime-int)
  if (end == str || *end != '\0' || value < std::numeric_limits<T>::min() || value > std::numeric_limits<T>::max())
    return {};
  return value;
}
template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), int> = 0>
optional<T> parse_number(const std::string &str) {
  return parse_number<T>(str.c_str());
}
template<typename T, enable_if_t<(std::is_same<T, float>::value), int> = 0> optional<T> parse_number(const char *str) {
  char *end = nullptr;
  float value = ::strtof(str, &end);
  if (end == str || *end != '\0' || value == HUGE_VALF)
    return {};
  return value;
}
template<typename T, enable_if_t<(std::is_same<T, float>::value), int> = 0>
optional<T> parse_number(const std::string &str) {
  return parse_number<T>(str.c_str());
}
 
size_t parse_hex(const char *str, size_t len, uint8_t *data, size_t count);
inline bool parse_hex(const char *str, uint8_t *data, size_t count) {
  return parse_hex(str, strlen(str), data, count) == 2 * count;
}
inline bool parse_hex(const std::string &str, uint8_t *data, size_t count) {
  return parse_hex(str.c_str(), str.length(), data, count) == 2 * count;
}
inline bool parse_hex(const char *str, std::vector<uint8_t> &data, size_t count) {
  data.resize(count);
  return parse_hex(str, strlen(str), data.data(), count) == 2 * count;
}
inline bool parse_hex(const std::string &str, std::vector<uint8_t> &data, size_t count) {
  data.resize(count);
  return parse_hex(str.c_str(), str.length(), data.data(), count) == 2 * count;
}
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
optional<T> parse_hex(const char *str, size_t len) {
  T val = 0;
  if (len > 2 * sizeof(T) || parse_hex(str, len, reinterpret_cast<uint8_t *>(&val), sizeof(T)) == 0)
    return {};
  return convert_big_endian(val);
}
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> optional<T> parse_hex(const char *str) {
  return parse_hex<T>(str, strlen(str));
}
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> optional<T> parse_hex(const std::string &str) {
  return parse_hex<T>(str.c_str(), str.length());
}
 
static constexpr uint8_t INVALID_HEX_CHAR = 255;
 
constexpr uint8_t parse_hex_char(char c) {
  if (c >= '0' && c <= '9')
    return c - '0';
  if (c >= 'A' && c <= 'F')
    return c - 'A' + 10;
  if (c >= 'a' && c <= 'f')
    return c - 'a' + 10;
  return INVALID_HEX_CHAR;
}
 
ESPHOME_ALWAYS_INLINE inline char format_hex_char(uint8_t v, char base) { return v >= 10 ? base + (v - 10) : '0' + v; }
 
ESPHOME_ALWAYS_INLINE inline char format_hex_char(uint8_t v) { return format_hex_char(v, 'a'); }
 
ESPHOME_ALWAYS_INLINE inline char format_hex_pretty_char(uint8_t v) { return format_hex_char(v, 'A'); }
 
inline char *int8_to_str(char *buf, int8_t val) {
  int32_t v = val;
  if (v < 0) {
    *buf++ = '-';
    v = -v;
  }
  if (v >= 100) {
    *buf++ = '1';  // int8 max is 128, so hundreds digit is always 1
    v -= 100;
    // Must write tens digit (even if 0) after hundreds
    int32_t tens = v / 10;
    *buf++ = '0' + tens;
    v -= tens * 10;
  } else if (v >= 10) {
    int32_t tens = v / 10;
    *buf++ = '0' + tens;
    v -= tens * 10;
  }
  *buf++ = '0' + v;
  return buf;
}
 
static constexpr size_t UINT32_MAX_STR_SIZE = 11;
 
char *uint32_to_str_unchecked(char *buf, uint32_t val);
 
inline size_t uint32_to_str(std::span<char, UINT32_MAX_STR_SIZE> buf, uint32_t val) {
  char *end = uint32_to_str_unchecked(buf.data(), val);
  *end = '\0';
  return static_cast<size_t>(end - buf.data());
}
 
char *format_hex_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);
 
template<size_t N> inline char *format_hex_to(char (&buffer)[N], const uint8_t *data, size_t length) {
  static_assert(N >= 3, "Buffer must hold at least one hex byte (3 chars)");
  return format_hex_to(buffer, N, data, length);
}
 
template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
inline char *format_hex_to(char (&buffer)[N], T val) {
  static_assert(N >= sizeof(T) * 2 + 1, "Buffer too small for type");
  val = convert_big_endian(val);
  return format_hex_to(buffer, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
}
 
template<size_t N> inline char *format_hex_to(char (&buffer)[N], const std::vector<uint8_t> &data) {
  return format_hex_to(buffer, data.data(), data.size());
}
 
template<size_t N, size_t M> inline char *format_hex_to(char (&buffer)[N], const std::array<uint8_t, M> &data) {
  return format_hex_to(buffer, data.data(), data.size());
}
 
constexpr size_t format_hex_size(size_t byte_count) { return byte_count * 2 + 1; }
 
constexpr size_t format_hex_prefixed_size(size_t byte_count) { return byte_count * 2 + 3; }
 
template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
inline char *format_hex_prefixed_to(char (&buffer)[N], T val) {
  static_assert(N >= sizeof(T) * 2 + 3, "Buffer too small for prefixed hex");
  buffer[0] = '0';
  buffer[1] = 'x';
  val = convert_big_endian(val);
  format_hex_to(buffer + 2, N - 2, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
  return buffer;
}
 
template<size_t N> inline char *format_hex_prefixed_to(char (&buffer)[N], const uint8_t *data, size_t length) {
  static_assert(N >= 5, "Buffer must hold at least '0x' + one hex byte + null");
  buffer[0] = '0';
  buffer[1] = 'x';
  format_hex_to(buffer + 2, N - 2, data, length);
  return buffer;
}
 
constexpr size_t format_hex_pretty_size(size_t byte_count) { return byte_count * 3; }
 
char *format_hex_pretty_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator = ':');
 
template<size_t N>
inline char *format_hex_pretty_to(char (&buffer)[N], const uint8_t *data, size_t length, char separator = ':') {
  static_assert(N >= 3, "Buffer must hold at least one hex byte");
  return format_hex_pretty_to(buffer, N, data, length, separator);
}
 
template<size_t N>
inline char *format_hex_pretty_to(char (&buffer)[N], const std::vector<uint8_t> &data, char separator = ':') {
  return format_hex_pretty_to(buffer, data.data(), data.size(), separator);
}
 
template<size_t N, size_t M>
inline char *format_hex_pretty_to(char (&buffer)[N], const std::array<uint8_t, M> &data, char separator = ':') {
  return format_hex_pretty_to(buffer, data.data(), data.size(), separator);
}
 
constexpr size_t format_hex_pretty_uint16_size(size_t count) { return count * 5; }
 
char *format_hex_pretty_to(char *buffer, size_t buffer_size, const uint16_t *data, size_t length, char separator = ':');
 
template<size_t N>
inline char *format_hex_pretty_to(char (&buffer)[N], const uint16_t *data, size_t length, char separator = ':') {
  static_assert(N >= 5, "Buffer must hold at least one hex uint16_t");
  return format_hex_pretty_to(buffer, N, data, length, separator);
}
 
static constexpr size_t MAC_ADDRESS_SIZE = 6;
static constexpr size_t MAC_ADDRESS_PRETTY_BUFFER_SIZE = format_hex_pretty_size(MAC_ADDRESS_SIZE);
static constexpr size_t MAC_ADDRESS_BUFFER_SIZE = MAC_ADDRESS_SIZE * 2 + 1;
 
inline char *format_mac_addr_upper(const uint8_t *mac, char *output) {
  return format_hex_pretty_to(output, MAC_ADDRESS_PRETTY_BUFFER_SIZE, mac, MAC_ADDRESS_SIZE, ':');
}
 
inline void format_mac_addr_lower_no_sep(const uint8_t *mac, char *output) {
  format_hex_to(output, MAC_ADDRESS_BUFFER_SIZE, mac, MAC_ADDRESS_SIZE);
}
 
std::string format_mac_address_pretty(const uint8_t mac[6]);
std::string format_hex(const uint8_t *data, size_t length);
std::string format_hex(const std::vector<uint8_t> &data);
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_hex(T val) {
  val = convert_big_endian(val);
  return format_hex(reinterpret_cast<uint8_t *>(&val), sizeof(T));
}
template<std::size_t N> std::string format_hex(const std::array<uint8_t, N> &data) {
  return format_hex(data.data(), data.size());
}
 
std::string format_hex_pretty(const uint8_t *data, size_t length, char separator = '.', bool show_length = true);
 
std::string format_hex_pretty(const uint16_t *data, size_t length, char separator = '.', bool show_length = true);
 
std::string format_hex_pretty(const std::vector<uint8_t> &data, char separator = '.', bool show_length = true);
 
std::string format_hex_pretty(const std::vector<uint16_t> &data, char separator = '.', bool show_length = true);
 
std::string format_hex_pretty(const std::string &data, char separator = '.', bool show_length = true);
 
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
std::string format_hex_pretty(T val, char separator = '.', bool show_length = true) {
  val = convert_big_endian(val);
  return format_hex_pretty(reinterpret_cast<uint8_t *>(&val), sizeof(T), separator, show_length);
}
 
constexpr size_t format_bin_size(size_t byte_count) { return byte_count * 8 + 1; }
 
char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);
 
template<size_t N> inline char *format_bin_to(char (&buffer)[N], const uint8_t *data, size_t length) {
  static_assert(N >= 9, "Buffer must hold at least one binary byte (9 chars)");
  return format_bin_to(buffer, N, data, length);
}
 
template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
inline char *format_bin_to(char (&buffer)[N], T val) {
  static_assert(N >= sizeof(T) * 8 + 1, "Buffer too small for type");
  val = convert_big_endian(val);
  return format_bin_to(buffer, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
}
 
std::string format_bin(const uint8_t *data, size_t length);
template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_bin(T val) {
  val = convert_big_endian(val);
  return format_bin(reinterpret_cast<uint8_t *>(&val), sizeof(T));
}
 
enum ParseOnOffState : uint8_t {
  PARSE_NONE = 0,
  PARSE_ON,
  PARSE_OFF,
  PARSE_TOGGLE,
};
ParseOnOffState parse_on_off(const char *str, const char *on = nullptr, const char *off = nullptr);
 
ESPDEPRECATED("Allocates heap memory. Use value_accuracy_to_buf() instead. Removed in 2026.7.0.", "2026.1.0")
std::string value_accuracy_to_string(float value, int8_t accuracy_decimals);
 
static constexpr size_t VALUE_ACCURACY_MAX_LEN = 64;
 
size_t value_accuracy_to_buf(std::span<char, VALUE_ACCURACY_MAX_LEN> buf, float value, int8_t accuracy_decimals);
size_t value_accuracy_with_uom_to_buf(std::span<char, VALUE_ACCURACY_MAX_LEN> buf, float value,
                                      int8_t accuracy_decimals, StringRef unit_of_measurement);
 
int8_t step_to_accuracy_decimals(float step);
 
std::string base64_encode(const uint8_t *buf, size_t buf_len);
std::string base64_encode(const std::vector<uint8_t> &buf);
 
std::vector<uint8_t> base64_decode(const std::string &encoded_string);
size_t base64_decode(std::string const &encoded_string, uint8_t *buf, size_t buf_len);
size_t base64_decode(const uint8_t *encoded_data, size_t encoded_len, uint8_t *buf, size_t buf_len);
 
bool base64_decode_int32_vector(const std::string &base64, std::vector<int32_t> &out);
 
 
 
// Remove before 2026.9.0
ESPDEPRECATED("Use LightState::gamma_correct_lut() instead. Removed in 2026.9.0.", "2026.3.0")
float gamma_correct(float value, float gamma);
// Remove before 2026.9.0
ESPDEPRECATED("Use LightState::gamma_uncorrect_lut() instead. Removed in 2026.9.0.", "2026.3.0")
float gamma_uncorrect(float value, float gamma);
 
void rgb_to_hsv(float red, float green, float blue, int &hue, float &saturation, float &value);
void hsv_to_rgb(int hue, float saturation, float value, float &red, float &green, float &blue);
 
 
 
constexpr float celsius_to_fahrenheit(float value) { return value * 1.8f + 32.0f; }
constexpr float fahrenheit_to_celsius(float value) { return (value - 32.0f) / 1.8f; }
 
 
 
template<typename... X> struct Callback;
 
template<typename... Ts> struct Callback<void(Ts...)> {
  // The inline storage path stores callable bytes in ctx_ via memcpy.
  // sizeof equality with uintptr_t ensures void* can round-trip arbitrary bit patterns,
  // which combined with flat address spaces on all ESPHome targets means no trap representations.
  static_assert(sizeof(void *) == sizeof(std::uintptr_t), "void* must be the same size as uintptr_t");
 
  void (*fn_)(void *, Ts...){nullptr};
  void *ctx_{nullptr};
 
  void call(Ts... args) const { this->fn_(this->ctx_, args...); }
 
  template<typename F> static Callback create(F &&callable) {
    using DecayF = std::decay_t<F>;
    if constexpr (sizeof(DecayF) <= sizeof(void *) && std::is_trivially_copyable_v<DecayF>) {
      // Small trivial callable (e.g. [this]() { this->method(); }) - store inline in ctx.
      // Safe under C++20 (P0593R6): byte copy into aligned storage implicitly
      // creates objects of implicit-lifetime types (trivially copyable qualifies).
      Callback cb;  // fn and ctx are zero-initialized by default
      // Decay callable to a local variable first. When F is a function reference
      // (e.g. void(&)(int)), &callable would point at machine code, not a pointer variable.
      DecayF decayed = std::forward<F>(callable);
      __builtin_memcpy(&cb.ctx_, &decayed, sizeof(DecayF));
      cb.fn_ = [](void *c, Ts... args) {
        alignas(DecayF) char buf[sizeof(DecayF)];
        __builtin_memcpy(buf, &c, sizeof(DecayF));
        (*std::launder(reinterpret_cast<DecayF *>(buf)))(args...);
      };
      return cb;
    } else {
      // Large or non-trivial callable - heap allocate.
      // Intentionally never freed: callbacks in ESPHome are registered during setup()
      // and live for device lifetime. Same lifetime as the previous std::function approach.
      auto *stored = new DecayF(std::forward<F>(callable));
      return {[](void *c, Ts... args) { (*static_cast<DecayF *>(c))(args...); }, static_cast<void *>(stored)};
    }
  }
};
 
void *callback_manager_grow(void *data, uint16_t size, uint16_t &capacity, size_t elem_size);
 
template<typename... X> class CallbackManager;
 
template<typename... Ts> class CallbackManager<void(Ts...)> {
  using CbType = Callback<void(Ts...)>;
  static_assert(std::is_trivially_copyable_v<CbType>, "Callback must be trivially copyable");
 
 public:
  CallbackManager() = default;
  ~CallbackManager() { ::operator delete(this->data_); }
 
  // Non-copyable (would alias data_), movable (for std::map support)
  CallbackManager(const CallbackManager &) = delete;
  CallbackManager &operator=(const CallbackManager &) = delete;
  CallbackManager(CallbackManager &&other) noexcept
      : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {
    other.data_ = nullptr;
    other.size_ = 0;
    other.capacity_ = 0;
  }
  CallbackManager &operator=(CallbackManager &&other) noexcept {
    std::swap(this->data_, other.data_);
    std::swap(this->size_, other.size_);
    std::swap(this->capacity_, other.capacity_);
    return *this;
  }
 
  template<typename F> void add(F &&callback) { this->add_(CbType::create(std::forward<F>(callback))); }
 
  inline void ESPHOME_ALWAYS_INLINE call(Ts... args) {
    if (this->size_ != 0) {
      for (auto *it = this->data_, *end = it + this->size_; it != end; ++it) {
        it->call(args...);
      }
    }
  }
  uint16_t size() const { return this->size_; }
 
  void operator()(Ts... args) { this->call(args...); }
 
 protected:
  template<typename...> friend class LazyCallbackManager;
  void add_(CbType cb) {
    if (this->size_ == this->capacity_) {
      this->data_ =
          static_cast<CbType *>(callback_manager_grow(this->data_, this->size_, this->capacity_, sizeof(CbType)));
    }
    this->data_[this->size_++] = cb;
  }
  CbType *data_{nullptr};
  uint16_t size_{0};
  uint16_t capacity_{0};
};
 
template<size_t N, typename... X> class StaticCallbackManager;
 
template<size_t N, typename... Ts> class StaticCallbackManager<N, void(Ts...)> {
 public:
  template<typename F> void add(F &&callback) { this->add_(Callback<void(Ts...)>::create(std::forward<F>(callback))); }
 
  void call(Ts... args) {
    for (auto &cb : this->callbacks_)
      cb.call(args...);
  }
  size_t size() const { return this->callbacks_.size(); }
 
  void operator()(Ts... args) { call(args...); }
 
 protected:
  void add_(Callback<void(Ts...)> cb) { this->callbacks_.push_back(cb); }
  StaticVector<Callback<void(Ts...)>, N> callbacks_;
};
 
template<typename... X> class LazyCallbackManager;
 
template<typename... Ts> class LazyCallbackManager<void(Ts...)> {
 public:
  LazyCallbackManager() = default;
  ~LazyCallbackManager() { delete this->callbacks_; }
 
  // Non-copyable and non-movable (entities are never copied or moved)
  LazyCallbackManager(const LazyCallbackManager &) = delete;
  LazyCallbackManager &operator=(const LazyCallbackManager &) = delete;
  LazyCallbackManager(LazyCallbackManager &&) = delete;
  LazyCallbackManager &operator=(LazyCallbackManager &&) = delete;
 
  template<typename F> void add(F &&callback) { this->add_(Callback<void(Ts...)>::create(std::forward<F>(callback))); }
 
  void call(Ts... args) {
    if (this->callbacks_) {
      this->callbacks_->call(args...);
    }
  }
 
  size_t size() const { return this->callbacks_ ? this->callbacks_->size() : 0; }
 
  bool empty() const { return !this->callbacks_ || this->callbacks_->size() == 0; }
 
  void operator()(Ts... args) { this->call(args...); }
 
 protected:
  void add_(Callback<void(Ts...)> cb) {
    if (!this->callbacks_) {
      this->callbacks_ = new CallbackManager<void(Ts...)>();
    }
    this->callbacks_->add_(cb);
  }
  CallbackManager<void(Ts...)> *callbacks_{nullptr};
};
 
template<typename T> class Deduplicator {
 public:
  bool next(T value) {
    if (this->has_value_ && !this->value_unknown_ && this->last_value_ == value) {
      return false;
    }
    this->has_value_ = true;
    this->value_unknown_ = false;
    this->last_value_ = value;
    return true;
  }
  bool next_unknown() {
    bool ret = !this->value_unknown_;
    this->value_unknown_ = true;
    return ret;
  }
  bool has_value() const { return this->has_value_; }
 
 protected:
  bool has_value_{false};
  bool value_unknown_{false};
  T last_value_{};
};
 
template<typename T> class Parented {
 public:
  Parented() {}
  Parented(T *parent) : parent_(parent) {}
 
  T *get_parent() const { return parent_; }
  void set_parent(T *parent) { parent_ = parent; }
 
 protected:
  T *parent_{nullptr};
};
 
 
 
class Mutex {
 public:
  Mutex(const Mutex &) = delete;
  Mutex &operator=(const Mutex &) = delete;
 
#if defined(USE_ESP8266) || defined(USE_RP2040)
  // Single-threaded platforms: inline no-ops so the compiler eliminates all call overhead.
  Mutex() = default;
  ~Mutex() = default;
  void lock() {}
  bool try_lock() { return true; }
  void unlock() {}
#elif defined(USE_ESP32) || defined(USE_LIBRETINY)
  // FreeRTOS platforms: inline to avoid out-of-line call overhead.
  Mutex() { handle_ = xSemaphoreCreateMutex(); }
  ~Mutex() = default;
  void lock() { xSemaphoreTake(this->handle_, portMAX_DELAY); }
  bool try_lock() { return xSemaphoreTake(this->handle_, 0) == pdTRUE; }
  void unlock() { xSemaphoreGive(this->handle_); }
 
 private:
  SemaphoreHandle_t handle_;
#else
  Mutex();
  ~Mutex();
  void lock();
  bool try_lock();
  void unlock();
 
 private:
  // d-pointer to store private data on new platforms
  void *handle_;  // NOLINT(clang-diagnostic-unused-private-field)
#endif
};
 
class LockGuard {
 public:
  LockGuard(Mutex &mutex) : mutex_(mutex) { mutex_.lock(); }
  ~LockGuard() { mutex_.unlock(); }
 
 private:
  Mutex &mutex_;
};
 
class InterruptLock {
 public:
  InterruptLock();
  ~InterruptLock();
 
 protected:
#if defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_ZEPHYR)
  uint32_t state_;
#endif
};
 
class LwIPLock {
 public:
  LwIPLock(const LwIPLock &) = delete;
  LwIPLock &operator=(const LwIPLock &) = delete;
 
#if defined(USE_ESP32) || defined(USE_RP2040)
  // Platforms with potential lwIP core locking — out-of-line implementations in helpers.cpp
  LwIPLock();
  ~LwIPLock();
#else
  // No lwIP core locking — inline no-ops (empty bodies instead of = default
  // to prevent clang-tidy unused-variable warnings at call sites)
  LwIPLock() {}
  ~LwIPLock() {}
#endif
};
 
class HighFrequencyLoopRequester {
 public:
  void start();
  void stop();
 
  static bool is_high_frequency() { return num_requests > 0; }
 
 protected:
  bool started_{false};
  static uint8_t num_requests;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
};
 
void get_mac_address_raw(uint8_t *mac);  // NOLINT(readability-non-const-parameter)
 
std::string get_mac_address();
 
std::string get_mac_address_pretty();
 
void get_mac_address_into_buffer(std::span<char, MAC_ADDRESS_BUFFER_SIZE> buf);
 
const char *get_mac_address_pretty_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
 
#ifdef USE_ESP32
void set_mac_address(uint8_t *mac);
#endif
 
bool has_custom_mac_address();
 
bool mac_address_is_valid(const uint8_t *mac);
 
void delay_microseconds_safe(uint32_t us);
 
 
 
template<class T> class RAMAllocator {
 public:
  using value_type = T;
 
  enum Flags {
    NONE = 0,                 // Perform external allocation and fall back to internal memory
    ALLOC_EXTERNAL = 1 << 0,  // Perform external allocation only.
    ALLOC_INTERNAL = 1 << 1,  // Perform internal allocation only.
    ALLOW_FAILURE = 1 << 2,   // Does nothing. Kept for compatibility.
  };
 
  constexpr RAMAllocator() = default;
  constexpr RAMAllocator(uint8_t flags)
      : flags_((flags & (ALLOC_INTERNAL | ALLOC_EXTERNAL)) != 0 ? (flags & (ALLOC_INTERNAL | ALLOC_EXTERNAL))
                                                                : (ALLOC_INTERNAL | ALLOC_EXTERNAL)) {}
  template<class U> constexpr RAMAllocator(const RAMAllocator<U> &other) : flags_{other.flags_} {}
 
  T *allocate(size_t n) { return this->allocate(n, sizeof(T)); }
 
  T *allocate(size_t n, size_t manual_size) {
    size_t size = n * manual_size;
    T *ptr = nullptr;
#ifdef USE_ESP32
    if (this->flags_ & Flags::ALLOC_EXTERNAL) {
      ptr = static_cast<T *>(heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
    }
    if (ptr == nullptr && this->flags_ & Flags::ALLOC_INTERNAL) {
      ptr = static_cast<T *>(heap_caps_malloc(size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT));
    }
#else
    // Ignore ALLOC_EXTERNAL/ALLOC_INTERNAL flags if external allocation is not supported
    ptr = static_cast<T *>(malloc(size));  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
#endif
    return ptr;
  }
 
  T *reallocate(T *p, size_t n) { return this->reallocate(p, n, sizeof(T)); }
 
  T *reallocate(T *p, size_t n, size_t manual_size) {
    size_t size = n * manual_size;
    T *ptr = nullptr;
#ifdef USE_ESP32
    if (this->flags_ & Flags::ALLOC_EXTERNAL) {
      ptr = static_cast<T *>(heap_caps_realloc(p, size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
    }
    if (ptr == nullptr && this->flags_ & Flags::ALLOC_INTERNAL) {
      ptr = static_cast<T *>(heap_caps_realloc(p, size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT));
    }
#else
    // Ignore ALLOC_EXTERNAL/ALLOC_INTERNAL flags if external allocation is not supported
    ptr = static_cast<T *>(realloc(p, size));  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
#endif
    return ptr;
  }
 
  void deallocate(T *p, size_t n) {
    free(p);  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
  }
 
  size_t get_free_heap_size() const {
#ifdef USE_ESP8266
    return ESP.getFreeHeap();  // NOLINT(readability-static-accessed-through-instance)
#elif defined(USE_ESP32)
    auto max_internal =
        this->flags_ & ALLOC_INTERNAL ? heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL) : 0;
    auto max_external =
        this->flags_ & ALLOC_EXTERNAL ? heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM) : 0;
    return max_internal + max_external;
#elif defined(USE_RP2040)
    return ::rp2040.getFreeHeap();
#elif defined(USE_LIBRETINY)
    return lt_heap_get_free();
#else
    return 100000;
#endif
  }
 
  size_t get_max_free_block_size() const {
#ifdef USE_ESP8266
    return ESP.getMaxFreeBlockSize();  // NOLINT(readability-static-accessed-through-instance)
#elif defined(USE_ESP32)
    auto max_internal =
        this->flags_ & ALLOC_INTERNAL ? heap_caps_get_largest_free_block(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL) : 0;
    auto max_external =
        this->flags_ & ALLOC_EXTERNAL ? heap_caps_get_largest_free_block(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM) : 0;
    return std::max(max_internal, max_external);
#else
    return this->get_free_heap_size();
#endif
  }
 
 private:
  uint8_t flags_{ALLOC_INTERNAL | ALLOC_EXTERNAL};
};
 
template<class T> using ExternalRAMAllocator = RAMAllocator<T>;
 
template<typename T, typename U>
concept comparable_with = requires(T a, U b) {
  { a > b } -> std::convertible_to<bool>;
  { a < b } -> std::convertible_to<bool>;
};
 
template<std::totally_ordered T, comparable_with<T> U> T clamp_at_least(T value, U min) {
  if (value < min)
    return min;
  return value;
}
template<std::totally_ordered T, comparable_with<T> U> T clamp_at_most(T value, U max) {
  if (value > max)
    return max;
  return value;
}
 
 
template<typename T, enable_if_t<!std::is_pointer<T>::value, int> = 0> T id(T value) { return value; }
template<typename T, enable_if_t<std::is_pointer<T *>::value, int> = 0> T &id(T *value) { return *value; }
 
 
}  // namespace esphome