refactor: replace C++17-style SFINAE patterns with concepts

Author: lmichaelis

include/zenkit/Archive.hh

@@ -131,8 +131,8 @@ namespace zenkit {
 		static std::unique_ptr<ReadArchive> from(Read* r);
 
 		template <typename T>
-		std::enable_if_t<std::is_base_of_v<Object, T>, std::shared_ptr<T>> //
-		read_object(GameVersion version) {
+		    requires std::derived_from<T, Object>
+		std::shared_ptr<T> read_object(GameVersion version) {
 			auto obj = this->read_object(version);
 			if (obj != nullptr && obj->get_object_type() != T::TYPE) {
 				throw ParserError {"ReadArchive", "Read unexcected object!"};

include/zenkit/DaedalusScript.hh

@@ -549,7 +549,8 @@ namespace zenkit {
 		/// \tparam T The type of instance to check for.
 		/// \return <tt>true</tt> if the symbol contains an instance of the given type, <tt>false</tt> if not.
 		template <typename T>
-		ZKAPI std::enable_if_t<std::is_base_of_v<DaedalusInstance, T>, bool> is_instance_of() {
+		    requires std::derived_from<T, DaedalusInstance>
+		ZKAPI bool is_instance_of() {
 			return this->type() == DaedalusDataType::INSTANCE && this->get_instance() != nullptr &&
 			    this->get_instance()->_m_type == &typeid(T);
 		}
@@ -747,6 +748,10 @@ namespace zenkit {
 		ZKINT static DaedalusInstruction decode(Read* r);
 	};
 
+	template <typename T>
+	concept DaedalusValue = std::same_as<T, std::string> || std::same_as<T, float> || std::same_as<T, int32_t> ||
+	    (std::is_enum_v<T> && sizeof(T) == 4);
+
 	/// \brief Represents a compiled daedalus script
 	class DaedalusScript {
 	public:
@@ -764,10 +769,8 @@ namespace zenkit {
 		/// \throws DaedalusInvalidRegistrationDataType If the datatype of \p _member is different than that of the
 		/// symbol.
 		template <typename _class, typename _member, int N>
-		std::enable_if_t<std::is_same_v<_member, std::string> || std::is_same_v<_member, float> ||
-		                     std::is_same_v<_member, std::int32_t> || (std::is_enum_v<_member> && sizeof(_member) == 4),
-		                 void>
-		register_member(std::string_view name, _member (_class::*field)[N]) {
+		    requires DaedalusValue<_member>
+		void register_member(std::string_view name, _member (_class::*field)[N]) {
 			auto* type = &typeid(_class);
 			auto* sym = _check_member<_member, N>(name, type);
 
@@ -785,10 +788,8 @@ namespace zenkit {
 		/// \throws DaedalusInvalidRegistrationDataType If the datatype of \p _member is different than that of the
 		/// symbol.
 		template <typename _class, typename _member>
-		std::enable_if_t<std::is_same_v<_member, std::string> || std::is_same_v<_member, float> ||
-		                     std::is_same_v<_member, std::int32_t> || (std::is_enum_v<_member> && sizeof(_member) == 4),
-		                 void>
-		register_member(std::string_view name, _member _class::*field) {
+		    requires DaedalusValue<_member>
+		void register_member(std::string_view name, _member _class::* field) {
 			auto* type = &typeid(_class);
 			auto* sym = _check_member<_member, 1>(name, type);
 
@@ -885,8 +886,8 @@ namespace zenkit {
 		/// \return The symbol associated with that instance or <tt>nullptr</tt> if the symbol is not associated
 		///         with any instance.
 		template <typename T>
-		ZKAPI std::enable_if_t<std::is_base_of_v<DaedalusInstance, T>, DaedalusSymbol const*>
-		find_symbol_by_instance(std::shared_ptr<T> const& inst) const {
+		    requires std::derived_from<T, DaedalusInstance>
+		ZKAPI DaedalusSymbol const* find_symbol_by_instance(std::shared_ptr<T> const& inst) const {
 			return find_symbol_by_index(inst->_m_symbol_index);
 		}
 
@@ -895,8 +896,8 @@ namespace zenkit {
 		/// \return The symbol associated with that instance or <tt>nullptr</tt> if the symbol is not associated
 		///         with any instance.
 		template <typename T>
-		ZKAPI std::enable_if_t<std::is_base_of_v<DaedalusInstance, T>, DaedalusSymbol*>
-		find_symbol_by_instance(std::shared_ptr<T> const& inst) {
+		    requires std::derived_from<T, DaedalusInstance>
+		ZKAPI DaedalusSymbol* find_symbol_by_instance(std::shared_ptr<T> const& inst) {
 			return find_symbol_by_index(inst->_m_symbol_index);
 		}
 
@@ -933,11 +934,11 @@ namespace zenkit {
 			}
 
 			// check type matches
-			if constexpr (std::is_same_v<std::string, _member>) {
+			if constexpr (std::same_as<std::string, _member>) {
 				if (sym->type() != DaedalusDataType::STRING) throw DaedalusInvalidRegistrationDataType {sym, "string"};
-			} else if constexpr (std::is_same_v<float, _member>) {
+			} else if constexpr (std::same_as<float, _member>) {
 				if (sym->type() != DaedalusDataType::FLOAT) throw DaedalusInvalidRegistrationDataType {sym, "float"};
-			} else if constexpr (std::is_same_v<int32_t, _member> || std::is_enum_v<_member>) {
+			} else if constexpr (std::same_as<int32_t, _member> || std::is_enum_v<_member>) {
 				if (sym->type() != DaedalusDataType::INT && sym->type() != DaedalusDataType::FUNCTION)
 					throw DaedalusInvalidRegistrationDataType {sym, "int"};
 			} else {