refactor: use concepts instead of SFINAE (#1652)

oltolm · web-flow · commit de4bf7c2c1c3 · 2025-08-25T01:33:46.000+02:00
diff --git a/src/Cafe/GameProfile/GameProfile.cpp b/src/Cafe/GameProfile/GameProfile.cpp
@@ -106,7 +106,7 @@ bool gameProfile_loadIntegerOption(IniParser* iniParser, const char* optionName,
 template <typename T>
 bool gameProfile_loadIntegerOption(IniParser& iniParser, const char* optionName, T& option, T minVal, T maxVal)
 {
-	static_assert(std::is_integral<T>::value);
+	static_assert(std::is_integral_v<T>);
 	auto option_value = iniParser.FindOption(optionName);
 	if (!option_value)
 		return false;
@@ -133,7 +133,7 @@ bool gameProfile_loadIntegerOption(IniParser& iniParser, const char* optionName,
 template<typename T>
 bool gameProfile_loadEnumOption(IniParser& iniParser, const char* optionName, T& option)
 {
-	static_assert(std::is_enum<T>::value);
+	static_assert(std::is_enum_v<T>);
 	auto option_value = iniParser.FindOption(optionName);
 	if (!option_value)
 		return false;
@@ -366,4 +366,4 @@ void GameProfile::Reset()
 	// controller settings
 	for (auto& profile : m_controllerProfile)
 		profile.reset();
-}
+}
diff --git a/src/Cafe/HW/Latte/Core/LatteBufferCache.cpp b/src/Cafe/HW/Latte/Core/LatteBufferCache.cpp
@@ -25,7 +25,7 @@ class IntervalTree2
 	// static TNodeObject* Split(TNodeObject* nodeObject, TRangeData firstRangeBegin, TRangeData firstRangeEnd, TRangeData secondRangeBegin, TRangeData secondRangeEnd)
 	// Cut a hole into an existing range and split it in two. Should return the newly created node object after the hole
 
-	static_assert(std::is_pointer<TNodeObject>::value == false, "TNodeObject must be a non-pointer type");
+	static_assert(!std::is_pointer_v<TNodeObject>, "TNodeObject must be a non-pointer type");
 
 	struct InternalRange
 	{
diff --git a/src/Cafe/OS/common/OSUtil.h b/src/Cafe/OS/common/OSUtil.h
@@ -176,14 +176,14 @@ void cafeExportCallWrapper(PPCInterpreter_t* hCPU)
 		if(cemuLog_advancedPPCLoggingEnabled())
 		{
 			MPTR threadMPTR = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
-			if constexpr (std::tuple_size<decltype(format_tup)>::value > 0)
+			if constexpr (std::tuple_size_v<decltype(format_tup)> > 0)
 				shouldLog = cemuLog_log(TLogType, "{}.{}{} # LR: {:#x} | Thread: {:#x}", TNames::GetLib(), TNames::GetFunc(), format_tup, hCPU->spr.LR, threadMPTR);
 			else
 				shouldLog = cemuLog_log(TLogType, "{}.{}() # LR: {:#x} | Thread: {:#x}", TNames::GetLib(), TNames::GetFunc(), hCPU->spr.LR, threadMPTR);
 		}
 		else
 		{
-			if constexpr (std::tuple_size<decltype(format_tup)>::value > 0)
+			if constexpr (std::tuple_size_v<decltype(format_tup)> > 0)
 			{
 				shouldLog = cemuLog_log(TLogType, "{}.{}{}", TNames::GetLib(), TNames::GetFunc(), format_tup);
 			}
@@ -192,7 +192,7 @@ void cafeExportCallWrapper(PPCInterpreter_t* hCPU)
 		}
 	}
 
-	if constexpr (!std::is_void<decltype(std::apply(fn, tup))>::value)
+	if constexpr (!std::is_void_v<decltype(std::apply(fn, tup))>)
 	{
 		// has non-void return type
 		decltype(auto) result = std::apply(fn, tup);
@@ -241,4 +241,4 @@ MPTR makeCallableExport()
 	return PPCInterpreter_makeCallableExportDepr(&cafeExportCallWrapper<fn, "CALLABLE_EXPORT">);
 }
 
-void osLib_addVirtualPointer(const char* libraryName, const char* functionName, uint32 vPtr);
+void osLib_addVirtualPointer(const char* libraryName, const char* functionName, uint32 vPtr);
diff --git a/src/Cafe/OS/libs/gx2/GX2_Command.h b/src/Cafe/OS/libs/gx2/GX2_Command.h
@@ -39,9 +39,9 @@ inline void gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const b
 }
 
 template <typename T, typename ...Targs>
+	requires std::is_floating_point_v<T>
 inline
-typename std::enable_if< std::is_floating_point<T>::value, void>::type
-gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs... args)
+void gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs... args)
 {
 	static_assert(sizeof(T) == sizeof(uint32));
 	*writePtr = *(uint32*)&arg;
@@ -50,9 +50,9 @@ gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs
 }
 
 template <typename T, typename ...Targs>
