improve has_type_at

Author: aalkin

Framework/Core/include/Framework/ASoA.h

@@ -2292,8 +2292,8 @@ class TableNG
   inline arrow::ChunkedArray* getIndexToKey()
   {
     if constexpr (framework::has_type_conditional<is_binding_compatible, Key>(external_index_columns_t{})) {
-      using IC = framework::pack_element_t<framework::has_type_at_conditional<is_binding_compatible, Key>(external_index_columns_t{}), external_index_columns_t>;
-      return mColumnChunks[framework::has_type_at<IC>(persistent_columns_t{})];
+      using IC = framework::pack_element_t<framework::has_type_at_conditional_v<is_binding_compatible, Key>(external_index_columns_t{}), external_index_columns_t>;
+      return mColumnChunks[framework::has_type_at_v<IC>(persistent_columns_t{})];
     } else if constexpr (std::is_same_v<table_t, Key>) {
       return nullptr;
     } else {
@@ -2680,8 +2680,8 @@ class Table
   inline arrow::ChunkedArray* getIndexToKey()
   {
     if constexpr (framework::has_type_conditional<is_binding_compatible, Key>(external_index_columns_t{})) {
-      using IC = framework::pack_element_t<framework::has_type_at_conditional<is_binding_compatible, Key>(external_index_columns_t{}), external_index_columns_t>;
-      return mColumnChunks[framework::has_type_at<IC>(persistent_columns_t{})];
+      using IC = framework::pack_element_t<framework::has_type_at_conditional_v<is_binding_compatible, Key>(external_index_columns_t{}), external_index_columns_t>;
+      return mColumnChunks[framework::has_type_at_v<IC>(persistent_columns_t{})];
     } else if constexpr (std::is_same_v<table_t, Key>) {
       return nullptr;
     } else {

Framework/Core/include/Framework/AnalysisHelpers.h

@@ -447,8 +447,8 @@ namespace
 template <typename T, typename Key>
 inline std::shared_ptr<arrow::ChunkedArray> getIndexToKey(arrow::Table* table)
 {
-  using IC = framework::pack_element_t<framework::has_type_at_conditional<soa::is_binding_compatible, Key>(typename T::external_index_columns_t{}), typename T::external_index_columns_t>;
-  return table->column(framework::has_type_at<IC>(typename T::persistent_columns_t{}));
+  using IC = framework::pack_element_t<framework::has_type_at_conditional_v<soa::is_binding_compatible, Key>(typename T::external_index_columns_t{}), typename T::external_index_columns_t>;
+  return table->column(framework::has_type_at_v<IC>(typename T::persistent_columns_t{}));
 }
 
 template <typename C>

Framework/Foundation/include/Framework/Pack.h

@@ -33,13 +33,12 @@ constexpr std::size_t pack_size(pack<Ts...> const&)
 template <std::size_t I, typename T>
 struct pack_element;
 
-#ifdef __clang__
+#if __has_builtin(__type_pack_element)
 template <std::size_t I, typename... Ts>
 struct pack_element<I, pack<Ts...>> {
   using type = __type_pack_element<I, Ts...>;
 };
 #else
-
 // recursive case
 template <std::size_t I, typename Head, typename... Tail>
 struct pack_element<I, pack<Head, Tail...>>
@@ -224,74 +223,30 @@ bool consteval has_type_conditional(framework::pack<Us...>)
 template <template <typename, typename> typename Condition, typename T, typename P>
 inline constexpr bool has_type_conditional_v = has_type_conditional<Condition, T>(P{});
 
-template <typename T>
-constexpr size_t has_type_at(pack<> const&)
-{
-  return static_cast<size_t>(-1);
-}
-
-template <typename T, typename T1, typename... Ts>
-constexpr size_t has_type_at(pack<T1, Ts...> const&)
-{
-  if constexpr (std::is_same_v<T, T1>) {
-    return 0;
-  } else if constexpr (has_type<T>(pack<Ts...>{})) {
-    return 1 + has_type_at<T>(pack<Ts...>{});
-  }
-  return sizeof...(Ts) + 2;
-}
-
-template <template <typename, typename> typename Condition, typename T>
-constexpr size_t has_type_at_conditional(pack<>&&)
+template <typename T, typename... Ts>
+consteval size_t has_type_at_v(pack<Ts...>)
 {
-  return static_cast<size_t>(-1);
+    constexpr size_t size = sizeof...(Ts);
+    constexpr bool found[size] = { std::same_as<T, Ts> ... };
+    for (size_t i = 0; i < size; ++i) {
+      if (found[i]) {
+        return i;
+      }
+    }
+    return size + 1;
 }
 
-template <template <typename, typename> typename Condition, typename T, typename T1, typename... Ts>
-constexpr size_t has_type_at_conditional(pack<T1, Ts...>&&)
+template <template <typename, typename> typename Condition, typename T, typename... Ts>
+consteval size_t has_type_at_conditional_v(pack<Ts...>)
 {
-  if constexpr (Condition<T, T1>::value) {
-    return 0;
-  } else if constexpr (has_type_conditional_v<Condition, T, pack<Ts...>>) {
-    return 1 + has_type_at_conditional<Condition, T>(pack<Ts...>{});
+  constexpr size_t size = sizeof...(Ts);
+  constexpr bool found[size] = { Condition<T, Ts>::value ... };
+  for (size_t i = 0; i < size; ++i) {
+    if (found[i]) {
+      return i;
+    }
   }
-  return sizeof...(Ts) + 2;
-}
-
-namespace
-{
-template <std::size_t I, typename T>
-struct indexed {
-  using type = T;
-  constexpr static std::size_t index = I;
-};
-
-template <typename Is, typename... Ts>
-struct indexer;
-
-template <std::size_t... Is, typename... Ts>
-struct indexer<std::index_sequence<Is...>, Ts...>
-  : indexed<Is, Ts>... {
-};
-
-template <typename T, std::size_t I>
-indexed<I, T> select(indexed<I, T>);
-
-template <typename W, typename... Ts>
-constexpr std::size_t has_type_at_t = decltype(select<W>(
-  indexer<std::index_sequence_for<Ts...>, Ts...>{}))::index;
-} // namespace
-
-template <typename W>
-constexpr std::size_t has_type_at_v(o2::framework::pack<>)
-{
-  return -1;
-}
-
-template <typename W, typename... Ts>
-constexpr std::size_t has_type_at_v(o2::framework::pack<Ts...>)
-{
-  return has_type_at_t<W, Ts...>;
+  return size + 1;
 }
 
 /// Intersect two packs

Framework/Foundation/test/test_FunctionalHelpers.cxx

@@ -37,10 +37,10 @@ TEST_CASE("TestOverride")
   static_assert(has_type_conditional_v<std::is_same, double, pack<int, float>> == false, "double should not be in the pack");
 
   pack<float, char, int, bool> pck;
-  static_assert(has_type_at<int>(pck) == 2, "int should be at 2");
-  static_assert(has_type_at<double>(pck) == pack_size(pck) + 1, "double is not in the pack so the function returns size + 1");
-  static_assert(has_type_at_conditional<std::is_same, bool>(pack<int, float, bool>()) == 2, "bool should be at 2");
-  static_assert(has_type_at_conditional<std::is_same, bool>(pack<int, float, double>()) == 3 + 1, "bool is not in the pack so the function returns size + 1");
+  static_assert(has_type_at_v<int>(pck) == 2, "int should be at 2");
+  static_assert(has_type_at_v<double>(pck) == pack_size(pck) + 1, "double is not in the pack so the function returns size + 1");
+  static_assert(has_type_at_conditional_v<std::is_same, bool>(pack<int, float, bool>()) == 2, "bool should be at 2");
+  static_assert(has_type_at_conditional_v<std::is_same, bool>(pack<int, float, double>()) == 3 + 1, "bool is not in the pack so the function returns size + 1");
 
   static_assert(std::is_same_v<selected_pack<is_int_t, int, float, char>, pack<int>>, "selector should select int");
   static_assert(std::is_same_v<selected_pack<is_int_t, int, int, float, char>, pack<int, int>>, "selector should select int");