From 7cc11245f9e5916bc3e1ec42e6ced8c3cb31c1c9 Mon Sep 17 00:00:00 2001
From: Lynix <lynix680@gmail.com>
Date: Wed, 15 Feb 2017 07:13:00 +0100
Subject: [PATCH] Core/Flags: Move external operators to the global scope

Fixes usage of those operators outside of the Nz namespace, global
scoping is not an issue thanks to the enable_if
---
 include/Nazara/Core/Flags.hpp |  10 +--
 include/Nazara/Core/Flags.inl | 115 +++++++++++++++++-----------------
 2 files changed, 62 insertions(+), 63 deletions(-)

diff --git a/include/Nazara/Core/Flags.hpp b/include/Nazara/Core/Flags.hpp
index f356a04a5..cb336def6 100644
--- a/include/Nazara/Core/Flags.hpp
+++ b/include/Nazara/Core/Flags.hpp
@@ -54,13 +54,13 @@ namespace Nz
 		private:
 			BitField m_value;
 	};
-
-	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator~(E lhs);
-	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator|(E lhs, E rhs);
-	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator&(E lhs, E rhs);
-	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator^(E lhs, E rhs);
 }
 
+template<typename E> constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator~(E lhs);
+template<typename E> constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator|(E lhs, E rhs);
+template<typename E> constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator&(E lhs, E rhs);
+template<typename E> constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator^(E lhs, E rhs);
+
 #include <Nazara/Core/Flags.inl>
 
 #endif // NAZARA_FLAGS_HPP
diff --git a/include/Nazara/Core/Flags.inl b/include/Nazara/Core/Flags.inl
index 57ffd9e7e..973da958d 100644
--- a/include/Nazara/Core/Flags.inl
+++ b/include/Nazara/Core/Flags.inl
@@ -209,68 +209,67 @@ namespace Nz
 	{
 		return 1U << static_cast<BitField>(enumValue);
 	}
+}
 
+/*!
+* \brief Override binary NOT operator on enum to turns into a Flags object.
+* \return A Flags object with reversed bits.
+*
+* \param lhs Enumeration value to reverse.
+*
+* Returns a Flags object with all state enabled except for the enum one.
+*/
+template<typename E>
+constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator~(E lhs)
+{
+	return ~Nz::Flags<E>(lhs);
+}
 
-	/*!
-	* \brief Override binary NOT operator on enum to turns into a Flags object.
-	* \return A Flags object with reversed bits.
-	*
-	* \param lhs Enumeration value to reverse.
-	*
-	* Returns a Flags object with all state enabled except for the enum one.
-	*/
-	template<typename E>
-	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator~(E lhs)
-	{
-		return ~Flags<E>(lhs);
-	}
+/*!
+* \brief Override binary OR operator on enum to turns into a Flags object.
+* \return A Flags object with combined enum states.
+*
+* \param lhs First enumeration value to combine.
+* \param rhs Second enumeration value to combine.
+*
+* Returns a Flags object with combined states from the two enumeration values.
+*/
+template<typename E>
+constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator|(E lhs, E rhs)
+{
+	return Nz::Flags<E>(lhs) | rhs;
+}
 
-	/*!
-	* \brief Override binary OR operator on enum to turns into a Flags object.
-	* \return A Flags object with combined enum states.
-	*
-	* \param lhs First enumeration value to combine.
-	* \param rhs Second enumeration value to combine.
-	*
-	* Returns a Flags object with combined states from the two enumeration values.
-	*/
-	template<typename E>
-	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator|(E lhs, E rhs)
-	{
-		return Flags<E>(lhs) | rhs;
-	}
+/*!
+* \brief Override binary AND operator on enum to turns into a Flags object.
+* \return A Flags object with compare enum states.
+*
+* \param lhs First enumeration value to compare.
+* \param rhs Second enumeration value to compare.
+*
+* Returns a Flags object with compared states from the two enumeration values.
+* In this case, only one flag will be enabled if both enumeration values are the same.
+*/
+template<typename E>
+constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator&(E lhs, E rhs)
+{
+	return Nz::Flags<E>(lhs) & rhs;
+}
 
-	/*!
-	* \brief Override binary AND operator on enum to turns into a Flags object.
-	* \return A Flags object with compare enum states.
-	*
-	* \param lhs First enumeration value to compare.
-	* \param rhs Second enumeration value to compare.
-	*
-	* Returns a Flags object with compared states from the two enumeration values.
-	* In this case, only one flag will be enabled if both enumeration values are the same.
-	*/
-	template<typename E>
-	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator&(E lhs, E rhs)
-	{
-		return Flags<E>(lhs) & rhs;
-	}
-
-	/*!
-	* \brief Override binary XOR operator on enum to turns into a Flags object.
-	* \return A Flags object with XORed enum states.
-	*
-	* \param lhs First enumeration value to compare.
-	* \param rhs Second enumeration value to compare.
-	*
-	* Returns a Flags object with XORed states from the two enumeration values.
-	* In this case, two flags will be enabled if both the enumeration values are different.
-	*/
-	template<typename E>
-	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator^(E lhs, E rhs)
-	{
-		return Flags<E>(lhs) ^ rhs;
-	}
+/*!
+* \brief Override binary XOR operator on enum to turns into a Flags object.
+* \return A Flags object with XORed enum states.
+*
+* \param lhs First enumeration value to compare.
+* \param rhs Second enumeration value to compare.
+*
+* Returns a Flags object with XORed states from the two enumeration values.
+* In this case, two flags will be enabled if both the enumeration values are different.
+*/
+template<typename E>
+constexpr std::enable_if_t<Nz::EnumAsFlags<E>::value, Nz::Flags<E>> operator^(E lhs, E rhs)
+{
+	return Nz::Flags<E>(lhs) ^ rhs;
 }
 
 #include <Nazara/Core/DebugOff.hpp>