Use C++17 variable templates for traits

Author: Flamefire

external/libendian

@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -20,7 +20,7 @@ template<typename T>
 struct Point //-V690
 {
     using ElementType = T;
-    static_assert(std::is_arithmetic<ElementType>::value, "Requires an arithmetic type");
+    static_assert(std::is_arithmetic_v<ElementType>, "Requires an arithmetic type");
 
     static constexpr auto MinElementValue = std::numeric_limits<T>::min();
     static constexpr auto MaxElementValue = std::numeric_limits<T>::max();
@@ -35,15 +35,15 @@ struct Point //-V690
     T x, y;
     constexpr Point() noexcept : x(getInvalidValue()), y(getInvalidValue()) {}
     constexpr Point(const T x, const T y) noexcept : x(x), y(y) {}
-    template<typename U, std::enable_if_t<!(std::is_integral<T>::value && std::is_floating_point<U>::value), int> = 0>
+    template<typename U, std::enable_if_t<!(std::is_integral_v<T> && std::is_floating_point_v<U>), int> = 0>
     constexpr explicit Point(const Point<U>& pt) noexcept : x(static_cast<T>(pt.x)), y(static_cast<T>(pt.y))
     {}
     /// Convert floating-point to integer by truncating
-    template<typename U, std::enable_if_t<std::is_integral<T>::value && std::is_floating_point<U>::value, int> = 0>
+    template<typename U, std::enable_if_t<std::is_integral_v<T> && std::is_floating_point_v<U>, int> = 0>
     constexpr explicit Point(Truncate_t, const Point<U>& pt) noexcept : x(static_cast<T>(pt.x)), y(static_cast<T>(pt.y))
     {}
     /// Convert floating-point to integer with rounding (default behavior)
-    template<typename U, std::enable_if_t<std::is_integral<T>::value && std::is_floating_point<U>::value, int> = 0>
+    template<typename U, std::enable_if_t<std::is_integral_v<T> && std::is_floating_point_v<U>, int> = 0>
     constexpr explicit Point(const Point<U>& pt) noexcept : x(helpers::iround<T>(pt.x)), y(helpers::iround<T>(pt.y))
     {}
     constexpr Point(const Point&) = default;
@@ -99,7 +99,7 @@ struct type_identity
 /// Convert the type T to a signed type if the condition is true (safe for float types)
 template<bool cond, typename T>
 using make_signed_if_t =
-  typename std::conditional_t<cond && !std::is_signed<T>::value, std::make_signed<T>, type_identity<T>>::type;
+  typename std::conditional_t<cond && !std::is_signed_v<T>, std::make_signed<T>, type_identity<T>>::type;
 
 // clang-format off
 
@@ -109,26 +109,25 @@ using make_signed_if_t =
 template<typename T, typename U>
 using mixed_type_t =
   make_signed_if_t<
-    std::is_signed<T>::value || std::is_signed<U>::value,
+    std::is_signed_v<T> || std::is_signed_v<U>,
     typename std::conditional_t<
-        std::is_floating_point<T>::value == std::is_floating_point<U>::value, // both are FP or not FP?
+        std::is_floating_point_v<T> == std::is_floating_point_v<U>, // both are FP or not FP?
         std::conditional<(sizeof(T) > sizeof(U)), T, U>, // Take the larger type
-        std::conditional<std::is_floating_point<T>::value, T, U> // Take the floating point type
+        std::conditional<std::is_floating_point_v<T>, T, U> // Take the floating point type
     >::type
   >;
 
 template<typename T, typename U>
-using IsNonLossyOp = std::integral_constant<bool,
+constexpr bool is_lossles_op_v = 
     // We can do T = T <op> U (except overflow) if:
-    std::is_floating_point<T>::value || std::is_signed<T>::value || std::is_unsigned<U>::value
->;
+    std::is_floating_point_v<T> || std::is_signed_v<T> || std::is_unsigned_v<U>;
 
 // clang-format on
 
 template<typename T, typename U>
-using require_nonLossyOp = std::enable_if_t<IsNonLossyOp<T, U>::value>;
+using require_lossless_op = std::enable_if_t<is_lossles_op_v<T, U>>;
 template<typename T>
-using require_arithmetic = std::enable_if_t<std::is_arithmetic<T>::value>;
+using require_arithmetic = std::enable_if_t<std::is_arithmetic_v<T>>;
 
 } // namespace detail
 
@@ -153,7 +152,7 @@ constexpr auto prodOfComponents(const Point<T>& pt) noexcept
 {
     // Let the compiler handle conversion to at least 32 bits keeping float types
     using op_type = decltype(T{} * uint32_t{});
-    using ResultType = ::detail::make_signed_if_t<std::is_signed<T>::value, op_type>;
+    using ResultType = ::detail::make_signed_if_t<std::is_signed_v<T>, op_type>;
     return static_cast<ResultType>(pt.x * pt.y);
 }
 
@@ -198,7 +197,7 @@ RTTR_GEN_ARITH(/)
 
 // Scaling operators
 
