Misc: use concepts instead of SFINAE

oltolm · oltolm · commit 302ced7fd07a · 2025-12-26T14:44:19.000+01:00
diff --git a/common/EnumOps.h b/common/EnumOps.h
@@ -7,9 +7,9 @@
 
 // Template function for casting enumerations to their underlying type
 template <typename Enumeration>
-typename std::underlying_type<Enumeration>::type enum_cast(Enumeration E)
+std::underlying_type_t<Enumeration> enum_cast(Enumeration E)
 {
-	return static_cast<typename std::underlying_type<Enumeration>::type>(E);
+	return static_cast<typename std::underlying_type_t<Enumeration>>(E);
 }
 
 namespace detail
@@ -25,67 +25,67 @@ namespace detail
 		Enum value;
 		constexpr enum_bool_helper(Enum value): value(value) {}
 		constexpr operator Enum() const { return value; }
-		constexpr operator bool() const { return static_cast<bool>(static_cast<typename std::underlying_type<Enum>::type>(value)); }
+		constexpr operator bool() const { return static_cast<bool>(static_cast<std::underlying_type_t<Enum>>(value)); }
 	};
 };
 
 #define MARK_ENUM_AS_FLAGS(T) template<> struct detail::enum_is_flags<T> : public std::true_type {}
 
 template <typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum>::type
-operator|(Enum lhs, Enum rhs) noexcept
+	requires detail::enum_is_flags<Enum>::value
+constexpr Enum operator|(Enum lhs, Enum rhs) noexcept
 {
-	using underlying = typename std::underlying_type<Enum>::type;
+	using underlying = std::underlying_type_t<Enum>;
 	return static_cast<Enum>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
 }
 
 template <typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, detail::enum_bool_helper<Enum>>::type
-operator&(Enum lhs, Enum rhs) noexcept
+	requires detail::enum_is_flags<Enum>::value
+constexpr detail::enum_bool_helper<Enum> operator&(Enum lhs, Enum rhs) noexcept
 {
-	using underlying = typename std::underlying_type<Enum>::type;
+	using underlying = std::underlying_type_t<Enum>;
 	return static_cast<Enum>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
 }
 
 template <typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum>::type
-operator^(Enum lhs, Enum rhs) noexcept
+	requires detail::enum_is_flags<Enum>::value
+constexpr Enum operator^(Enum lhs, Enum rhs) noexcept
 {
-	using underlying = typename std::underlying_type<Enum>::type;
+	using underlying = std::underlying_type_t<Enum>;
 	return static_cast<Enum>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
 }
 
 template <typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum&>::type
-operator|=(Enum& lhs, Enum rhs) noexcept
+	requires detail::enum_is_flags<Enum>::value
+constexpr Enum& operator|=(Enum& lhs, Enum rhs) noexcept
 {
 	return lhs = lhs | rhs;
 }
 
 template <typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum&>::type
-operator&=(Enum& lhs, Enum rhs) noexcept
+	requires detail::enum_is_flags<Enum>::value
+constexpr Enum& operator&=(Enum& lhs, Enum rhs) noexcept
 {
 	return lhs = lhs & rhs;
 }
 
 template <typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum&>::type
-operator^=(Enum& lhs, Enum rhs) noexcept
+	requires detail::enum_is_flags<Enum>::value
+constexpr Enum& operator^=(Enum& lhs, Enum rhs) noexcept
 {
 	return lhs = lhs ^ rhs;
 }
 
-template<typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, bool>::type
-operator!(Enum e) noexcept
+template <typename Enum>
+	requires detail::enum_is_flags<Enum>::value
+constexpr bool operator!(Enum e) noexcept
 {
-	return !static_cast<typename std::underlying_type<Enum>::type>(e);
+	return !static_cast<std::underlying_type_t<Enum>>(e);
 }
 
-template<typename Enum>
-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum>::type
-operator~(Enum e) noexcept
+template <typename Enum>
+	requires detail::enum_is_flags<Enum>::value
+constexpr Enum operator~(Enum e) noexcept
 {
-	return static_cast<Enum>(~static_cast<typename std::underlying_type<Enum>::type>(e));
+	return static_cast<Enum>(~static_cast<std::underlying_type_t<Enum>>(e));
 }
diff --git a/common/Error.cpp b/common/Error.cpp
@@ -14,8 +14,8 @@
 // Platform-specific includes
 #if defined(_WIN32)
 #include "RedtapeWindows.h"
