enum.hpp

#ifndef ENTT_CORE_ENUM_HPP
#define ENTT_CORE_ENUM_HPP
 
#include "../stl/concepts.hpp"
#include "../stl/type_traits.hpp"
 
namespace entt {

template<typename Type>
struct enum_as_bitmask: stl::false_type {};

template<typename Type>
requires requires {
    requires stl::is_enum_v<Type>;
    { Type::_entt_enum_as_bitmask } -> stl::same_as<Type>;
}
struct enum_as_bitmask<Type>: stl::true_type {};

template<typename Type>
inline constexpr bool enum_as_bitmask_v = enum_as_bitmask<Type>::value;

template<typename Type>
// check again that it is an enum to deal with incorrect specializations
concept enum_bitmask = stl::is_enum_v<Type> && enum_as_bitmask_v<Type>;
 
} // namespace entt

template<entt::enum_bitmask Type>
[[nodiscard]] constexpr Type operator|(const Type lhs, const Type rhs) noexcept {
    return static_cast<Type>(static_cast<entt::stl::underlying_type_t<Type>>(lhs) | static_cast<entt::stl::underlying_type_t<Type>>(rhs));
}

template<entt::enum_bitmask Type>
[[nodiscard]] constexpr Type operator&(const Type lhs, const Type rhs) noexcept {
    return static_cast<Type>(static_cast<entt::stl::underlying_type_t<Type>>(lhs) & static_cast<entt::stl::underlying_type_t<Type>>(rhs));
}

template<entt::enum_bitmask Type>
[[nodiscard]] constexpr Type operator^(const Type lhs, const Type rhs) noexcept {
    return static_cast<Type>(static_cast<entt::stl::underlying_type_t<Type>>(lhs) ^ static_cast<entt::stl::underlying_type_t<Type>>(rhs));
}

template<entt::enum_bitmask Type>
[[nodiscard]] constexpr Type operator~(const Type value) noexcept {
    return static_cast<Type>(~static_cast<entt::stl::underlying_type_t<Type>>(value));
}

template<entt::enum_bitmask Type>
[[nodiscard]] constexpr bool operator!(const Type value) noexcept {
    return !static_cast<entt::stl::underlying_type_t<Type>>(value);
}

template<entt::enum_bitmask Type>
constexpr Type &operator|=(Type &lhs, const Type rhs) noexcept {
    return (lhs = (lhs | rhs));
}

template<entt::enum_bitmask Type>
constexpr Type &operator&=(Type &lhs, const Type rhs) noexcept {
    return (lhs = (lhs & rhs));
}

template<entt::enum_bitmask Type>
constexpr Type &operator^=(Type &lhs, const Type rhs) noexcept {
    return (lhs = (lhs ^ rhs));
}
 
#endif