Class bitset_dynamic

src/fl/stl/bitset_dynamic.h:20–261

/// A dynamic bitset implementation that can be resized at runtime
class bitset_dynamic {
  private:
    static constexpr fl::u32 bits_per_block = 8 * sizeof(fl::u16);
    using block_type = fl::u16;

    fl::unique_ptr<block_type[]> _blocks;
    fl::u32 _block_count = 0;
    fl::u32 _size = 0;

    // Helper to calculate block count from bit count
    static fl::u32 calc_block_count(fl::u32 bit_count) FL_NOEXCEPT {  // okay static in header
        return (bit_count + bits_per_block - 1) / bits_per_block;
    }

  public:
    // Default constructor
    bitset_dynamic() = default;

    // Constructor with initial size
    explicit bitset_dynamic(fl::u32 size) FL_NOEXCEPT { resize(size); }

    // Copy constructor
    bitset_dynamic(const bitset_dynamic &other) FL_NOEXCEPT {
        if (other._size > 0) {
            resize(other._size);
            fl::memcpy(_blocks.get(), other._blocks.get(), _block_count * sizeof(block_type));
        }
    }

    // Move constructor
    bitset_dynamic(bitset_dynamic &&other) FL_NOEXCEPT
        : _blocks(fl::move(other._blocks)), _block_count(other._block_count),
          _size(other._size) {
        other._block_count = 0;
        other._size = 0;
    }

    // Copy assignment
    bitset_dynamic &operator=(const bitset_dynamic &other) FL_NOEXCEPT {
        if (this != &other) {
            if (other._size > 0) {
                resize(other._size);
                fl::memcpy(_blocks.get(), other._blocks.get(),
                       _block_count * sizeof(block_type));
            } else {
                clear();
            }
        }
        return *this;
    }

    // Move assignment
    bitset_dynamic &operator=(bitset_dynamic &&other) FL_NOEXCEPT {
        if (this != &other) {
            _blocks = fl::move(other._blocks);
            _block_count = other._block_count;
            _size = other._size;
            other._block_count = 0;