-static_assert(std::is_same<DWORD, unsigned long>::value, "DWORD is unsigned long");
-static_assert(std::is_same<HRESULT, long>::value, "HRESULT is long");
+static_assert(std::is_same_v<DWORD, unsigned long>, "DWORD is unsigned long");
+static_assert(std::is_same_v<HRESULT, long>, "HRESULT is long");
 #endif
 
 Error::Error() = default;
diff --git a/common/StringUtil.h b/common/StringUtil.h
@@ -75,7 +75,8 @@ namespace StringUtil
 	}
 
 	/// Wrapper around std::from_chars
-	template <typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>
+	template <typename T>
+		requires std::is_integral_v<T>
 	inline std::optional<T> FromChars(const std::string_view str, int base = 10)
 	{
 		T value;
@@ -86,7 +87,8 @@ namespace StringUtil
 
 		return value;
 	}
-	template <typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>
+	template <typename T>
+		requires std::is_integral_v<T>
 	inline std::optional<T> FromChars(const std::string_view str, int base, std::string_view* endptr)
 	{
 		T value;
@@ -103,7 +105,8 @@ namespace StringUtil
 		return value;
 	}
 
-	template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
+	template <typename T>
+		requires std::is_floating_point_v<T>
 	inline std::optional<T> FromChars(const std::string_view str)
 	{
 		T value;
@@ -114,7 +117,8 @@ namespace StringUtil
 
 		return value;
 	}
-	template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
+	template <typename T>
+		requires std::is_floating_point_v<T>
 	inline std::optional<T> FromChars(const std::string_view str, std::string_view* endptr)
 	{
 		T value;
@@ -132,7 +136,8 @@ namespace StringUtil
 	}
 
 	/// Wrapper around std::to_chars
-	template <typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>
+	template <typename T>
+		requires std::is_integral_v<T>
 	inline std::string ToChars(T value, int base = 10)
 	{
 		// to_chars() requires macOS 10.15+.
@@ -154,7 +159,8 @@ namespace StringUtil
 #endif
 	}
 
