BitFlag.hh

#pragma once
 
#include <Logger.hh>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>
 
namespace Kinoko {
 
// We can't include Common.hh, because we have a cyclic dependency
typedef uint32_t u32;
 
namespace EGG {
 
template <typename T, typename E>
    requires(std::is_enum_v<E> && std::is_integral_v<T>)
struct TBitFlag {
    constexpr TBitFlag() {
        makeAllZero();
    }
 
    constexpr TBitFlag(T mask) {
        setDirect(mask);
    }
 
    constexpr TBitFlag(E e) : TBitFlag() {
        setBit(e);
    }
 
    [[nodiscard]] constexpr operator T() const {
        return getDirect();
    }
 
    constexpr TBitFlag<T, E> &operator=(const TBitFlag<T, E> &rhs) {
        bits = rhs.bits;
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    constexpr TBitFlag<T, E> &setBit(Es... es) {
        (setBit_(es), ...);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    constexpr TBitFlag<T, E> &resetBit(Es... es) {
        (resetBit_(es), ...);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    constexpr TBitFlag<T, E> &changeBit(bool on, Es... es) {
        (changeBit_(on, es), ...);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    constexpr TBitFlag<T, E> &toggleBit(Es... es) {
        (toggleBit_(es), ...);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool onBit(Es... es) const {
        return (onAnyBit(es...));
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool onAnyBit(Es... es) const {
        return (onBit_(es) || ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool onAllBit(Es... es) const {
        return (onBit_(es) && ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool offBit(Es... es) const {
        return offAllBit(es...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool offAllBit(Es... es) const {
        return (offBit_(es) && ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool offAnyBit(Es... es) const {
        return (offBit_(es) || ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr T maskBit(Es... es) const {
        return bits & makeMask(es...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr T makeMask(Es... es) const {
        return (makeMask_(es) | ...);
    }
 
    constexpr TBitFlag<T, E> &set(T mask) {
        bits |= mask;
        return *this;
    }
 
    constexpr TBitFlag<T, E> &reset(T mask) {
        bits &= ~mask;
        return *this;
    }
 
    constexpr TBitFlag<T, E> &change(bool on, T mask) {
        return on ? set(mask) : reset(mask);
    }
 
    [[nodiscard]] constexpr bool on(T mask) const {
        return (bits & mask) != 0;
    }
 
    [[nodiscard]] constexpr bool onAll(T mask) const {
        return (bits | mask) == bits;
    }
 
    [[nodiscard]] constexpr bool off(T mask) const {
        return (bits & mask) == 0;
    }
 
    constexpr void makeAllZero() {
        bits = 0;
    }
 
    [[nodiscard]] constexpr T getDirect() const {
        return bits;
    }
 
    constexpr void setDirect(T mask) {
        bits = mask;
    }
 
private:
    typedef std::underlying_type_t<E> EI;
    static constexpr size_t MAX_CAPACITY = std::numeric_limits<T>::digits;
 
    constexpr void setBit_(E e) {
        ASSERT(static_cast<EI>(e) < MAX_CAPACITY);
        set(makeMask_(e));
    }
 
    constexpr void resetBit_(E e) {
        ASSERT(static_cast<EI>(e) < MAX_CAPACITY);
        reset(makeMask_(e));
    }
 
    constexpr void changeBit_(bool on, E e) {
        ASSERT(static_cast<EI>(e) < MAX_CAPACITY);
        change(on, makeMask_(e));
    }
 
    constexpr void toggleBit_(E e) {
        ASSERT(static_cast<EI>(e) < MAX_CAPACITY);
        changeBit_(offBit_(e), e);
    }
 
    [[nodiscard]] constexpr bool onBit_(E e) const {
        ASSERT(static_cast<EI>(e) < MAX_CAPACITY);
        return on(makeMask_(e));
    }
 
    [[nodiscard]] constexpr bool offBit_(E e) const {
        ASSERT(static_cast<EI>(e) < MAX_CAPACITY);
        return off(makeMask_(e));
    }
 
    [[nodiscard]] constexpr T makeMask_(E e) const {
        ASSERT(static_cast<EI>(e) < MAX_CAPACITY);
        return static_cast<T>(1) << static_cast<T>(e);
    }
 
    T bits; 
};
 
template <size_t N, typename E>
    requires(std::is_enum_v<E> && N > 64)
class TBitFlagExt {
public:
    constexpr TBitFlagExt() {
        makeAllZero();
    }
 
    constexpr TBitFlagExt<N, E> &makeAllZero() {
        std::fill(bits.begin(), bits.end(), 0);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    constexpr TBitFlagExt<N, E> &setBit(Es... es) {
        (setBit_(es), ...);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    constexpr TBitFlagExt<N, E> &resetBit(Es... es) {
        (resetBit_(es), ...);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    constexpr TBitFlagExt<N, E> &changeBit(bool on, Es... es) {
        (changeBit_(on, es), ...);
        return *this;
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool onBit(Es... es) const {
        return onAnyBit(es...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool onAnyBit(Es... es) const {
        return (onBit_(es) || ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool onAllBit(Es... es) const {
        return (onBit_(es) && ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool offBit(Es... es) const {
        return offAllBit(es...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool offAllBit(Es... es) const {
        return (offBit_(es) && ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool offAnyBit(Es... es) const {
        return (offBit_(es) || ...);
    }
 
private:
    typedef std::underlying_type_t<E> EI;
 
    constexpr void setBit_(E e) {
        auto [field, mask] = makeMask_(e);
        field |= mask;
    }
 
    constexpr void resetBit_(E e) {
        auto [field, mask] = makeMask_(e);
        field &= ~mask;
    }
 
    [[nodiscard]] constexpr void changeBit_(bool on, E e) {
        on ? setBit_(e) : resetBit_(e);
    }
 
    [[nodiscard]] constexpr bool onBit_(E e) const {
        auto [field, mask] = makeMask_(e);
        return (field & mask) != 0;
    }
 
    [[nodiscard]] constexpr bool offBit_(E e) const {
        auto [field, mask] = makeMask_(e);
        return (field & mask) == 0;
    }
 
    typedef u32 T;
 
    [[nodiscard]] constexpr std::pair<T, T> makeMask_(E e) const {
        EI ei = static_cast<EI>(e);
        ASSERT(ei < N);
        return std::pair<T, T>(bits[ei / C], static_cast<T>(1) << (ei % C));
    }
 
    [[nodiscard]] constexpr std::pair<T &, T> makeMask_(E e) {
        EI ei = static_cast<EI>(e);
        ASSERT(ei < N);
        return std::pair<T &, T>(bits[ei / C], static_cast<T>(1) << (ei % C));
    }
 
    static constexpr size_t C = 8 * sizeof(T);
    std::array<T, (N + C - 1) / C> bits;
};
 
} // namespace EGG
 
} // namespace Kinoko