Add more bitset operators and trait-based opt-in

Add new operator overloads to enhance the functionality of bitsets, and
introduce a type trait that enables enums to opt in to being used as
bitsets.

Author: falbrechtskirchinger

libs/common/include/s25util/enumUtils.h

@@ -6,16 +6,61 @@
 
 #include <type_traits>
 
+template<typename Enum>
+struct IsBitset : std::false_type
+{};
+
+template<typename Enum>
+using IsValidBitset =
+  std::integral_constant<bool, IsBitset<Enum>::value && std::is_unsigned<std::underlying_type_t<Enum>>::value>;
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator&(Enum lhs, Enum rhs) noexcept
+{
+    using T = std::underlying_type_t<Enum>;
+    return Enum(static_cast<T>(lhs) & static_cast<T>(rhs));
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator|(Enum lhs, Enum rhs) noexcept
+{
+    using T = std::underlying_type_t<Enum>;
+    return Enum(static_cast<T>(lhs) | static_cast<T>(rhs));
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator^(Enum lhs, Enum rhs) noexcept
+{
+    using T = std::underlying_type_t<Enum>;
+    return Enum(static_cast<T>(lhs) ^ static_cast<T>(rhs));
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator&=(Enum& lhs, Enum rhs) noexcept
+{
+    lhs = lhs & rhs;
+    return lhs;
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator|=(Enum& lhs, Enum rhs) noexcept
+{
+    lhs = lhs | rhs;
+    return lhs;
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator^=(Enum& lhs, Enum rhs) noexcept
+{
+    lhs = lhs ^ rhs;
+    return lhs;
+}
+
 /// Makes a strongly typed enum usable as a bitset
-#define MAKE_BITSET_STRONG(Type)                                              \
-    inline auto operator&(Type lhs, Type rhs)                                 \
-    {                                                                         \
-        return Type(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); \
-    }                                                                         \
-    inline auto operator|(Type lhs, Type rhs)                                 \
-    {                                                                         \
-        return Type(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); \
-    }                                                                         \
-    /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                          \
-    static_assert(std::is_unsigned<std::underlying_type_t<Type>>::value,      \
+#define MAKE_BITSET_STRONG(Type)                                         \
+    template<>                                                           \
+    struct IsBitset<Type> : std::true_type                               \
+    {};                                                                  \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                     \
+    static_assert(std::is_unsigned<std::underlying_type_t<Type>>::value, \
                   #Type " must use unsigned type as the underlying type")