EnumBit.h

#pragma once
 
#include <type_traits>
 
#define _SW_ENUM_ENABLE_BIT_OPERATIONS(T)                  \
    template <>                                            \
    struct _EnumSupportBitOperations<T> : std::true_type { \
    }
 
namespace sw
{
    template <typename T>
    struct _EnumSupportBitOperations : std::false_type {
    };
 
    template <typename T>
    inline constexpr auto operator|(T a, T b)
        -> typename std::enable_if<std::is_enum<T>::value && _EnumSupportBitOperations<T>::value, T>::type
    {
        using TUnderlying = typename std::underlying_type<T>::type;
        return static_cast<T>(static_cast<TUnderlying>(a) | static_cast<TUnderlying>(b));
    }
 
    template <typename T>
    inline constexpr auto operator|=(T &a, T b)
        -> typename std::enable_if<std::is_enum<T>::value && _EnumSupportBitOperations<T>::value, T &>::type
    {
        return a = a | b;
    }
 
    template <typename T>
    inline constexpr auto operator&(T a, T b)
        -> typename std::enable_if<std::is_enum<T>::value && _EnumSupportBitOperations<T>::value, T>::type
    {
        using TUnderlying = typename std::underlying_type<T>::type;
        return static_cast<T>(static_cast<TUnderlying>(a) & static_cast<TUnderlying>(b));
    }
 
    template <typename T>
    inline constexpr auto operator&=(T &a, T b)
        -> typename std::enable_if<std::is_enum<T>::value && _EnumSupportBitOperations<T>::value, T &>::type
    {
        return a = a & b;
    }
 
    template <typename T>
    inline constexpr auto operator^(T a, T b)
        -> typename std::enable_if<std::is_enum<T>::value && _EnumSupportBitOperations<T>::value, T>::type
    {
        using TUnderlying = typename std::underlying_type<T>::type;
        return static_cast<T>(static_cast<TUnderlying>(a) ^ static_cast<TUnderlying>(b));
    }
 
    template <typename T>
    inline constexpr auto operator^=(T &a, T b)
        -> typename std::enable_if<std::is_enum<T>::value && _EnumSupportBitOperations<T>::value, T &>::type
    {
        return a = a ^ b;
    }
 
    template <typename T>
    inline constexpr auto operator~(T a)
        -> typename std::enable_if<std::is_enum<T>::value && _EnumSupportBitOperations<T>::value, T>::type
    {
        using TUnderlying = typename std::underlying_type<T>::type;
        return static_cast<T>(~static_cast<TUnderlying>(a));
    }
}