sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Core/Flags: Rename EnableFlagsOperators to EnumAsFlags

This commit is contained in:
Lynix 2016-12-12 15:07:16 +01:00
parent bc073de94a
commit e9061a6cf8
5 changed files with 28 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/Nazara/Core/Enums.hpp
View File

@ -91,9 +91,10 @@ namespace Nz
}; };
template<> template<>
struct EnableFlagsOperators<OpenMode> struct EnumAsFlags<OpenMode>
{ {
static constexpr bool value = true; static constexpr bool value = true;
static constexpr int max = OpenMode_Max;
}; };
using OpenModeFlags = Flags<OpenMode>; using OpenModeFlags = Flags<OpenMode>;
@ -194,9 +195,10 @@ namespace Nz
}; };
template<> template<>
struct EnableFlagsOperators<StreamOption> struct EnumAsFlags<StreamOption>
{ {
static constexpr bool value = true; static constexpr bool value = true;
static constexpr int max = StreamOption_Max;
}; };
using StreamOptionFlags = Flags<StreamOption>; using StreamOptionFlags = Flags<StreamOption>;

23
include/Nazara/Core/Flags.hpp
View File

@ -12,6 +12,13 @@
namespace Nz namespace Nz
{ {
// From: https://www.justsoftwaresolutions.co.uk/cplusplus/using-enum-classes-as-bitfields.html
template<typename E>
struct EnumAsFlags
{
static constexpr bool value = false;
};
template<typename E> template<typename E>
class Flags class Flags
{ {
@ -40,19 +47,13 @@ namespace Nz
private: private:
UInt32 m_value; UInt32 m_value;
}; };
// From: https://www.justsoftwaresolutions.co.uk/cplusplus/using-enum-classes-as-bitfields.html template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator~(E lhs);
template<typename E> template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator|(E lhs, E rhs);
struct EnableFlagsOperators 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);
static constexpr bool value = false;
};
template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator~(E lhs);
template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator|(E lhs, E rhs);
template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator&(E lhs, E rhs);
template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator^(E lhs, E rhs);
} }
#include <Nazara/Core/Flags.inl> #include <Nazara/Core/Flags.inl>

8
include/Nazara/Core/Flags.inl
View File

@ -219,7 +219,7 @@ namespace Nz
* Returns a Flags object with all state enabled except for the enum one. * Returns a Flags object with all state enabled except for the enum one.
*/ */
template<typename E> template<typename E>
constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator~(E lhs) constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator~(E lhs)
{ {
return ~Flags<E>(lhs); return ~Flags<E>(lhs);
} }
@ -234,7 +234,7 @@ namespace Nz
* Returns a Flags object with combined states from the two enumeration values. * Returns a Flags object with combined states from the two enumeration values.
*/ */
template<typename E> template<typename E>
constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator|(E lhs, E rhs) constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator|(E lhs, E rhs)
{ {
return Flags<E>(lhs) | rhs; return Flags<E>(lhs) | rhs;
} }
@ -250,7 +250,7 @@ namespace Nz
* In this case, only one flag will be enabled if both enumeration values are the same. * In this case, only one flag will be enabled if both enumeration values are the same.
*/ */
template<typename E> template<typename E>
constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator&(E lhs, E rhs) constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator&(E lhs, E rhs)
{ {
return Flags<E>(lhs) & rhs; return Flags<E>(lhs) & rhs;
} }
@ -266,7 +266,7 @@ namespace Nz
* In this case, two flags will be enabled if both the enumeration values are different. * In this case, two flags will be enabled if both the enumeration values are different.
*/ */
template<typename E> template<typename E>
constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator^(E lhs, E rhs) constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator^(E lhs, E rhs)
{ {
return Flags<E>(lhs) ^ rhs; return Flags<E>(lhs) ^ rhs;
} }

12
include/Nazara/Lua/LuaInstance.inl
View File

@ -100,21 +100,21 @@ namespace Nz
} }
template<typename T> template<typename T>
std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>) std::enable_if_t<std::is_enum<T>::value && !EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
{ {
using UnderlyingT = std::underlying_type_t<T>; using UnderlyingT = std::underlying_type_t<T>;
return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), TypeTag<UnderlyingT>()); return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), TypeTag<UnderlyingT>());
} }
template<typename T> template<typename T>
std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>) std::enable_if_t<std::is_enum<T>::value && !EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
{ {
using UnderlyingT = std::underlying_type_t<T>; using UnderlyingT = std::underlying_type_t<T>;
return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), static_cast<UnderlyingT>(defValue), TypeTag<UnderlyingT>()); return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), static_cast<UnderlyingT>(defValue), TypeTag<UnderlyingT>());
} }
template<typename T> template<typename T>
std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>) std::enable_if_t<std::is_enum<T>::value && EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
{ {
using UnderlyingT = std::underlying_type_t<T>; using UnderlyingT = std::underlying_type_t<T>;
@ -126,7 +126,7 @@ namespace Nz
} }
template<typename T> template<typename T>
std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>) std::enable_if_t<std::is_enum<T>::value && EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
{ {
using UnderlyingT = std::underlying_type_t<T>; using UnderlyingT = std::underlying_type_t<T>;
@ -216,14 +216,14 @@ namespace Nz
} }
template<typename T> template<typename T>
std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>) std::enable_if_t<std::is_enum<T>::value && !EnumAsFlags<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
{ {
using EnumT = typename std::underlying_type<T>::type; using EnumT = typename std::underlying_type<T>::type;
return LuaImplReplyVal(instance, static_cast<EnumT>(val), TypeTag<EnumT>()); return LuaImplReplyVal(instance, static_cast<EnumT>(val), TypeTag<EnumT>());
} }
template<typename T> template<typename T>
std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>) std::enable_if_t<std::is_enum<T>::value && EnumAsFlags<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
{ {
Flags<T> flags(val); Flags<T> flags(val);
return LuaImplReplyVal(instance, flags, TypeTag<decltype(flags)>()); return LuaImplReplyVal(instance, flags, TypeTag<decltype(flags)>());

4
include/Nazara/Utility/Enums.hpp
View File

@ -62,7 +62,7 @@ namespace Nz
}; };
template<> template<>
struct EnableFlagsOperators<BufferUsage> struct EnumAsFlags<BufferUsage>
{ {
static constexpr bool value = true; static constexpr bool value = true;
}; };
@ -453,7 +453,7 @@ namespace Nz
}; };
template<> template<>
struct EnableFlagsOperators<WindowStyle> struct EnumAsFlags<WindowStyle>
{ {
static constexpr bool value = true; static constexpr bool value = true;
}; };