From 013f8370a0edabc75fb55fcb870c9cf3c387ffa4 Mon Sep 17 00:00:00 2001
From: Shauren <shauren.trinity@gmail.com>
Date: Mon, 27 Apr 2020 09:06:49 +0200
Subject: Core/Misc: Enum flag v3 - allow enabling flag operations directly
 after enum definition when inside namespaces

(cherry picked from commit ec87d048b4ebbb326158bc05512d1cc5ecbe8271)

# Conflicts:
#	src/server/game/AuctionHouse/AuctionHouseMgr.cpp
#	src/server/game/AuctionHouse/AuctionHouseMgr.h
#	src/server/game/Entities/Object/ObjectGuid.h
#	src/server/game/Entities/Object/Updates/UpdateField.h
#	src/server/game/Entities/Object/Updates/UpdateFields.cpp
#	src/server/game/Entities/Object/Updates/UpdateFields.h
#	src/server/game/Entities/Player/CollectionMgr.cpp
#	src/server/game/Entities/Player/CollectionMgr.h
#	src/server/game/Phasing/PhaseShift.cpp
#	src/server/game/Phasing/PhaseShift.h
#	src/server/game/Phasing/PhasingHandler.cpp
---
 src/common/Utilities/EnumFlag.h | 37 +++++++++++++++++++++----------------
 1 file changed, 21 insertions(+), 16 deletions(-)

(limited to 'src')

diff --git a/src/common/Utilities/EnumFlag.h b/src/common/Utilities/EnumFlag.h
index bd9a991daed..528625c1f08 100644
--- a/src/common/Utilities/EnumFlag.h
+++ b/src/common/Utilities/EnumFlag.h
@@ -20,80 +20,85 @@
 
 #include <type_traits>
 
-namespace EnumFlag
+template<typename T>
+constexpr bool IsEnumFlag(T) { return false; }
+
+#define DEFINE_ENUM_FLAG(enumType) constexpr bool IsEnumFlag(enumType) { return true; }
+
+namespace EnumTraits
 {
     template<typename T>
-    struct IsFlag : std::false_type { };
+    using IsFlag = std::integral_constant<bool, IsEnumFlag(T{})>;
 }
 
-template<typename T, std::enable_if_t<EnumFlag::IsFlag<T>::value, std::nullptr_t> = nullptr>
+template<typename T, std::enable_if_t<EnumTraits::IsFlag<T>::value, std::nullptr_t> = nullptr>
 inline constexpr T operator&(T left, T right)
 {
     return static_cast<T>(static_cast<std::underlying_type_t<T>>(left) & static_cast<std::underlying_type_t<T>>(right));
 }
 
-template<typename T, std::enable_if_t<EnumFlag::IsFlag<T>::value, std::nullptr_t> = nullptr>
+template<typename T, std::enable_if_t<EnumTraits::IsFlag<T>::value, std::nullptr_t> = nullptr>
 inline constexpr T& operator&=(T& left, T right)
 {
     return left = left & right;
 }
 
-template<typename T, std::enable_if_t<EnumFlag::IsFlag<T>::value, std::nullptr_t> = nullptr>
+template<typename T, std::enable_if_t<EnumTraits::IsFlag<T>::value, std::nullptr_t> = nullptr>
 inline constexpr T operator|(T left, T right)
 {
     return static_cast<T>(static_cast<std::underlying_type_t<T>>(left) | static_cast<std::underlying_type_t<T>>(right));
 }
 
-template<typename T, std::enable_if_t<EnumFlag::IsFlag<T>::value, std::nullptr_t> = nullptr>
+template<typename T, std::enable_if_t<EnumTraits::IsFlag<T>::value, std::nullptr_t> = nullptr>
 inline constexpr T& operator|=(T& left, T right)
 {
     return left = left | right;
 }
 
-template<typename T, std::enable_if_t<EnumFlag::IsFlag<T>::value, std::nullptr_t> = nullptr>
+template<typename T, std::enable_if_t<EnumTraits::IsFlag<T>::value, std::nullptr_t> = nullptr>
 inline constexpr T operator~(T value)
 {
     return static_cast<T>(~static_cast<std::underlying_type_t<T>>(value));
 }
 
 template<typename T>
-class EnumFlag_t
+class EnumFlag
 {
-    static_assert(EnumFlag::IsFlag<T>::value, "EnumFlag_t must be used only with enums that are specify EnumFlag::IsFlag");
+    static_assert(EnumTraits::IsFlag<T>::value, "EnumFlag must be used only with enums that are specify EnumFlag::IsFlag");
 
 public:
-    /*implicit*/ constexpr EnumFlag_t(T value) : _value(value)
+    /*implicit*/ constexpr EnumFlag(T value) : _value(value)
     {
     }
 
-    constexpr EnumFlag_t& operator&=(EnumFlag_t right)
+    constexpr EnumFlag& operator&=(EnumFlag right)
     {
         _value &= right._value;
         return *this;
     }
 
-    constexpr friend EnumFlag_t operator&(EnumFlag_t left, EnumFlag_t right)
+    constexpr friend EnumFlag operator&(EnumFlag left, EnumFlag right)
     {
         return left &= right;
     }
 
-    constexpr EnumFlag_t& operator|=(EnumFlag_t right)
+    constexpr EnumFlag& operator|=(EnumFlag right)
     {
         _value |= right._value;
         return *this;
     }
 
-    constexpr friend EnumFlag_t operator|(EnumFlag_t left, EnumFlag_t right)
+    constexpr friend EnumFlag operator|(EnumFlag left, EnumFlag right)
     {
         return left |= right;
     }
 
-    constexpr EnumFlag_t operator~() const
+    constexpr EnumFlag operator~() const
     {
         return static_cast<T>(~static_cast<std::underlying_type_t<T>>(_value));
     }
 
-    constexpr void RemoveFlag(EnumFlag_t flag)
+    constexpr void RemoveFlag(EnumFlag flag)
     {
         _value &= ~flag._value;
     }
-- 
cgit v1.2.3