Use concepts and constraints instead of std::enable_ifconcepts

7 files changed, 22 insertions, 19 deletions

diff --git a/apps/openmw_test_suite/detournavigator/generate.hpp b/apps/openmw_test_suite/detournavigator/generate.hpp
index 52d04495a7..bff1231a02 100644
--- a/apps/openmw_test_suite/detournavigator/generate.hpp
+++ b/apps/openmw_test_suite/detournavigator/generate.hpp
@@ -11,8 +11,8 @@ namespace DetourNavigator
     namespace Tests
     {
         template <class T, class Random>
-        inline auto generateValue(T& value, Random& random)
-            -> std::enable_if_t<sizeof(T) >= 2>
+            requires (sizeof(T) >= 2)
+        inline void generateValue(T& value, Random& random)
         {
             using Distribution = std::conditional_t<
                 std::is_floating_point_v<T>,
@@ -24,8 +24,8 @@ namespace DetourNavigator
         }
 
         template <class T, class Random>
-        inline auto generateValue(T& value, Random& random)
-            -> std::enable_if_t<sizeof(T) == 1>
+            requires (sizeof(T) == 1)
+        inline void generateValue(T& value, Random& random)
         {
             unsigned short v;
             generateValue(v, random);
diff --git a/apps/openmw_test_suite/serialization/format.hpp b/apps/openmw_test_suite/serialization/format.hpp
index 603d2790e0..fe8bdb5e90 100644
--- a/apps/openmw_test_suite/serialization/format.hpp
+++ b/apps/openmw_test_suite/serialization/format.hpp
@@ -46,16 +46,16 @@ namespace SerializationTesting
         using Serialization::Format<mode, TestFormat<mode>>::operator();
 
         template <class Visitor, class T>
+            requires std::is_same_v<std::decay_t<T>, Pod>
         auto operator()(Visitor&& visitor, T& value) const
-            -> std::enable_if_t<std::is_same_v<std::decay_t<T>, Pod>>
         {
             visitor(*this, value.mInt);
             visitor(*this, value.mDouble);
         }
 
         template <class Visitor, class T>
+            requires std::is_same_v<std::decay_t<T>, Composite>
         auto operator()(Visitor&& visitor, T& value) const
-            -> std::enable_if_t<std::is_same_v<std::decay_t<T>, Composite>>
         {
             visitor(*this, value.mFloatArray);
             visitor(*this, value.mIntVector);
diff --git a/components/detournavigator/serialization.cpp b/components/detournavigator/serialization.cpp
index a0a097ab0b..9998ac94f9 100644
--- a/components/detournavigator/serialization.cpp
+++ b/components/detournavigator/serialization.cpp
@@ -149,8 +149,8 @@ namespace
         }
 
         template <class Visitor, class T>
+            requires std::is_same_v<std::decay_t<T>, rcPolyMesh>
         auto operator()(Visitor&& visitor, T& value) const
-            -> std::enable_if_t<std::is_same_v<std::decay_t<T>, rcPolyMesh>>
         {
             visitor(*this, value.nverts);
             visitor(*this, value.npolys);
@@ -183,8 +183,8 @@ namespace
         }
 
         template <class Visitor, class T>
+            requires std::is_same_v<std::decay_t<T>, rcPolyMeshDetail>
         auto operator()(Visitor&& visitor, T& value) const
-            -> std::enable_if_t<std::is_same_v<std::decay_t<T>, rcPolyMeshDetail>>
         {
             visitor(*this, value.nmeshes);
             if constexpr (mode == Serialization::Mode::Read)
@@ -204,8 +204,8 @@ namespace
         }
 
         template <class Visitor, class T>
+            requires std::is_same_v<std::decay_t<T>, PreparedNavMeshData>
         auto operator()(Visitor&& visitor, T& value) const
-            -> std::enable_if_t<std::is_same_v<std::decay_t<T>, PreparedNavMeshData>>
         {
             if constexpr (mode == Serialization::Mode::Write)
             {
diff --git a/components/esm/esmcommon.hpp b/components/esm/esmcommon.hpp
index 2685371ec0..35be1725f2 100644
--- a/components/esm/esmcommon.hpp
+++ b/components/esm/esmcommon.hpp
@@ -8,6 +8,7 @@
 #include <cstdint>
 #include <cassert>
 #include <limits>
+#include <concepts>
 
 namespace ESM
 {
@@ -125,7 +126,7 @@ struct FixedString
     }
 };
 
-template <std::size_t capacity, class T, typename = std::enable_if_t<std::is_same_v<T, char>>>
+template <std::size_t capacity, std::same_as<char> T>
 inline bool operator==(const FixedString<capacity>& lhs, const T* const& rhs) noexcept
 {
     for (std::size_t i = 0; i < capacity; ++i)
diff --git a/components/esmloader/load.cpp b/components/esmloader/load.cpp
index d3c170bc4c..ee11b98327 100644
--- a/components/esmloader/load.cpp
+++ b/components/esmloader/load.cpp
@@ -79,8 +79,8 @@ namespace EsmLoader
         constexpr bool hasId = HasId<T>::value;
 
         template <class T>
+            requires hasId<T>
         auto loadRecord(ESM::ESMReader& reader, Records<T>& records)
-            -> std::enable_if_t<hasId<T>>
         {
             T record;
             bool deleted = false;
@@ -92,8 +92,8 @@ namespace EsmLoader
         }
 
         template <class T>
+            requires (!hasId<T>)
         auto loadRecord(ESM::ESMReader& reader, Records<T>& records)
-            -> std::enable_if_t<!hasId<T>>
         {
             T record;
             bool deleted = false;
diff --git a/components/navmeshtool/protocol.cpp b/components/navmeshtool/protocol.cpp
index 656d5ab4d6..9a8b593025 100644
--- a/components/navmeshtool/protocol.cpp
+++ b/components/navmeshtool/protocol.cpp
@@ -18,8 +18,8 @@ namespace NavMeshTool
             using Serialization::Format<mode, Format<mode>>::operator();
 
             template <class Visitor, class T>
+                requires std::is_same_v<std::decay_t<T>, Message>
             auto operator()(Visitor&& visitor, T& value) const
-                -> std::enable_if_t<std::is_same_v<std::decay_t<T>, Message>>
             {
                 if constexpr (mode == Serialization::Mode::Write)
                     visitor(*this, messageMagic);
@@ -40,29 +40,29 @@ namespace NavMeshTool
             }
 
             template <class Visitor, class T>
+                requires std::is_same_v<std::decay_t<T>, ExpectedCells>
             auto operator()(Visitor&& visitor, T& value) const
-                -> std::enable_if_t<std::is_same_v<std::decay_t<T>, ExpectedCells>>
             {
                 visitor(*this, value.mCount);
             }
 
             template <class Visitor, class T>
+                requires std::is_same_v<std::decay_t<T>, ProcessedCells>
             auto operator()(Visitor&& visitor, T& value) const
-                -> std::enable_if_t<std::is_same_v<std::decay_t<T>, ProcessedCells>>
             {
                 visitor(*this, value.mCount);
             }
 
             template <class Visitor, class T>
+                requires std::is_same_v<std::decay_t<T>, ExpectedTiles>
             auto operator()(Visitor&& visitor, T& value) const
-                -> std::enable_if_t<std::is_same_v<std::decay_t<T>, ExpectedTiles>>
             {
                 visitor(*this, value.mCount);
             }
 
             template <class Visitor, class T>
+                requires std::is_same_v<std::decay_t<T>, GeneratedTiles>
             auto operator()(Visitor&& visitor, T& value) const
-                -> std::enable_if_t<std::is_same_v<std::decay_t<T>, GeneratedTiles>>
             {
                 visitor(*this, value.mCount);
             }
diff --git a/components/serialization/format.hpp b/components/serialization/format.hpp
index 29fc0ec42d..f20118d304 100644
--- a/components/serialization/format.hpp
+++ b/components/serialization/format.hpp
@@ -29,6 +29,9 @@ namespace Serialization
     template <class T>
     inline constexpr bool isContiguousContainer = IsContiguousContainer<std::decay_t<T>>::value;
 
+    template <class T>
+    concept ContiguousContainer = isContiguousContainer<T>;
+
     template <Mode mode, class Derived>
     struct Format
     {
@@ -47,9 +50,8 @@ namespace Serialization
             self()(std::forward<Visitor>(visitor), data, size);
         }
 
-        template <class Visitor, class T>
+        template <class Visitor, ContiguousContainer T>
         auto operator()(Visitor&& visitor, T&& value) const
-            -> std::enable_if_t<isContiguousContainer<T>>
         {
             if constexpr (mode == Mode::Write)
                 visitor(self(), static_cast<std::uint64_t>(value.size()));