Add new type traits && Rename existing

Add bew type traits for std::array - isStdArray and numeric std::array - isNumericStdArray.
Add arraySize trait to get array size.
Rename is_flags to isFlags, is_enum to isEnum, is_typemask to isTypeMask.

Author: smlu

libraries/libim/content/text/text_resource_reader.h

@@ -30,7 +30,7 @@ namespace libim::content::text {
         void assertKeyValue(std::string_view key, T v)
         {
             using DT =  typename std::decay_t<T>;
-            if constexpr (utils::is_enum<DT>){
+            if constexpr (utils::isEnum<DT>){
                 return assertKeyValue(key, utils::to_underlying(v));
             }
 
@@ -56,7 +56,7 @@ namespace libim::content::text {
         template<typename T, typename DT = typename std::decay_t<T>>
         DT readFlags()
         {
-            static_assert(utils::is_enum<DT>,
+            static_assert(utils::isEnum<DT>,
                 "T must be either enum, Flags or TypeMask type"
             );
             return getFlags<DT>();
@@ -160,7 +160,7 @@ namespace libim::content::text {
 
                 if constexpr(!hasListSize && utils::has_mf_capacity<Container>)
                 {
-                    if(result.capacity() < 10) {
+                    if (result.capacity() < 10) {
                         reserve(result, 256);
                     }
                 }

libraries/libim/content/text/text_resource_writer.h

@@ -32,7 +32,7 @@ namespace libim::content::text {
             indent = indent - (std::signbit(n) ? 1 : 0);
 
             std::size_t digits = 0;
-            if constexpr(std::is_unsigned_v<T>) {
+            if constexpr (std::is_unsigned_v<T>) {
                 digits = utils::numdigits(static_cast<uint64_t>(n));
             }
             else {
@@ -80,14 +80,14 @@ namespace libim::content::text {
         template<std::size_t precision = 0,
             typename T,
             bool isArithmetic = std::is_arithmetic_v<T>,
-            typename = std::enable_if_t<isArithmetic || utils::is_enum<T>>
+            typename = std::enable_if_t<isArithmetic || utils::isEnum<T>>
         >
         TextResourceWriter& writeKeyValue(std::string_view key, T value, std::size_t indent = 1)
         {
             constexpr std::size_t p = [&](){
                 // Set default precision for float and enum type
                 if constexpr(precision == 0 &&
-                    (std::is_floating_point_v<T> || utils::is_enum<T>))
+                    (std::is_floating_point_v<T> || utils::isEnum<T>))
                 {
                     if constexpr (std::is_floating_point_v<T>) {
                         return std::size_t(6);
@@ -168,7 +168,7 @@ namespace libim::content::text {
             }
 
 
-            for(auto[i, v] : utils::enumerate(list))
+            for (auto[i, v] : utils::enumerate(list))
             {
                 auto pos = tell();
                 writeRow(*this, i, v); // TODO: detect via function trait the return type of row writer function.

libraries/libim/text/tokenizer.h

@@ -34,7 +34,7 @@ namespace libim::text {
         template <typename T, typename DT = std::decay_t<T>>
         DT getFlags()
         {
-            static_assert(utils::is_enum<DT>,
+            static_assert(utils::isEnum<DT>,
                 "T must be either enum, Flags or TypeMask type"
             );
             auto tkn = getNextToken();

libraries/libim/utils/traits.h

@@ -2,6 +2,9 @@
 #define LIBIM_TRAITS_H
 #include <libim/types/flags.h>
 #include <libim/types/typemask.h>
+#include <libim/math/abstract_vector.h>
+
+#include <array>
 #include <type_traits>
 
 namespace libim::utils {
@@ -48,11 +51,36 @@ namespace libim::utils {
         template<typename T>
         struct is_flags<Flags<T>> : std::true_type {};
 
+        template<typename>
+        struct is_std_array : std::false_type {};
+
+        template<typename T, std::size_t N>
+        struct is_std_array<std::array<T, N>> : std::true_type {};
+
+        template<typename>
+        struct is_numeric_std_array : std::false_type {};
+
+        template<typename T, std::size_t N>
+        struct is_numeric_std_array<std::array<T, N>> : std::is_arithmetic<T> {};
+
         template<typename>
         struct is_typemask : std::false_type {};
 
         template<typename T>
         struct is_typemask<TypeMask<T>> : std::true_type {};
+
+        template<typename>
+        struct array_size;
+
+        template<typename T, size_t N>
+        struct array_size<std::array<T,N>> {
+            static constexpr size_t size = N;
+        };
+
+        template<typename T, size_t N>
+        struct array_size<T[N]> {
+            static size_t const size = N;
+        };
     }
 
 
@@ -67,7 +95,7 @@ namespace libim::utils {
         typename Container::value_type
     >;
 
-    // Triats
+    /* Triats */
 
     // Does C have member function 'capacity'
     template<typename C>
@@ -85,16 +113,28 @@ namespace libim::utils {
     template<typename C>
     constexpr bool has_mf_reserve = detail::has_reserve<C>::value;
 
+    // Is T of type std::array<T,N>
+    template<typename T>
+    constexpr bool isStdArray = detail::is_std_array<T>::value;
+
+    // Is T numeric std::array<T, N> type
+    template<typename T>
+    constexpr bool isNumericStdArray = detail::is_numeric_std_array<T>::value;
+
     // Is T of type Flags
     template<typename T>
-    constexpr bool is_flags = detail::is_flags<T>::value;
+    constexpr bool isFlags = detail::is_flags<T>::value;
 
     // Is T of type TypeMask
     template<typename T>
-    constexpr bool is_typemask = detail::is_typemask<T>::value;
+    constexpr bool isTypeMask = detail::is_typemask<T>::value;
 
     // is T of type enum or Flags or TypeMask
     template<typename T>
-    constexpr bool is_enum = std::is_enum_v<T> || is_flags<T> || is_typemask<T>;
+    constexpr bool isEnum = std::is_enum_v<T> || isFlags<T> || isTypeMask<T>;
+
+    /* Utility type triats */
+    template<typename T>
+    constexpr std::size_t arraySize = detail::array_size<T>::size;
 }
 #endif // LIBIM_TRAITS_H