+	requires std::is_base_of_v<Latte::LATTEREG, T>
 inline
-typename std::enable_if< std::is_base_of<Latte::LATTEREG, T>::value, void>::type
-gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs... args)
+void gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs... args)
 {
 	static_assert(sizeof(Latte::LATTEREG) == sizeof(uint32be));
 	*writePtr = arg.getRawValue();
@@ -61,9 +61,9 @@ gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs
 }
 
 template <typename T, typename ...Targs>
+	requires (!std::is_base_of_v<Latte::LATTEREG, T>) && (!std::is_floating_point_v<T>)
 inline
-typename std::enable_if< !std::is_base_of<Latte::LATTEREG, T>::value && !std::is_floating_point<T>::value, void>::type
-gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs... args)
+void gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr, const T& arg, Targs... args)
 {
 	*writePtr = arg;
 	writePtr++;
@@ -105,4 +105,4 @@ namespace GX2
 	void GX2Init_commandBufferPool(void* bufferBase, uint32 bufferSize);
 	void GX2Shutdown_commandBufferPool();
     void GX2CommandResetToDefaultState();
-}
+}
diff --git a/src/Cemu/ExpressionParser/ExpressionParser.h b/src/Cemu/ExpressionParser/ExpressionParser.h
@@ -37,7 +37,7 @@ class TExpressionParser
 	template<typename T>
 	T Evaluate(std::string_view expression) const
 	{
-		static_assert(std::is_arithmetic<T>::value, "type T must be an arithmetic type");
+		static_assert(std::is_arithmetic_v<T>, "type T must be an arithmetic type");
 		return (T)Evaluate(expression);
 	}
 
diff --git a/src/Common/SysAllocator.h b/src/Common/SysAllocator.h
@@ -113,9 +113,8 @@ class SysAllocator : public SysAllocatorBase
 	operator void*() { return m_sysMem->GetPtr(); }
 
 	// for all arrays except bool
-	template<class Q = T>
-	typename std::enable_if< count != 1 && !std::is_same<Q, bool>::value, Q >::type&
-		operator[](int index)
+	T& operator[](int index)
+		requires(count != 1) && (!std::is_same_v<T, bool>)
 	{
 		// return tmp data until we allocated in sys mem
 		if (m_sysMem.GetMPTR() == 0)
@@ -125,7 +124,7 @@ class SysAllocator : public SysAllocatorBase
 
 		return m_sysMem[index];
 	}
-private:
+  private:
 	SysAllocator(uint32 memptr)
 		: m_sysMem(memptr)
 	{}
@@ -215,4 +214,4 @@ class SysAllocator<T, 1> : public SysAllocatorBase
 
 	MEMPTR<T> m_sysMem;
 	T m_tempData;
-};
+};
diff --git a/src/Common/betype.h b/src/Common/betype.h
@@ -22,7 +22,7 @@ constexpr T bswap(T i)
 template <typename T>
 constexpr T SwapEndian(T value)
 {
-	if constexpr (std::is_integral<T>::value)
+	if constexpr (std::is_integral_v<T>)
 	{
 #ifdef _MSC_VER
 		if constexpr (sizeof(T) == sizeof(uint32_t))
@@ -33,7 +33,7 @@ constexpr T SwapEndian(T value)
 
 		return (T)bswap((std::make_unsigned_t<T>)value);
 	}
-	else if constexpr (std::is_floating_point<T>::value)
+	else if constexpr (std::is_floating_point_v<T>)
 	{
 		if constexpr (sizeof(T) == sizeof(uint32_t))
 		{
@@ -46,18 +46,18 @@ constexpr T SwapEndian(T value)
 			return *(T*)&tmp;
 		}
 	}
-	else if constexpr (std::is_enum<T>::value)
+	else if constexpr (std::is_enum_v<T>)
 	{
 		return (T)SwapEndian((std::underlying_type_t<T>)value);
 	}
-	else if constexpr (std::is_base_of<Latte::LATTEREG, T>::value)
+	else if constexpr (std::is_base_of_v<Latte::LATTEREG, T>)
 	{
 		const auto tmp = bswap<uint32_t>(*(uint32_t*)&value);
 		return *(T*)&tmp;
 	}
     else
     {
-        static_assert(std::is_integral<T>::value, "unsupported betype specialization!");
+        static_assert(std::is_integral_v<T>, "unsupported betype specialization!");
     }
 
 	return value;
diff --git a/src/Common/enumFlags.h b/src/Common/enumFlags.h
@@ -10,63 +10,65 @@ struct EnableBitMaskOperators
 };
 
 template<typename TEnum>
