Flags.h

#pragma once
#include <UnCompute/Base/Base.h>
 
namespace UN
{
#define UN_BIT(n) (1 << (n))
 
    template<class TEnum>
    inline constexpr std::enable_if_t<std::is_enum_v<TEnum>, std::underlying_type_t<TEnum>> un_enum_cast(TEnum value)
    {
        return static_cast<std::underlying_type_t<TEnum>>(value);
    }
 
#define UN_ENUM_OPERATORS(Name)                                                                                                  \
    inline constexpr Name operator|(Name a, Name b)                                                                              \
    {                                                                                                                            \
        return static_cast<Name>(un_enum_cast(a) | un_enum_cast(b));                                                             \
    }                                                                                                                            \
    inline constexpr Name& operator|=(Name& a, Name b)                                                                           \
    {                                                                                                                            \
        return a = a | b;                                                                                                        \
    }                                                                                                                            \
    inline constexpr Name operator&(Name a, Name b)                                                                              \
    {                                                                                                                            \
        return static_cast<Name>(un_enum_cast(a) & un_enum_cast(b));                                                             \
    }                                                                                                                            \
    inline constexpr Name& operator&=(Name& a, Name b)                                                                           \
    {                                                                                                                            \
        return a = a & b;                                                                                                        \
    }                                                                                                                            \
    inline constexpr Name operator^(Name a, Name b)                                                                              \
    {                                                                                                                            \
        return static_cast<Name>(un_enum_cast(a) ^ un_enum_cast(b));                                                             \
    }                                                                                                                            \
    inline constexpr Name& operator^=(Name& a, Name b)                                                                           \
    {                                                                                                                            \
        return a = a ^ b;                                                                                                        \
    }                                                                                                                            \
    inline constexpr Name operator~(Name a)                                                                                      \
    {                                                                                                                            \
        return static_cast<Name>(~un_enum_cast(a));                                                                              \
    }
 
    namespace Internal
    {
        template<class T>
        inline constexpr bool IsAllowedAsFlags = std::is_enum_v<T> | std::is_integral_v<T>;
    }
 
    template<class TFlags>
    inline constexpr std::enable_if_t<Internal::IsAllowedAsFlags<TFlags>, bool> AnyFlagsActive(TFlags source, TFlags test)
    {
        return (source & test) != static_cast<TFlags>(0);
    }
 
    template<class TFlags>
    inline constexpr std::enable_if_t<Internal::IsAllowedAsFlags<TFlags>, bool> AllFlagsActive(TFlags source, TFlags test)
    {
        return (source & test) == test;
    }
 
    template<class TFlags>
    inline constexpr std::enable_if_t<Internal::IsAllowedAsFlags<TFlags>, TFlags> RemoveFlags(TFlags source, TFlags remove)
    {
        return source & ~remove;
    }
} // namespace UN