fix: is_integral and is_signed causing errors on >= gcc 11

This fixes #265

plugins/libimhex/include/hex/helpers/utils.hpp

@@ -25,15 +25,114 @@
     #define fopen64 fopen
     #define fseeko64 fseek
     #define ftello64 ftell
-#else
-    template<>
-    struct std::is_integral<u128> : public std::true_type { };
-    template<>
-    struct std::is_integral<s128> : public std::true_type { };
-    template<>
-    struct std::is_signed<s128>   : public std::true_type { };
 #endif
 
+namespace hex {
+    
+    template<typename>
+    struct is_integral_helper : public std::false_type { };
+
+    template<>
+    struct is_integral_helper<u8> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<s8> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<u16> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<s16> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<u32> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<s32> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<u64> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<s64> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<u128> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<s128> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<bool> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<char> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<char8_t> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<char16_t> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<char32_t> : public std::true_type { };
+
+    template<>
+    struct is_integral_helper<wchar_t> : public std::true_type { };
+
+    template<typename T>
+    struct is_integral : public is_integral_helper<std::remove_cvref_t<T>>::type { };
+
+    template<typename>
+    struct is_signed_helper : public std::false_type { };
+
+    template<>
+    struct is_signed_helper<s8> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<s16> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<s32> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<s64> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<s128> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<char> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<float> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<double> : public std::true_type { };
+
+    template<>
+    struct is_signed_helper<long double> : public std::true_type { };
+
+    template<typename T>
+    struct is_signed : public is_signed_helper<std::remove_cvref_t<T>>::type { };
+
+    template<typename>
+    struct is_floating_point_helper : public std::false_type { };
+
+    template<>
+    struct is_floating_point_helper<float> : public std::true_type { };
+
+    template<>
+    struct is_floating_point_helper<double> : public std::true_type { };
+
+    template<>
+    struct is_floating_point_helper<long double> : public std::true_type { };
+
+    template<typename T>
+    struct is_floating_point : public is_floating_point_helper<std::remove_cvref_t<T>>::type { };
+    
+}
+
 #if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 12000
 #if __has_include(<concepts>)
 // Make sure we break when derived_from is implemented in libc++. Then we can fix a compatibility version above
@@ -47,33 +146,29 @@ concept derived_from =
   __is_base_of(_Bp, _Dp) && __is_convertible_to(const volatile _Dp*, const volatile _Bp*);
 }
 
-// [concepts.arithmetic]
-namespace hex {
-template<class _Tp>
-concept integral = __is_integral(_Tp);
-
-template<class _Tp>
-concept signed_integral = integral<_Tp> && __is_signed(_Tp);
-
-template<class _Tp>
-concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
-
-template<class _Tp>
-concept floating_point = __is_floating_point(_Tp);
-}
 #else
 // Assume supported
 #include <concepts>
 namespace hex {
     using std::derived_from;
-
-    using std::integral;
-    using std::signed_integral;
-    using std::unsigned_integral;
-    using std::floating_point;
 }
 #endif
 
+// [concepts.arithmetic]
+namespace hex {
+template<class _Tp>
+concept integral = hex::is_integral<_Tp>::value;
+
+template<class _Tp>
+concept signed_integral = integral<_Tp> && hex::is_signed<_Tp>::value;
+
+template<class _Tp>
+concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+template<class _Tp>
+concept floating_point = std::is_floating_point<_Tp>::value;
+}
+
 #define TOKEN_CONCAT_IMPL(x, y) x ## y
 #define TOKEN_CONCAT(x, y) TOKEN_CONCAT_IMPL(x, y)
 #define ANONYMOUS_VARIABLE(prefix) TOKEN_CONCAT(prefix, __COUNTER__)
@@ -266,4 +361,4 @@ namespace hex {
         size_t size;
     };
 
-}
+}