-	template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
+	template <typename T>
+		requires std::is_floating_point_v<T>
 	inline std::string ToChars(T value)
 	{
 		// No to_chars() in older versions of libstdc++/libc++.
diff --git a/common/emitter/x86types.h b/common/emitter/x86types.h
@@ -44,7 +44,7 @@ namespace x86Emitter
 	template <typename T>
 	static __fi bool is_s8(T imm)
 	{
-		return (s8)imm == (typename std::make_signed<T>::type)imm;
+		return (s8)imm == (std::make_signed_t<T>)imm;
 	}
 
 	template <typename T>
diff --git a/pcsx2/GS/GSLzma.h b/pcsx2/GS/GSLzma.h
@@ -120,7 +120,8 @@ namespace GSDumpTypes
 #undef DEF_GIFReg
 	// clang-format on
 
-	template <typename Output, typename Input, typename std::enable_if<sizeof(Input) == sizeof(Output), bool>::type = true>
+	template <typename Output, typename Input>
+		requires(sizeof(Input) == sizeof(Output))
 	static constexpr Output BitCast(Input input)
 	{
 		Output output;
diff --git a/pcsx2/GS/GSRingHeap.h b/pcsx2/GS/GSRingHeap.h
@@ -262,7 +262,7 @@ class GSRingHeap
 	template <typename T>
 	typename _unique_if<T>::_unique_array_unknown_bound make_unique(size_t count)
 	{
-		typedef typename std::remove_extent<T>::type Base;
+		typedef std::remove_extent_t<T> Base;
 		return UniquePtr<T>(make_array<Base>(count));
 	}
 
diff --git a/pcsx2/GS/Renderers/SW/GSDrawScanlineCodeGenerator.all.h b/pcsx2/GS/Renderers/SW/GSDrawScanlineCodeGenerator.all.h
@@ -25,8 +25,8 @@ class GSDrawScanlineCodeGenerator : public GSNewCodeGenerator
 {
 	using XYm = DRAW_SCANLINE_VECTOR_REGISTER;
 
-	constexpr static bool isXmm = std::is_same<XYm, Xbyak::Xmm>::value;
-	constexpr static bool isYmm = std::is_same<XYm, Xbyak::Ymm>::value;
+	constexpr static bool isXmm = std::is_same_v<XYm, Xbyak::Xmm>;
+	constexpr static bool isYmm = std::is_same_v<XYm, Xbyak::Ymm>;
 	constexpr static int wordsize = 8;
 	constexpr static int vecsize = isXmm ? 16 : 32;
 	constexpr static int vecsizelog = isXmm ? 4 : 5;
diff --git a/pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.all.h b/pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.all.h
@@ -26,8 +26,8 @@ class GSSetupPrimCodeGenerator : public GSNewCodeGenerator
 	using Xmm = Xbyak::Xmm;
 	using Ymm = Xbyak::Ymm;
 
-	constexpr static bool isXmm = std::is_same<XYm, Xbyak::Xmm>::value;
-	constexpr static bool isYmm = std::is_same<XYm, Xbyak::Ymm>::value;
+	constexpr static bool isXmm = std::is_same_v<XYm, Xbyak::Xmm>;
+	constexpr static bool isYmm = std::is_same_v<XYm, Xbyak::Ymm>;
 	constexpr static int vecsize = isXmm ? 16 : 32;
 
 	constexpr static int dsize = isXmm ? 4 : 8;
diff --git a/pcsx2/StateWrapper.h b/pcsx2/StateWrapper.h
@@ -104,7 +104,8 @@ class StateWrapper
 	u32 GetVersion() const { return m_version; }
 
 	/// Overload for integral or floating-point types. Writes bytes as-is.
-	template <typename T, std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T>, int> = 0>
+	template <typename T>
+		requires std::is_integral_v<T> || std::is_floating_point_v<T>
 	void Do(T* value_ptr)
 	{
 		if (m_mode == Mode::Read)
@@ -120,7 +121,8 @@ class StateWrapper
 	}
 
 	/// Overload for enum types. Uses the underlying type.
-	template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
+	template <typename T>
+		requires std::is_enum_v<T>
 	void Do(T* value_ptr)
 	{
 		using TType = std::underlying_type_t<T>;
@@ -142,7 +144,8 @@ class StateWrapper
 	}
 
 	/// Overload for POD types, such as structs.
-	template <typename T, std::enable_if_t<std::is_standard_layout_v<T> && std::is_trivial_v<T>, int> = 0>
+	template <typename T>
+		requires std::is_standard_layout_v<T> && std::is_trivial_v<T>
 	void DoPOD(T* value_ptr)
 	{
 		if (m_mode == Mode::Read)

Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,9 @@`
`7`	`7`
`8`	`8`	`// Template function for casting enumerations to their underlying type`
`9`	`9`	`template <typename Enumeration>`
`10`		`-typename std::underlying_type<Enumeration>::type enum_cast(Enumeration E)`
	`10`	`+std::underlying_type_t<Enumeration> enum_cast(Enumeration E)`
`11`	`11`	`{`
`12`		`- return static_cast<typename std::underlying_type<Enumeration>::type>(E);`
	`12`	`+ return static_cast<typename std::underlying_type_t<Enumeration>>(E);`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`namespace detail`
`@@ -25,67 +25,67 @@ namespace detail`
`25`	`25`	`Enum value;`
`26`	`26`	`constexpr enum_bool_helper(Enum value): value(value) {}`
`27`	`27`	`constexpr operator Enum() const { return value; }`
`28`		`- constexpr operator bool() const { return static_cast<bool>(static_cast<typename std::underlying_type<Enum>::type>(value)); }`
	`28`	`+ constexpr operator bool() const { return static_cast<bool>(static_cast<std::underlying_type_t<Enum>>(value)); }`
`29`	`29`	`};`
`30`	`30`	`};`
`31`	`31`
`32`	`32`	`#define MARK_ENUM_AS_FLAGS(T) template<> struct detail::enum_is_flags<T> : public std::true_type {}`
`33`	`33`
`34`	`34`	`template <typename Enum>`
`35`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum>::type`
`36`		`-operator\|(Enum lhs, Enum rhs) noexcept`
	`35`	`+ requires detail::enum_is_flags<Enum>::value`
	`36`	`+constexpr Enum operator\|(Enum lhs, Enum rhs) noexcept`
`37`	`37`	`{`
`38`		`- using underlying = typename std::underlying_type<Enum>::type;`
	`38`	`+ using underlying = std::underlying_type_t<Enum>;`
`39`	`39`	`return static_cast<Enum>(static_cast<underlying>(lhs) \| static_cast<underlying>(rhs));`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`template <typename Enum>`
`43`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, detail::enum_bool_helper<Enum>>::type`
`44`		`-operator&(Enum lhs, Enum rhs) noexcept`
	`43`	`+ requires detail::enum_is_flags<Enum>::value`
	`44`	`+constexpr detail::enum_bool_helper<Enum> operator&(Enum lhs, Enum rhs) noexcept`
`45`	`45`	`{`
`46`		`- using underlying = typename std::underlying_type<Enum>::type;`
	`46`	`+ using underlying = std::underlying_type_t<Enum>;`
`47`	`47`	`return static_cast<Enum>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`template <typename Enum>`
`51`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum>::type`
`52`		`-operator^(Enum lhs, Enum rhs) noexcept`
	`51`	`+ requires detail::enum_is_flags<Enum>::value`
	`52`	`+constexpr Enum operator^(Enum lhs, Enum rhs) noexcept`
`53`	`53`	`{`
`54`		`- using underlying = typename std::underlying_type<Enum>::type;`
	`54`	`+ using underlying = std::underlying_type_t<Enum>;`
`55`	`55`	`return static_cast<Enum>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`template <typename Enum>`
`59`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum&>::type`
`60`		`-operator\|=(Enum& lhs, Enum rhs) noexcept`
	`59`	`+ requires detail::enum_is_flags<Enum>::value`
	`60`	`+constexpr Enum& operator\|=(Enum& lhs, Enum rhs) noexcept`
`61`	`61`	`{`
`62`	`62`	`return lhs = lhs \| rhs;`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`template <typename Enum>`
`66`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum&>::type`
`67`		`-operator&=(Enum& lhs, Enum rhs) noexcept`
	`66`	`+ requires detail::enum_is_flags<Enum>::value`
	`67`	`+constexpr Enum& operator&=(Enum& lhs, Enum rhs) noexcept`
`68`	`68`	`{`
`69`	`69`	`return lhs = lhs & rhs;`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`template <typename Enum>`
`73`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum&>::type`
`74`		`-operator^=(Enum& lhs, Enum rhs) noexcept`
	`73`	`+ requires detail::enum_is_flags<Enum>::value`
	`74`	`+constexpr Enum& operator^=(Enum& lhs, Enum rhs) noexcept`
`75`	`75`	`{`
`76`	`76`	`return lhs = lhs ^ rhs;`
`77`	`77`	`}`
`78`	`78`
`79`		`-template<typename Enum>`
`80`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, bool>::type`
`81`		`-operator!(Enum e) noexcept`
	`79`	`+template <typename Enum>`
	`80`	`+ requires detail::enum_is_flags<Enum>::value`
	`81`	`+constexpr bool operator!(Enum e) noexcept`
`82`	`82`	`{`
`83`		`- return !static_cast<typename std::underlying_type<Enum>::type>(e);`
	`83`	`+ return !static_cast<std::underlying_type_t<Enum>>(e);`
`84`	`84`	`}`
`85`	`85`
`86`		`-template<typename Enum>`
`87`		`-constexpr typename std::enable_if<detail::enum_is_flags<Enum>::value, Enum>::type`
`88`		`-operator~(Enum e) noexcept`
	`86`	`+template <typename Enum>`
	`87`	`+ requires detail::enum_is_flags<Enum>::value`
	`88`	`+constexpr Enum operator~(Enum e) noexcept`
`89`	`89`	`{`
`90`		`- return static_cast<Enum>(~static_cast<typename std::underlying_type<Enum>::type>(e));`
	`90`	`+ return static_cast<Enum>(~static_cast<std::underlying_type_t<Enum>>(e));`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,8 @@ namespace StringUtil`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`/// Wrapper around std::from_chars`
`78`		`- template <typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>`
	`78`	`+ template <typename T>`
	`79`	`+ requires std::is_integral_v<T>`
`79`	`80`	`inline std::optional<T> FromChars(const std::string_view str, int base = 10)`
`80`	`81`	`{`
`81`	`82`	`T value;`
`@@ -86,7 +87,8 @@ namespace StringUtil`
`86`	`87`
`87`	`88`	`return value;`
`88`	`89`	`}`
`89`		`- template <typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>`
	`90`	`+ template <typename T>`
	`91`	`+ requires std::is_integral_v<T>`
`90`	`92`	`inline std::optional<T> FromChars(const std::string_view str, int base, std::string_view* endptr)`
`91`	`93`	`{`
`92`	`94`	`T value;`
`@@ -103,7 +105,8 @@ namespace StringUtil`
`103`	`105`	`return value;`
`104`	`106`	`}`
`105`	`107`
`106`		`- template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>`
	`108`	`+ template <typename T>`
	`109`	`+ requires std::is_floating_point_v<T>`
`107`	`110`	`inline std::optional<T> FromChars(const std::string_view str)`
`108`	`111`	`{`
`109`	`112`	`T value;`
`@@ -114,7 +117,8 @@ namespace StringUtil`
`114`	`117`
`115`	`118`	`return value;`
`116`	`119`	`}`
`117`		`- template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>`
	`120`	`+ template <typename T>`
	`121`	`+ requires std::is_floating_point_v<T>`
`118`	`122`	`inline std::optional<T> FromChars(const std::string_view str, std::string_view* endptr)`
`119`	`123`	`{`
`120`	`124`	`T value;`
`@@ -132,7 +136,8 @@ namespace StringUtil`
`132`	`136`	`}`
`133`	`137`
`134`	`138`	`/// Wrapper around std::to_chars`
`135`		`- template <typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>`
	`139`	`+ template <typename T>`
	`140`	`+ requires std::is_integral_v<T>`
`136`	`141`	`inline std::string ToChars(T value, int base = 10)`
`137`	`142`	`{`
`138`	`143`	`// to_chars() requires macOS 10.15+.`
`@@ -154,7 +159,8 @@ namespace StringUtil`
`154`	`159`	`#endif`
`155`	`160`	`}`
`156`	`161`
`157`		`- template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>`
	`162`	`+ template <typename T>`
	`163`	`+ requires std::is_floating_point_v<T>`
`158`	`164`	`inline std::string ToChars(T value)`
`159`	`165`	`{`
`160`	`166`	`// No to_chars() in older versions of libstdc++/libc++.`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ namespace x86Emitter`
`44`	`44`	`template <typename T>`
`45`	`45`	`static __fi bool is_s8(T imm)`
`46`	`46`	`{`
`47`		`- return (s8)imm == (typename std::make_signed<T>::type)imm;`
	`47`	`+ return (s8)imm == (std::make_signed_t<T>)imm;`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`template <typename T>`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,8 @@ namespace GSDumpTypes`
`120`	`120`	`#undef DEF_GIFReg`
`121`	`121`	`// clang-format on`
`122`	`122`
`123`		`- template <typename Output, typename Input, typename std::enable_if<sizeof(Input) == sizeof(Output), bool>::type = true>`
	`123`	`+ template <typename Output, typename Input>`
	`124`	`+ requires(sizeof(Input) == sizeof(Output))`
`124`	`125`	`static constexpr Output BitCast(Input input)`
`125`	`126`	`{`
`126`	`127`	`Output output;`
Original file line number	Diff line number	Diff line change
`@@ -262,7 +262,7 @@ class GSRingHeap`
`262`	`262`	`template <typename T>`
`263`	`263`	`typename _unique_if<T>::_unique_array_unknown_bound make_unique(size_t count)`
`264`	`264`	`{`
`265`		`- typedef typename std::remove_extent<T>::type Base;`
	`265`	`+ typedef std::remove_extent_t<T> Base;`
`266`	`266`	`return UniquePtr<T>(make_array<Base>(count));`
`267`	`267`	`}`
`268`	`268`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,8 @@ class StateWrapper`
`104`	`104`	`u32 GetVersion() const { return m_version; }`
`105`	`105`
`106`	`106`	`/// Overload for integral or floating-point types. Writes bytes as-is.`
`107`		`- template <typename T, std::enable_if_t<std::is_integral_v<T> \|\| std::is_floating_point_v<T>, int> = 0>`
	`107`	`+ template <typename T>`
	`108`	`+ requires std::is_integral_v<T> \|\| std::is_floating_point_v<T>`
`108`	`109`	`void Do(T* value_ptr)`
`109`	`110`	`{`
`110`	`111`	`if (m_mode == Mode::Read)`
`@@ -120,7 +121,8 @@ class StateWrapper`
`120`	`121`	`}`
`121`	`122`
`122`	`123`	`/// Overload for enum types. Uses the underlying type.`
`123`		`- template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>`
	`124`	`+ template <typename T>`
	`125`	`+ requires std::is_enum_v<T>`
`124`	`126`	`void Do(T* value_ptr)`
`125`	`127`	`{`
`126`	`128`	`using TType = std::underlying_type_t<T>;`
`@@ -142,7 +144,8 @@ class StateWrapper`
`142`	`144`	`}`
`143`	`145`
`144`	`146`	`/// Overload for POD types, such as structs.`
`145`		`- template <typename T, std::enable_if_t<std::is_standard_layout_v<T> && std::is_trivial_v<T>, int> = 0>`
	`147`	`+ template <typename T>`
	`148`	`+ requires std::is_standard_layout_v<T> && std::is_trivial_v<T>`
`146`	`149`	`void DoPOD(T* value_ptr)`
`147`	`150`	`{`
`148`	`151`	`if (m_mode == Mode::Read)`