-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type
-operator &(TEnum lhs, TEnum rhs)
+	requires EnableBitMaskOperators<TEnum>::enable
+TEnum operator &(TEnum lhs, TEnum rhs)
 {
 	return static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) & static_cast<typename std::underlying_type<TEnum>::type>(rhs));
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type
-operator |(TEnum lhs, TEnum rhs)
+	requires EnableBitMaskOperators<TEnum>::enable
+TEnum operator |(TEnum lhs, TEnum rhs)
 {
 	return static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) | static_cast<typename std::underlying_type<TEnum>::type>(rhs));
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type
-operator ^(TEnum lhs, TEnum rhs)
+	requires EnableBitMaskOperators<TEnum>::enable
+TEnum operator ^(TEnum lhs, TEnum rhs)
 {
 	return static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) ^ static_cast<typename std::underlying_type<TEnum>::type>(rhs));
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type
-operator ~(TEnum rhs)
+	requires EnableBitMaskOperators<TEnum>::enable
+TEnum operator ~(TEnum rhs)
 {
 	return static_cast<TEnum> (~static_cast<typename std::underlying_type<TEnum>::type>(rhs));
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type&
-operator &=(TEnum& lhs, TEnum rhs)
+	requires EnableBitMaskOperators<TEnum>::enable
+TEnum& operator &=(TEnum& lhs, TEnum rhs)
 {
 	lhs = static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) & static_cast<typename std::underlying_type<TEnum>::type>(rhs));
 	return lhs;
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type&
-operator |=(TEnum& lhs, TEnum rhs)
+	requires EnableBitMaskOperators<TEnum>::enable
+TEnum& operator |=(TEnum& lhs, TEnum rhs)
 {
 	lhs = static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) | static_cast<typename std::underlying_type<TEnum>::type>(rhs));
 	return lhs;
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type&
-operator ^=(TEnum& lhs, TEnum rhs)
+	requires EnableBitMaskOperators<TEnum>::enable
+TEnum& operator ^=(TEnum& lhs, TEnum rhs)
 {
 	lhs = static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) ^ static_cast<typename std::underlying_type<TEnum>::type>(rhs));
 	return lhs;
 }
 
-template<typename TEnum, typename = std::enable_if_t<EnableBitMaskOperators<TEnum>::enable>>
+template<typename TEnum>
+	requires EnableBitMaskOperators<TEnum>::enable
 constexpr bool operator==(TEnum lhs, std::underlying_type_t<TEnum> rhs)
 {
 	return static_cast<std::underlying_type_t<TEnum>>(lhs) == rhs;
 }
-template<typename TEnum, typename = std::enable_if_t<EnableBitMaskOperators<TEnum>::enable>>
+template<typename TEnum>
+	requires EnableBitMaskOperators<TEnum>::enable
 constexpr bool operator!=(TEnum lhs, std::underlying_type_t<TEnum> rhs)
 {
 	return static_cast<std::underlying_type_t<TEnum>>(lhs) != rhs;
@@ -82,43 +84,43 @@ struct EnableEnumIterators
 };
 
 template<typename TEnum>