-template<typename T, typename U, class = detail::require_nonLossyOp<T, U>>
+template<typename T, typename U, class = detail::require_lossless_op<T, U>>
 constexpr Point<T>& operator*=(Point<T>& lhs, U factor) noexcept
 {
     return lhs *= Point<T>::all(factor);
@@ -216,7 +215,7 @@ constexpr auto operator*(const T left, const Point<U>& factor) noexcept
     return factor * left;
 }
 
-template<typename T, typename U, class = detail::require_nonLossyOp<T, U>>
+template<typename T, typename U, class = detail::require_lossless_op<T, U>>
 constexpr Point<T>& operator/=(Point<T>& lhs, U div) noexcept
 {
     return lhs /= Point<T>::all(div);

external/libsiedler2

@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -21,7 +21,7 @@ struct RectBase
 {
     using position_type = Point<T>;
     using extent_elem_type =
-      typename std::conditional_t<std::is_integral<T>::value, std::make_unsigned<T>, std::common_type<T>>::type;
+      typename std::conditional_t<std::is_integral_v<T>, std::make_unsigned<T>, std::common_type<T>>::type;
     using extent_type = Point<extent_elem_type>;
     T left, top, right, bottom;
     constexpr RectBase() : RectBase(position_type::all(0), extent_type::all(0)) {}

external/libutil

@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -29,7 +29,7 @@ struct EnumIterTraits
 template<class T>
 struct EnumRange
 {
-    static_assert(std::is_enum<T>::value, "Must be an enum!");
+    static_assert(std::is_enum_v<T>, "Must be an enum!");
     class iterator : public EnumIterTraits<T>
     {
         unsigned value;
@@ -51,7 +51,7 @@ struct EnumRange
 template<class T>
 struct EnumRangeWithOffset
 {
-    static_assert(std::is_enum<T>::value, "Must be an enum!");
+    static_assert(std::is_enum_v<T>, "Must be an enum!");
     class iterator : public EnumIterTraits<T>
     {
         unsigned value;

libs/common/include/Point.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -14,13 +14,17 @@ namespace helpers {
 template<class T>
 struct MaxEnumValue
 {
-    static_assert(std::is_enum<T>::value, "T must be an enum");
+    static_assert(std::is_enum_v<T>, "T must be an enum");
     static constexpr T value = maxEnumValue(T{});
 };
 
-/// Return the maximum value of an Enum
+/// Return the highest enumerator of an enum type
 template<class T_Enum>
-inline constexpr unsigned MaxEnumValue_v = static_cast<std::underlying_type_t<T_Enum>>(MaxEnumValue<T_Enum>::value);
+inline constexpr T_Enum MaxEnumerator_v = MaxEnumValue<T_Enum>::value;
+
+/// Return the maximum numeric value of an Enum
+template<class T_Enum>
+inline constexpr unsigned MaxEnumValue_v = static_cast<std::underlying_type_t<T_Enum>>(MaxEnumerator_v<T_Enum>);
 
 /// Return the number of enumerators for an enum type
 template<class T_Enum>

libs/common/include/Rect.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -16,7 +16,7 @@ namespace helpers {
 template<class T>
 class OptionalEnum
 {
-    static_assert(std::is_enum<T>::value, "Only works for enums");
+    static_assert(std::is_enum_v<T>, "Only works for enums");
     using underlying_type = std::underlying_type_t<T>;
 
 public:

libs/common/include/helpers/EnumRange.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2024 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -16,7 +16,7 @@ namespace helpers {
 template<typename T>
 class range
 {
-    static_assert(std::is_integral<T>::value, "Must be an integral!");
+    static_assert(std::is_integral_v<T>, "Must be an integral!");
     const T startValue_;
     const T endValue_;
 

libs/common/include/helpers/MaxEnumValue.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2005 - 2024 Settlers Freaks (sf-team at siedler25.org)
+// Copyright (C) 2005 - 2025 Settlers Freaks (sf-team at siedler25.org)
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -21,6 +21,8 @@ namespace detail {
     template<class T>
     struct has_pop_front<T, std::void_t<decltype(T::pop_front())>> : std::true_type
     {};
+    template<class T>
+    constexpr bool has_pop_front_v = has_pop_front<T>::value;
 
     template<class T, class U, typename = void>
     struct has_find : std::false_type
@@ -29,6 +31,8 @@ namespace detail {
     template<class T, class U>
     struct has_find<T, U, std::void_t<decltype(std::declval<T>().find(std::declval<U>()))>> : std::true_type
     {};
+    template<class T, class U>
+    constexpr bool has_find_v = has_find<T, U>::value;
 } // namespace detail
 
 /// Removes an element from a container by its reverse iterator and returns an iterator to the next element
@@ -62,7 +66,7 @@ template<typename T>
 void pop_front(T& container)
 {
     RTTR_Assert(!container.empty());
-    if constexpr(detail::has_pop_front<T>::value)
+    if constexpr(detail::has_pop_front_v<T>)
         container.pop_front();
     else
         container.erase(container.begin());
@@ -72,7 +76,7 @@ void pop_front(T& container)
 template<typename T, typename U>
 auto find(T& container, const U& value)
 {
-    if constexpr(detail::has_find<T, U>::value)
+    if constexpr(detail::has_find_v<T, U>)
         return container.find(value);
     else
     {