spk_flags.hpp

#pragma once
 
#include <cstdint>
#include <initializer_list>
#include <iostream>
#include <type_traits>
 
namespace spk
{
    template <typename TEnumType>
    concept bitmask_enum =
        std::is_enum_v<TEnumType> &&
        (sizeof(std::underlying_type_t<TEnumType>) <= 4);

    template <typename T>
    concept unsigned_storage =
        std::is_unsigned_v<T> &&
        (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4);
}

template <spk::bitmask_enum TEnumType>
constexpr TEnumType operator|(TEnumType p_l, TEnumType p_r) noexcept
{
    using U = std::underlying_type_t<TEnumType>;
    return static_cast<TEnumType>(static_cast<U>(p_l) | static_cast<U>(p_r));
}
template <spk::bitmask_enum TEnumType>
constexpr TEnumType operator&(TEnumType p_l, TEnumType p_r) noexcept
{
    using U = std::underlying_type_t<TEnumType>;
    return static_cast<TEnumType>(static_cast<U>(p_l) & static_cast<U>(p_r));
}
template <spk::bitmask_enum TEnumType>
constexpr TEnumType operator^(TEnumType p_l, TEnumType p_r) noexcept
{
    using U = std::underlying_type_t<TEnumType>;
    return static_cast<TEnumType>(static_cast<U>(p_l) ^ static_cast<U>(p_r));
}
template <spk::bitmask_enum TEnumType>
constexpr TEnumType operator~(TEnumType p_v) noexcept
{
    using U = std::underlying_type_t<TEnumType>;
    return static_cast<TEnumType>(~static_cast<U>(p_v));
}
template <spk::bitmask_enum TEnumType>
constexpr TEnumType &operator|=(TEnumType &p_l, TEnumType p_r) noexcept
{
    return p_l = (p_l | p_r);
}
template <spk::bitmask_enum TEnumType>
constexpr TEnumType &operator&=(TEnumType &p_l, TEnumType p_r) noexcept
{
    return p_l = (p_l & p_r);
}
template <spk::bitmask_enum TEnumType>
constexpr TEnumType &operator^=(TEnumType &p_l, TEnumType p_r) noexcept
{
    return p_l = (p_l ^ p_r);
}
 
namespace spk
{
    template <bitmask_enum TFlagType, unsigned_storage StorageT = std::uint32_t>
    struct alignas(StorageT) Flags
    {
        static_assert(sizeof(std::underlying_type_t<TFlagType>) <= sizeof(StorageT), "Storage type too small for enum underlying type");

        using MaskType = StorageT;

        MaskType bits{};

        constexpr Flags() = default;

        constexpr Flags(TFlagType p_v) :
            bits(static_cast<MaskType>(p_v))
        {
        }

        constexpr explicit Flags(MaskType p_raw) :
            bits(p_raw)
        {
        }

        constexpr Flags(std::initializer_list<TFlagType> p_values) :
            bits(0)
        {
            for (auto v : p_values)
            {
                bits |= static_cast<MaskType>(v);
            }
        }

        constexpr void clear()
        {
            bits = 0;
        }

        constexpr void reset(TFlagType p_v)
        {
            bits &= ~static_cast<MaskType>(p_v);
        }

        constexpr Flags &operator|=(TFlagType p_v)
        {
            bits |= static_cast<MaskType>(p_v);
            return *this;
        }

        constexpr Flags &operator&=(TFlagType p_v)
        {
            bits &= static_cast<MaskType>(p_v);
            return *this;
        }

        constexpr Flags &operator^=(TFlagType p_v)
        {
            bits ^= static_cast<MaskType>(p_v);
            return *this;
        }

        constexpr bool has(TFlagType p_v) const
        {
            return (bits & static_cast<MaskType>(p_v)) == static_cast<MaskType>(p_v);
        }

        constexpr bool testAny(TFlagType p_v) const
        {
            return (bits & static_cast<MaskType>(p_v)) != 0;
        }

        constexpr bool any() const
        {
            return bits != 0;
        }

        constexpr bool none() const
        {
            return bits == 0;
        }

        explicit constexpr operator bool() const
        {
            return any();
        }

        constexpr MaskType raw() const
        {
            return bits;
        }
    };

    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator|(Flags<T, S> p_l, Flags<T, S> p_r) noexcept
    {
        p_l.bits |= p_r.bits;
        return p_l;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator&(Flags<T, S> p_l, Flags<T, S> p_r) noexcept
    {
        p_l.bits &= p_r.bits;
        return p_l;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator^(Flags<T, S> p_l, Flags<T, S> p_r) noexcept
    {
        p_l.bits ^= p_r.bits;
        return p_l;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator~(Flags<T, S> p_v) noexcept
    {
        p_v.bits = static_cast<typename Flags<T, S>::MaskType>(~p_v.bits);
        return p_v;
    }

    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator|(Flags<T, S> p_l, T p_r) noexcept
    {
        p_l |= p_r;
        return p_l;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator|(T p_l, Flags<T, S> p_r) noexcept
    {
        p_r |= p_l;
        return p_r;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator&(Flags<T, S> p_l, T p_r) noexcept
    {
        p_l.bits &= static_cast<typename Flags<T, S>::MaskType>(p_r);
        return p_l;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr Flags<T, S> operator&(T p_l, Flags<T, S> p_r) noexcept
    {
        return p_r & p_l;
    }

    template <bitmask_enum T, unsigned_storage S>
    constexpr bool operator==(Flags<T, S> p_l, Flags<T, S> p_r) noexcept
    {
        return p_l.bits == p_r.bits;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr bool operator!=(Flags<T, S> p_l, Flags<T, S> p_r) noexcept
    {
        return !(p_l == p_r);
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr bool operator==(Flags<T, S> p_l, T p_r) noexcept
    {
        return p_l.bits == static_cast<typename Flags<T, S>::MaskType>(p_r);
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr bool operator==(T p_l, Flags<T, S> p_r) noexcept
    {
        return p_r == p_l;
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr bool operator!=(Flags<T, S> p_l, T p_r) noexcept
    {
        return !(p_l == p_r);
    }
    template <bitmask_enum T, unsigned_storage S>
    constexpr bool operator!=(T p_l, Flags<T, S> p_r) noexcept
    {
        return !(p_r == p_l);
    }
 
    template <bitmask_enum T>
    using Flags8 = Flags<T, std::uint8_t>;
    template <bitmask_enum T>
    using Flags16 = Flags<T, std::uint16_t>;
    template <bitmask_enum T>
    using Flags32 = Flags<T, std::uint32_t>;
}
 
template <spk::bitmask_enum E, spk::unsigned_storage S>
std::ostream &operator<<(std::ostream &p_os, spk::Flags<E, S> p_f)
{
    return p_os << "0x" << std::hex << static_cast<typename spk::Flags<E, S>::MaskType>(p_f.bits);
}
template <spk::bitmask_enum E, spk::unsigned_storage S>
std::wostream &operator<<(std::wostream &p_os, spk::Flags<E, S> p_f)
{
    return p_os << L"0x" << std::hex << static_cast<typename spk::Flags<E, S>::MaskType>(p_f.bits);
}