bitwise_enum.h File Reference

#include "di/util/to_underlying.h"

Go to the source code of this file.

Macros
#define	DI_DEFINE_ENUM_BITWISE_OPERATIONS(Type)

Macro Definition Documentation

DI_DEFINE_ENUM_BITWISE_OPERATIONS

#define DI_DEFINE_ENUM_BITWISE_OPERATIONS

(

Type

)

Value:

    static_assert(::di::concepts::Enum<Type>);                                                 \
    constexpr auto operator~(Type a)->Type {                                                   \
        return static_cast<Type>(~::di::util::to_underlying(a));                               \
    }                                                                                          \
    constexpr auto operator|(Type a, Type b)->Type {                                           \
        return static_cast<Type>(::di::util::to_underlying(a) | ::di::util::to_underlying(b)); \
    }                                                                                          \
    constexpr auto operator&(Type a, Type b)->Type {                                           \
        return static_cast<Type>(::di::util::to_underlying(a) & ::di::util::to_underlying(b)); \
    }                                                                                          \
    constexpr auto operator^(Type a, Type b)->Type {                                           \
        return static_cast<Type>(::di::util::to_underlying(a) ^ ::di::util::to_underlying(b)); \
    }                                                                                          \
    constexpr auto operator|=(Type& a, Type b)->Type& {                                        \
        return a = a | b;                                                                      \
    }                                                                                          \
    constexpr auto operator&=(Type& a, Type b)->Type& {                                        \
        return a = a & b;                                                                      \
    }                                                                                          \
    constexpr auto operator^=(Type& a, Type b)->Type& {                                        \
        return a = a ^ b;                                                                      \
    }                                                                                          \
    constexpr auto operator!(Type a)->bool {                                                   \
        return !::di::util::to_underlying(a);                                                  \
    }