-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type&
-operator++(TEnum& lhs) 
+	requires EnableEnumIterators<TEnum>::enable
+TEnum& operator++(TEnum& lhs) 
 {
 	lhs = static_cast<TEnum>(static_cast<typename std::underlying_type<TEnum>::type>(lhs) + 1);
 	return lhs;
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type
-operator*(TEnum rhs) 
+	requires EnableEnumIterators<TEnum>::enable
+TEnum operator*(TEnum rhs) 
 {
 	return rhs;
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type
-begin(TEnum value) 
+	requires EnableEnumIterators<TEnum>::enable
+TEnum begin(TEnum value) 
 {
 	return EnableEnumIterators<TEnum>::begin;
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type
-rbegin(TEnum value) 
+	requires EnableEnumIterators<TEnum>::enable
+TEnum rbegin(TEnum value) 
 {
 	return EnableEnumIterators<TEnum>::rbegin;
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type
-end(TEnum r) {
+	requires EnableEnumIterators<TEnum>::enable
+TEnum end(TEnum r) {
 	return EnableEnumIterators<TEnum>::end;
 }
 
 template<typename TEnum>
-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type
-rend(TEnum r) {
+	requires EnableEnumIterators<TEnum>::enable
+TEnum rend(TEnum r) {
 	return EnableEnumIterators<TEnum>::rend;
 }
 
@@ -129,4 +131,4 @@ rend(TEnum r) {
 	static const x end = static_cast<x>(static_cast<typename std::underlying_type<x>::type>(last_value) + 1);\
 	static const x rend = static_cast<x>(static_cast<typename std::underlying_type<x>::type>(first_value) - 1);\
 };
-// todo: rend type must be signed?
+// todo: rend type must be signed?
diff --git a/src/Common/precompiled.h b/src/Common/precompiled.h
@@ -653,7 +653,8 @@ struct fmt::formatter<betype<T>> : fmt::formatter<T>
 namespace stdx
 {
 	// std::to_underlying
-    template <typename EnumT, typename = std::enable_if_t < std::is_enum<EnumT>{} >>
+    template <typename EnumT>
+		requires (std::is_enum_v<EnumT>)
         constexpr std::underlying_type_t<EnumT> to_underlying(EnumT e) noexcept {
         return static_cast<std::underlying_type_t<EnumT>>(e);
     };
@@ -689,7 +690,7 @@ namespace stdx
 	template<typename T>
 	class atomic_ref
 	{
-		static_assert(std::is_trivially_copyable<T>::value, "atomic_ref requires trivially copyable types");
+		static_assert(std::is_trivially_copyable_v<T>, "atomic_ref requires trivially copyable types");
 	public:
 		using value_type = T;
 
diff --git a/src/config/ConfigValue.h b/src/config/ConfigValue.h
@@ -96,15 +96,15 @@ class ConfigValueNoneAtomic
 		m_value = v;
 	}
 
-	template <typename = typename std::enable_if<std::is_same_v<TType, std::string>>>
 	void SetValue(std::string_view v)
+		requires std::is_same_v<TType, std::string>
 	{
 		std::lock_guard lock(m_mutex);
 		m_value = v;
 	}
 
-    template <typename = typename std::enable_if<std::is_same_v<TType, std::wstring>>>
 	void SetValue(std::wstring_view v)
+		requires std::is_same_v<TType, std::string>
 	{
 		std::lock_guard lock(m_mutex);
 		m_value = v;
@@ -171,22 +171,22 @@ class ConfigValueBounds : public ConfigValue<TType>
 	}
 
 	// init from enum with iterators
-	template<typename TEnum = typename std::enable_if<std::is_enum<TType>::value && EnableEnumIterators<TType>::enable, TType>>
 	constexpr ConfigValueBounds()
-		: base_type(), m_min_value(begin(TEnum{})), m_max_value(rbegin(TEnum{}))
+		requires std::is_enum_v<TType> && EnableEnumIterators<TType>::enable
+		: base_type(), m_min_value(begin(TType{})), m_max_value(rbegin(TType{}))
 	{
 		assert(m_min_value <= this->GetInitValue() && this->GetInitValue() <= m_max_value);
 	}
 
-    template<typename TEnum = typename std::enable_if<std::is_enum<TType>::value && EnableEnumIterators<TType>::enable, TType>>
 	constexpr ConfigValueBounds(const TType& init_value)
+		requires std::is_enum_v<TType> && EnableEnumIterators<TType>::enable
 		: base_type(std::forward<TType>(init_value)), m_min_value(begin(init_value)), m_max_value(rbegin(init_value))
 	{
 		assert(m_min_value <= init_value && init_value <= m_max_value);
 	}
 
-    template<typename TEnum = typename std::enable_if<std::is_enum<TType>::value && EnableEnumIterators<TType>::enable, TType>>
 	constexpr ConfigValueBounds(TType&& init_value)
+		requires std::is_enum_v<TType> && EnableEnumIterators<TType>::enable
 		: base_type(std::forward<TType>(init_value)), m_min_value(begin(init_value)), m_max_value(rbegin(init_value))
 	{
 		assert(m_min_value <= init_value && init_value <= m_max_value);
diff --git a/src/config/XMLConfig.h b/src/config/XMLConfig.h
diff --git a/src/gui/wxgui/helpers/wxControlObject.h b/src/gui/wxgui/helpers/wxControlObject.h
diff --git a/src/util/helpers/ringbuffer.h b/src/util/helpers/ringbuffer.h

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ class IntervalTree2`
`25`	`25`	`// static TNodeObject* Split(TNodeObject* nodeObject, TRangeData firstRangeBegin, TRangeData firstRangeEnd, TRangeData secondRangeBegin, TRangeData secondRangeEnd)`
`26`	`26`	`// Cut a hole into an existing range and split it in two. Should return the newly created node object after the hole`
`27`	`27`
`28`		`- static_assert(std::is_pointer<TNodeObject>::value == false, "TNodeObject must be a non-pointer type");`
	`28`	`+ static_assert(!std::is_pointer_v<TNodeObject>, "TNodeObject must be a non-pointer type");`
`29`	`29`
`30`	`30`	`struct InternalRange`
`31`	`31`	`{`
Original file line number	Diff line number	Diff line change
`@@ -176,14 +176,14 @@ void cafeExportCallWrapper(PPCInterpreter_t* hCPU)`
`176`	`176`	`if(cemuLog_advancedPPCLoggingEnabled())`
`177`	`177`	`{`
`178`	`178`	`MPTR threadMPTR = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());`
`179`		`- if constexpr (std::tuple_size<decltype(format_tup)>::value > 0)`
	`179`	`+ if constexpr (std::tuple_size_v<decltype(format_tup)> > 0)`
`180`	`180`	`shouldLog = cemuLog_log(TLogType, "{}.{}{} # LR: {:#x} \| Thread: {:#x}", TNames::GetLib(), TNames::GetFunc(), format_tup, hCPU->spr.LR, threadMPTR);`
`181`	`181`	`else`
`182`	`182`	`shouldLog = cemuLog_log(TLogType, "{}.{}() # LR: {:#x} \| Thread: {:#x}", TNames::GetLib(), TNames::GetFunc(), hCPU->spr.LR, threadMPTR);`
`183`	`183`	`}`
`184`	`184`	`else`
`185`	`185`	`{`
`186`		`- if constexpr (std::tuple_size<decltype(format_tup)>::value > 0)`
	`186`	`+ if constexpr (std::tuple_size_v<decltype(format_tup)> > 0)`
`187`	`187`	`{`
`188`	`188`	`shouldLog = cemuLog_log(TLogType, "{}.{}{}", TNames::GetLib(), TNames::GetFunc(), format_tup);`
`189`	`189`	`}`
`@@ -192,7 +192,7 @@ void cafeExportCallWrapper(PPCInterpreter_t* hCPU)`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`
`195`		`- if constexpr (!std::is_void<decltype(std::apply(fn, tup))>::value)`
	`195`	`+ if constexpr (!std::is_void_v<decltype(std::apply(fn, tup))>)`
`196`	`196`	`{`
`197`	`197`	`// has non-void return type`
`198`	`198`	`decltype(auto) result = std::apply(fn, tup);`
`@@ -241,4 +241,4 @@ MPTR makeCallableExport()`
`241`	`241`	`return PPCInterpreter_makeCallableExportDepr(&cafeExportCallWrapper<fn, "CALLABLE_EXPORT">);`
`242`	`242`	`}`
`243`	`243`
`244`		`-void osLib_addVirtualPointer(const char* libraryName, const char* functionName, uint32 vPtr);`
	`244`	`+void osLib_addVirtualPointer(const char* libraryName, const char* functionName, uint32 vPtr);`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ class TExpressionParser`
`37`	`37`	`template<typename T>`
`38`	`38`	`T Evaluate(std::string_view expression) const`
`39`	`39`	`{`
`40`		`- static_assert(std::is_arithmetic<T>::value, "type T must be an arithmetic type");`
	`40`	`+ static_assert(std::is_arithmetic_v<T>, "type T must be an arithmetic type");`
`41`	`41`	`return (T)Evaluate(expression);`
`42`	`42`	`}`
`43`	`43`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ constexpr T bswap(T i)`
`22`	`22`	`template <typename T>`
`23`	`23`	`constexpr T SwapEndian(T value)`
`24`	`24`	`{`
`25`		`- if constexpr (std::is_integral<T>::value)`
	`25`	`+ if constexpr (std::is_integral_v<T>)`
`26`	`26`	`{`
`27`	`27`	`#ifdef _MSC_VER`
`28`	`28`	`if constexpr (sizeof(T) == sizeof(uint32_t))`
`@@ -33,7 +33,7 @@ constexpr T SwapEndian(T value)`
`33`	`33`
`34`	`34`	`return (T)bswap((std::make_unsigned_t<T>)value);`
`35`	`35`	`}`
`36`		`- else if constexpr (std::is_floating_point<T>::value)`
	`36`	`+ else if constexpr (std::is_floating_point_v<T>)`
`37`	`37`	`{`
`38`	`38`	`if constexpr (sizeof(T) == sizeof(uint32_t))`
`39`	`39`	`{`
`@@ -46,18 +46,18 @@ constexpr T SwapEndian(T value)`
`46`	`46`	`return (T)&tmp;`
`47`	`47`	`}`
`48`	`48`	`}`
`49`		`- else if constexpr (std::is_enum<T>::value)`
	`49`	`+ else if constexpr (std::is_enum_v<T>)`
`50`	`50`	`{`
`51`	`51`	`return (T)SwapEndian((std::underlying_type_t<T>)value);`
`52`	`52`	`}`
`53`		`- else if constexpr (std::is_base_of<Latte::LATTEREG, T>::value)`
	`53`	`+ else if constexpr (std::is_base_of_v<Latte::LATTEREG, T>)`
`54`	`54`	`{`
`55`	`55`	`const auto tmp = bswap<uint32_t>((uint32_t)&value);`
`56`	`56`	`return (T)&tmp;`
`57`	`57`	`}`
`58`	`58`	`else`
`59`	`59`	`{`
`60`		`- static_assert(std::is_integral<T>::value, "unsupported betype specialization!");`
	`60`	`+ static_assert(std::is_integral_v<T>, "unsupported betype specialization!");`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`return value;`
Original file line number	Diff line number	Diff line change
`@@ -10,63 +10,65 @@ struct EnableBitMaskOperators`
`10`	`10`	`};`
`11`	`11`
`12`	`12`	`template<typename TEnum>`
`13`		`-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type`
`14`		`-operator &(TEnum lhs, TEnum rhs)`
	`13`	`+ requires EnableBitMaskOperators<TEnum>::enable`
	`14`	`+TEnum operator &(TEnum lhs, TEnum rhs)`
`15`	`15`	`{`
`16`	`16`	`return static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) & static_cast<typename std::underlying_type<TEnum>::type>(rhs));`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`template<typename TEnum>`
`20`		`-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type`
`21`		`-operator \|(TEnum lhs, TEnum rhs)`
	`20`	`+ requires EnableBitMaskOperators<TEnum>::enable`
	`21`	`+TEnum operator \|(TEnum lhs, TEnum rhs)`
`22`	`22`	`{`
`23`	`23`	`return static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) \| static_cast<typename std::underlying_type<TEnum>::type>(rhs));`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`template<typename TEnum>`
`27`		`-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type`
`28`		`-operator ^(TEnum lhs, TEnum rhs)`
	`27`	`+ requires EnableBitMaskOperators<TEnum>::enable`
	`28`	`+TEnum operator ^(TEnum lhs, TEnum rhs)`
`29`	`29`	`{`
`30`	`30`	`return static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) ^ static_cast<typename std::underlying_type<TEnum>::type>(rhs));`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`template<typename TEnum>`
`34`		`-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type`
`35`		`-operator ~(TEnum rhs)`
	`34`	`+ requires EnableBitMaskOperators<TEnum>::enable`
	`35`	`+TEnum operator ~(TEnum rhs)`
`36`	`36`	`{`
`37`	`37`	`return static_cast<TEnum> (~static_cast<typename std::underlying_type<TEnum>::type>(rhs));`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`template<typename TEnum>`
`41`		`-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type&`
`42`		`-operator &=(TEnum& lhs, TEnum rhs)`
	`41`	`+ requires EnableBitMaskOperators<TEnum>::enable`
	`42`	`+TEnum& operator &=(TEnum& lhs, TEnum rhs)`
`43`	`43`	`{`
`44`	`44`	`lhs = static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) & static_cast<typename std::underlying_type<TEnum>::type>(rhs));`
`45`	`45`	`return lhs;`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`template<typename TEnum>`
`49`		`-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type&`
`50`		`-operator \|=(TEnum& lhs, TEnum rhs)`
	`49`	`+ requires EnableBitMaskOperators<TEnum>::enable`
	`50`	`+TEnum& operator \|=(TEnum& lhs, TEnum rhs)`
`51`	`51`	`{`
`52`	`52`	`lhs = static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) \| static_cast<typename std::underlying_type<TEnum>::type>(rhs));`
`53`	`53`	`return lhs;`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`template<typename TEnum>`
`57`		`-typename std::enable_if<EnableBitMaskOperators<TEnum>::enable, TEnum>::type&`
`58`		`-operator ^=(TEnum& lhs, TEnum rhs)`
	`57`	`+ requires EnableBitMaskOperators<TEnum>::enable`
	`58`	`+TEnum& operator ^=(TEnum& lhs, TEnum rhs)`
`59`	`59`	`{`
`60`	`60`	`lhs = static_cast<TEnum> (static_cast<typename std::underlying_type<TEnum>::type>(lhs) ^ static_cast<typename std::underlying_type<TEnum>::type>(rhs));`
`61`	`61`	`return lhs;`
`62`	`62`	`}`
`63`	`63`
`64`		`-template<typename TEnum, typename = std::enable_if_t<EnableBitMaskOperators<TEnum>::enable>>`
	`64`	`+template<typename TEnum>`
	`65`	`+ requires EnableBitMaskOperators<TEnum>::enable`
`65`	`66`	`constexpr bool operator==(TEnum lhs, std::underlying_type_t<TEnum> rhs)`
`66`	`67`	`{`
`67`	`68`	`return static_cast<std::underlying_type_t<TEnum>>(lhs) == rhs;`
`68`	`69`	`}`
`69`		`-template<typename TEnum, typename = std::enable_if_t<EnableBitMaskOperators<TEnum>::enable>>`
	`70`	`+template<typename TEnum>`
	`71`	`+ requires EnableBitMaskOperators<TEnum>::enable`
`70`	`72`	`constexpr bool operator!=(TEnum lhs, std::underlying_type_t<TEnum> rhs)`
`71`	`73`	`{`
`72`	`74`	`return static_cast<std::underlying_type_t<TEnum>>(lhs) != rhs;`
`@@ -82,43 +84,43 @@ struct EnableEnumIterators`
`82`	`84`	`};`
`83`	`85`
`84`	`86`	`template<typename TEnum>`
`85`		`-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type&`
`86`		`-operator++(TEnum& lhs)`
	`87`	`+ requires EnableEnumIterators<TEnum>::enable`
	`88`	`+TEnum& operator++(TEnum& lhs)`
`87`	`89`	`{`
`88`	`90`	`lhs = static_cast<TEnum>(static_cast<typename std::underlying_type<TEnum>::type>(lhs) + 1);`
`89`	`91`	`return lhs;`
`90`	`92`	`}`
`91`	`93`
`92`	`94`	`template<typename TEnum>`
`93`		`-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type`
`94`		`-operator*(TEnum rhs)`
	`95`	`+ requires EnableEnumIterators<TEnum>::enable`
	`96`	`+TEnum operator*(TEnum rhs)`
`95`	`97`	`{`
`96`	`98`	`return rhs;`
`97`	`99`	`}`
`98`	`100`
`99`	`101`	`template<typename TEnum>`
`100`		`-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type`
`101`		`-begin(TEnum value)`
	`102`	`+ requires EnableEnumIterators<TEnum>::enable`
	`103`	`+TEnum begin(TEnum value)`
`102`	`104`	`{`
`103`	`105`	`return EnableEnumIterators<TEnum>::begin;`
`104`	`106`	`}`
`105`	`107`
`106`	`108`	`template<typename TEnum>`
`107`		`-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type`
`108`		`-rbegin(TEnum value)`
	`109`	`+ requires EnableEnumIterators<TEnum>::enable`
	`110`	`+TEnum rbegin(TEnum value)`
`109`	`111`	`{`
`110`	`112`	`return EnableEnumIterators<TEnum>::rbegin;`
`111`	`113`	`}`
`112`	`114`
`113`	`115`	`template<typename TEnum>`
`114`		`-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type`
`115`		`-end(TEnum r) {`
	`116`	`+ requires EnableEnumIterators<TEnum>::enable`
	`117`	`+TEnum end(TEnum r) {`
`116`	`118`	`return EnableEnumIterators<TEnum>::end;`
`117`	`119`	`}`
`118`	`120`
`119`	`121`	`template<typename TEnum>`
`120`		`-typename std::enable_if<EnableEnumIterators<TEnum>::enable, TEnum>::type`
`121`		`-rend(TEnum r) {`
	`122`	`+ requires EnableEnumIterators<TEnum>::enable`
	`123`	`+TEnum rend(TEnum r) {`
`122`	`124`	`return EnableEnumIterators<TEnum>::rend;`
`123`	`125`	`}`
`124`	`126`
`@@ -129,4 +131,4 @@ rend(TEnum r) {`
`129`	`131`	`static const x end = static_cast<x>(static_cast<typename std::underlying_type<x>::type>(last_value) + 1);\`
`130`	`132`	`static const x rend = static_cast<x>(static_cast<typename std::underlying_type<x>::type>(first_value) - 1);\`
`131`	`133`	`};`
`132`		`-// todo: rend type must be signed?`
	`134`	`+// todo: rend type must be signed?`
Original file line number	Diff line number	Diff line change
`@@ -96,15 +96,15 @@ class ConfigValueNoneAtomic`
`96`	`96`	`m_value = v;`
`97`	`97`	`}`
`98`	`98`
`99`		`- template <typename = typename std::enable_if<std::is_same_v<TType, std::string>>>`
`100`	`99`	`void SetValue(std::string_view v)`
	`100`	`+ requires std::is_same_v<TType, std::string>`
`101`	`101`	`{`
`102`	`102`	`std::lock_guard lock(m_mutex);`
`103`	`103`	`m_value = v;`
`104`	`104`	`}`
`105`	`105`
`106`		`- template <typename = typename std::enable_if<std::is_same_v<TType, std::wstring>>>`
`107`	`106`	`void SetValue(std::wstring_view v)`
	`107`	`+ requires std::is_same_v<TType, std::string>`
`108`	`108`	`{`
`109`	`109`	`std::lock_guard lock(m_mutex);`
`110`	`110`	`m_value = v;`
`@@ -171,22 +171,22 @@ class ConfigValueBounds : public ConfigValue<TType>`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`// init from enum with iterators`
`174`		`- template<typename TEnum = typename std::enable_if<std::is_enum<TType>::value && EnableEnumIterators<TType>::enable, TType>>`
`175`	`174`	`constexpr ConfigValueBounds()`
`176`		`- : base_type(), m_min_value(begin(TEnum{})), m_max_value(rbegin(TEnum{}))`
	`175`	`+ requires std::is_enum_v<TType> && EnableEnumIterators<TType>::enable`
	`176`	`+ : base_type(), m_min_value(begin(TType{})), m_max_value(rbegin(TType{}))`
`177`	`177`	`{`
`178`	`178`	`assert(m_min_value <= this->GetInitValue() && this->GetInitValue() <= m_max_value);`
`179`	`179`	`}`
`180`	`180`
`181`		`- template<typename TEnum = typename std::enable_if<std::is_enum<TType>::value && EnableEnumIterators<TType>::enable, TType>>`
`182`	`181`	`constexpr ConfigValueBounds(const TType& init_value)`
	`182`	`+ requires std::is_enum_v<TType> && EnableEnumIterators<TType>::enable`
`183`	`183`	`: base_type(std::forward<TType>(init_value)), m_min_value(begin(init_value)), m_max_value(rbegin(init_value))`
`184`	`184`	`{`
`185`	`185`	`assert(m_min_value <= init_value && init_value <= m_max_value);`
`186`	`186`	`}`
`187`	`187`
`188`		`- template<typename TEnum = typename std::enable_if<std::is_enum<TType>::value && EnableEnumIterators<TType>::enable, TType>>`
`189`	`188`	`constexpr ConfigValueBounds(TType&& init_value)`
	`189`	`+ requires std::is_enum_v<TType> && EnableEnumIterators<TType>::enable`
`190`	`190`	`: base_type(std::forward<TType>(init_value)), m_min_value(begin(init_value)), m_max_value(rbegin(init_value))`
`191`	`191`	`{`
`192`	`192`	`assert(m_min_value <= init_value && init_value <= m_max_value);`