bitfield.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_CONTAINERS_BITFIELD_H
#define FENNEC_CONTAINERS_BITFIELD_H
 
#include <fennec/containers/array.h>
#include <fennec/lang/types.h>
#include <fennec/lang/utility.h>
 
namespace fennec
{
 
template<size_t N>
struct bitfield {
    static constexpr size_t bits  = N;
    static constexpr size_t bytes = (N + 7) / 8;
 
public:
    constexpr bitfield()
        : _bytes() {
    }
 
    explicit constexpr bitfield(const bool (&arr)[N])
        : _bytes() {
        for (size_t i = 0; i < arr; ++i) {
            this->store(i, arr[i]);
        }
    }
 
    template<size_t I>
    explicit constexpr bitfield(const size_t (&arr)[I])
        : _bytes() {
        for (size_t i : arr) {
            this->set(i);
        }
    }
 
    template<typename...ArgsT>
    constexpr bitfield(ArgsT&&...args)
        : _bytes() {
        (this->store(fennec::forward<ArgsT>(args), true), ...);
    }
 
    template<typename...ArgsT> requires((is_bool_v<ArgsT> or is_convertible_v<ArgsT, bool>) and ...)
    constexpr bitfield(ArgsT&&...args)
        : _bytes() {
        size_t i = 0;
        (this->store(i++, fennec::forward<ArgsT>(args)), ...);
    }
 
    bitfield(const bitfield& bf)
        : _bytes(bf._bytes) {
    }
 
    bitfield(bitfield&& bf) noexcept
        : _bytes(bf._bytes) {
    }
 
    constexpr ~bitfield() = default;
 
    bitfield& operator=(const bitfield& bf) = default;
    bitfield& operator=(bitfield&& bf) noexcept = default;
 
    bool test(size_t i) const {
        assertd(i < bits, "Index out of Bounds!");
        size_t b = i / 8;
        size_t o = i % 8;
        return _bytes[b] & (1 << o);
    }
 
    void set(size_t i) {
        assertd(i < bits, "Index out of Bounds!");
        size_t b = i / 8;
        size_t o = i % 8;
        _bytes[b] |= (1 << o);
    }
 
    void clear(size_t i) {
        assertd(i < bits, "Index out of Bounds!");
        size_t b = i / 8;
        size_t o = i % 8;
        _bytes[b] &= ~(1 << o);
    }
 
    void toggle(size_t i) {
        assertd(i < bits, "Index out of Bounds!");
        size_t b = i / 8;
        size_t o = i % 8;
        _bytes[b] ^= (1 << o);
    }
 
    void store(size_t i, bool v) {
        assertd(i < bits, "Index out of Bounds!");
        size_t b = i / 8;
        size_t o = i % 8;
        (_bytes[b] &= ~((1 << o))) |= ((v << o));
    }
 
    bitfield operator~() const {
        bitfield res = *this;
        res._inv_helper(make_index_metasequence_t<bytes>{});
        return res;
    }
 
private:
    array<uint8_t, bytes> _bytes;
 
    template<size_t...I>
    void _inv_helper(index_metasequence<I...>) {
        ((_bytes[I] = ~_bytes[I]), ...);
    }
};
 
 
}
 
#endif // FENNEC_CONTAINERS_BITFIELD_H