BitFlag.hh

#pragma once
 
#include <Logger.hh>
 
#include <cstddef>
#include <limits>
#include <type_traits>
 
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 (onBit_(es) || ...);
    }
 
    template <typename... Es>
        requires(std::is_same_v<Es, E> && ...)
    [[nodiscard]] constexpr bool offBit(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; 
};
 
} // namespace EGG