Enums.hpp

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <bit>
namespace Foundation::Core
{
    template <typename T, typename Ty> struct BitmaskEnumWrapper {
        Ty value{};
        BitmaskEnumWrapper() : value(static_cast<Ty>(T{})) {}
        BitmaskEnumWrapper(T v) : value(static_cast<Ty>(v)) {}
        BitmaskEnumWrapper(Ty v) : value(v) {}
        BitmaskEnumWrapper operator=(auto v) { value = static_cast<Ty>(v); return *this; }
        BitmaskEnumWrapper operator|(auto v) const { return { value | static_cast<Ty>(v) }; }
        BitmaskEnumWrapper operator&(auto v) const { return { value & static_cast<Ty>(v) }; }
        BitmaskEnumWrapper operator^(auto v) const { return { value ^ static_cast<Ty>(v) }; }
        BitmaskEnumWrapper operator~() const { return { ~value }; }
        BitmaskEnumWrapper& operator|=(auto v) { value |= static_cast<Ty>(v); return *this; }
        BitmaskEnumWrapper& operator&=(auto v) { value &= static_cast<Ty>(v); return *this; }
        BitmaskEnumWrapper& operator^=(auto v) { value ^= static_cast<Ty>(v); return *this; }
        constexpr bool operator ==(auto v) const { return value == static_cast<Ty>(v); }
        constexpr operator Ty() const { return static_cast<Ty>(value); }
        constexpr operator T() const { return static_cast<T>(value); }
        constexpr operator bool() const { return value != 0; }
        constexpr bool operator<(auto v) const { return value < static_cast<Ty>(v); }
        [[nodiscard]] constexpr bool is_pow2() const { return (value & (value - 1)) == 0; }
        [[nodiscard]] constexpr bool is_bitmask() const { return is_pow2(); }
        [[nodiscard]] constexpr int bit() const { 
            constexpr size_t bits = sizeof(Ty) * 8;
            return std::countr_zero(value) & (bits - 1); 
        }
    };
} // namespace Foundation::Core
#define BITMASK_ENUM_BEGIN(T,INT_T) \
enum class T##Bits : INT_T; \
inline constexpr INT_T to_integer(T##Bits e) { return static_cast<INT_T>(e); } \
using T = Foundation::Core::BitmaskEnumWrapper<T##Bits, INT_T>; \
inline T##Bits   operator   &   (T##Bits x, T##Bits y)      {   return static_cast<T##Bits>(static_cast<INT_T>(x) & static_cast<INT_T>(y)); }; \
inline T##Bits   operator   |   (T##Bits x, T##Bits y)      {   return static_cast<T##Bits>(static_cast<INT_T>(x) | static_cast<INT_T>(y)); }; \
inline T##Bits   operator   ^   (T##Bits x, T##Bits y)      {   return static_cast<T##Bits>(static_cast<INT_T>(x) ^ static_cast<INT_T>(y)); }; \
inline T##Bits   operator   ~   (T##Bits x)                 {   return static_cast<T##Bits>(~static_cast<INT_T>(x));                        }; \
inline T##Bits&  operator   &=  (T##Bits& x, T##Bits y)     {   x = static_cast<T##Bits>(x & y);    return x; }; \
inline T##Bits&  operator   |=  (T##Bits& x, T##Bits y)     {   x = static_cast<T##Bits>(x | y);    return x; }; \
inline T##Bits&  operator   ^=  (T##Bits& x, T##Bits y)     {   x = static_cast<T##Bits>(x ^ y);    return x; }; \
enum class T##Bits : INT_T {
 
#define BITMASK_ENUM_END() };
 
#define ENUM_NAME_CONV_BEGIN(T) \
inline constexpr const char* format_as(T elem) { \
    using enum T; \
    switch (elem) {
 
#define ENUM_NAME_CONV_END() \
    default: \
    return "Unknown"; \
    } \
}
// Shorthand for @ref ENUM_NAME_CONV_BEGIN case statements
#define ENUM_NAME(E) case E: return #E;