finite_set_mask.h

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <iterator>
#include <type_traits>
 
namespace esphome {
 
template<typename ValueType, int MaxBits> struct DefaultBitPolicy {
  // Automatic bitmask type selection based on MaxBits
  // ≤8 bits: uint8_t, ≤16 bits: uint16_t, otherwise: uint32_t
  using mask_t = typename std::conditional<(MaxBits <= 8), uint8_t,
                                           typename std::conditional<(MaxBits <= 16), uint16_t, uint32_t>::type>::type;
 
  static constexpr int MAX_BITS = MaxBits;
 
  static constexpr unsigned to_bit(ValueType value) { return static_cast<unsigned>(value); }
 
  static constexpr ValueType from_bit(unsigned bit) { return static_cast<ValueType>(bit); }
};
 
template<typename ValueType, typename BitPolicy = DefaultBitPolicy<ValueType, 16>> class FiniteSetMask {
 public:
  using bitmask_t = typename BitPolicy::mask_t;
 
  constexpr FiniteSetMask() = default;
 
  constexpr FiniteSetMask(std::initializer_list<ValueType> values) {
    for (auto value : values) {
      this->insert(value);
    }
  }
 
  constexpr void insert(ValueType value) { this->mask_ |= (static_cast<bitmask_t>(1) << BitPolicy::to_bit(value)); }
 
  constexpr void insert(std::initializer_list<ValueType> values) {
    for (auto value : values) {
      this->insert(value);
    }
  }
 
  constexpr void erase(ValueType value) { this->mask_ &= ~(static_cast<bitmask_t>(1) << BitPolicy::to_bit(value)); }
 
  constexpr void clear() { this->mask_ = 0; }
 
  constexpr size_t count(ValueType value) const {
    return (this->mask_ & (static_cast<bitmask_t>(1) << BitPolicy::to_bit(value))) != 0 ? 1 : 0;
  }
 
  constexpr size_t size() const {
    // Brian Kernighan's algorithm - efficient for sparse bitmasks
    // Typical case: 2-4 modes out of 10 possible
    bitmask_t n = this->mask_;
    size_t count = 0;
    while (n) {
      n &= n - 1;  // Clear the least significant set bit
      count++;
    }
    return count;
  }
 
  constexpr bool empty() const { return this->mask_ == 0; }
 
  class Iterator {
   public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = ValueType;
    using difference_type = std::ptrdiff_t;
    using pointer = const ValueType *;
    using reference = ValueType;
 
    constexpr explicit Iterator(bitmask_t mask) : mask_(mask) {}
 
    constexpr ValueType operator*() const {
      // Return value for the first set bit
      return BitPolicy::from_bit(find_next_set_bit(mask_, 0));
    }
 
    constexpr Iterator &operator++() {
      // Clear the lowest set bit (Brian Kernighan's algorithm)
      mask_ &= mask_ - 1;
      return *this;
    }
 
    constexpr bool operator==(const Iterator &other) const { return mask_ == other.mask_; }
 
    constexpr bool operator!=(const Iterator &other) const { return !(*this == other); }
 
   private:
    bitmask_t mask_;
  };
 
  constexpr Iterator begin() const { return Iterator(mask_); }
  constexpr Iterator end() const { return Iterator(0); }
 
  constexpr bitmask_t get_mask() const { return this->mask_; }
 
  static constexpr bool mask_contains(bitmask_t mask, ValueType value) {
    return (mask & (static_cast<bitmask_t>(1) << BitPolicy::to_bit(value))) != 0;
  }
 
  static constexpr ValueType first_value_from_mask(bitmask_t mask) {
    return BitPolicy::from_bit(find_next_set_bit(mask, 0));
  }
 
  static constexpr int find_next_set_bit(bitmask_t mask, int start_bit) {
    int bit = start_bit;
    while (bit < BitPolicy::MAX_BITS && !(mask & (static_cast<bitmask_t>(1) << bit))) {
      ++bit;
    }
    return bit;
  }
 
 protected:
  bitmask_t mask_{0};
};
 
}  // namespace esphome