DPL Analysis: Remove selected pack rework

Framework/Core/include/Framework/ASoA.h

@@ -213,8 +213,6 @@ template <typename D, typename... Cs>
 struct TableMetadata {
   using columns = framework::pack<Cs...>;
   using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, Cs...>;
-  using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, Cs...>;
-  using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, Cs...>;
 
   template <typename Key, typename... PCs>
   static consteval std::array<bool, sizeof...(PCs)> getMap(framework::pack<PCs...>)
@@ -814,9 +812,6 @@ concept is_dynamic_column = requires(C& c) {
 template <typename C>
 concept is_marker_column = requires { &C::mark; };
 
-template <typename T>
-using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
-
 template <typename T>
 concept is_column = is_persistent_column<T> || is_dynamic_column<T> || is_indexing_column<T> || is_marker_column<T>;
 
@@ -1039,28 +1034,36 @@ concept can_bind = requires(T&& t) {
 template <typename... C>
 concept has_index = (is_indexing_column<C> || ...);
 
+template <typename T, typename... Cs>
+consteval auto inBindings(framework::pack<Cs...>)
+{
+  return framework::has_type_at_v<T>(framework::pack<decltype([]<typename C>() {
+    if constexpr (is_index_column<C> && !is_self_index_column<C>) {
+      return std::declval<typename C::binding_t>();
+    } else {
+      return;
+    } }.template operator()<Cs>())...>{});
+}
+
 template <typename D, typename O, typename IP, typename... C>
 struct TableIterator : IP, C... {
  public:
   using self_t = TableIterator<D, O, IP, C...>;
   using policy_t = IP;
   using all_columns = framework::pack<C...>;
   using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, C...>;
-  using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, C...>;
-  using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, C...>;
-  using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) -> framework::pack<typename Cs::binding_t...> {}(external_index_columns_t{})); // decltype(extractBindings(external_index_columns_t{}));
 
   TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
     : IP{policy},
-      C(columnData[framework::has_type_at_v<C>(all_columns{})])...
+      C(columnData[framework::has_type_at_v<C>(framework::pack<C...>{})])...
   {
     bind();
   }
 
   TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
     requires(has_index<C...>)
     : IP{policy},
-      C(columnData[framework::has_type_at_v<C>(all_columns{})])...
+      C(columnData[framework::has_type_at_v<C>(framework::pack<C...>{})])...
   {
     bind();
     // In case we have an index column might need to constrain the actual
@@ -1138,58 +1141,61 @@ struct TableIterator : IP, C... {
     return *this;
   }
 
-  template <typename... CL, typename TA>
-  void doSetCurrentIndex(framework::pack<CL...>, TA* current)
-  {
-    (CL::setCurrent(current), ...);
-  }
-
   template <typename CL>
   auto getCurrent() const
   {
     return CL::getCurrentRaw();
   }
 
-  template <typename... Cs>
-  auto getIndexBindingsImpl(framework::pack<Cs...>) const
+  std::vector<o2::soa::Binding> getIndexBindings() const
   {
-    return std::vector<o2::soa::Binding>{static_cast<Cs const&>(*this).getCurrentRaw()...};
-  }
-
-  auto getIndexBindings() const
-  {
-    return getIndexBindingsImpl(external_index_columns_t{});
+    return { [this]<soa::is_column CL>() {
+      if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
+        return o2::soa::Binding{CL::getCurrentRaw()};
+      } else {
+        return o2::soa::Binding{};
+      }
+    }.template operator()<C>()... };
   }
 
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
-    (doSetCurrentIndex(external_index_columns_t{}, current), ...);
-  }
-
-  template <typename... Cs>
-  void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
-  {
-    (Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]), ...);
-  }
-
-  template <typename... Cs, typename I>
-  void doSetCurrentInternal(framework::pack<Cs...>, I const* ptr)
-  {
-    o2::soa::Binding b;
-    b.bind(ptr);
-    (Cs::setCurrentRaw(b), ...);
+    ([this]<typename... Cs, typename TT>(framework::pack<Cs...>, TT* t) {
+      ([this]<soa::is_column CL, typename TI>(TI* c) {
+        if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
+          CL::setCurrent(c);
+        }
+      }.template operator()<Cs, TT>(t),
+       ...);
+    }(framework::pack<C...>{}, current),
+     ...);
   }
 
-  void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
+  void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& bindings)
   {
-    doSetCurrentIndexRaw(external_index_columns_t{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
+    [&bindings, this]<size_t... Is>(std::index_sequence<Is...>) {
+      ([&bindings, this]() {
+        using column = typename framework::pack_element_t<Is, framework::pack<C...>>;
+        if constexpr (soa::is_index_column<column> && !soa::is_self_index_column<column>) {
+          column::setCurrentRaw(bindings[Is]);
+        }
+      }(),
+       ...);
+    }(std::make_index_sequence<sizeof...(C)>());
   }
 
   template <typename I>
   void bindInternalIndices(I const* table)
   {
-    doSetCurrentInternal(internal_index_columns_t{}, table);
+    o2::soa::Binding b;
+    b.bind(table);
+    ([this]<soa::is_column CL>(o2::soa::Binding const& bb) {
+      if constexpr (soa::is_self_index_column<CL>) {
+        CL::setCurrentRaw(bb);
+      }
+    }.template operator()<C>(b),
+     ...);
   }
 
  private:
@@ -1205,42 +1211,36 @@ struct TableIterator : IP, C... {
   void bind()
   {
     using namespace o2::soa;
-    auto f = framework::overloaded{
-      [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
-      [this]<soa::is_dynamic_column T>(T*) -> void { bindDynamicColumn<T>(typename T::bindings_t{}); },
-      [this]<typename T>(T*) -> void {},
-    };
-    (f(static_cast<C*>(nullptr)), ...);
+    ([this]() {
+      if constexpr (soa::is_persistent_column<C>) {
+        C::mColumnIterator.mCurrentPos = &this->mRowIndex;
+      } else if constexpr (soa::is_dynamic_column<C>) {
+        bindDynamicColumn<C>(typename C::bindings_t{});
+      }
+    }(),
+     ...);
+
     if constexpr (has_index<C...>) {
       this->setIndices(this->getIndices());
       this->setOffsets(this->getOffsets());
     }
   }
 
-  template <typename DC, typename... B>
-  auto bindDynamicColumn(framework::pack<B...>)
-  {
-    DC::boundIterators = std::make_tuple(getDynamicBinding<B>()...);
-  }
-
   // Sometimes dynamic columns are defined for tables in
   // the hope that it will be joined / extended with another one which provides
   // the full set of bindings. This is to avoid a compilation
   // error if constructor for the table or any other thing involving a missing
   // binding is preinstanciated.
-  template <typename B>
-    requires(can_bind<self_t, B>)
-  decltype(auto) getDynamicBinding()
-  {
-    static_assert(std::same_as<decltype(&(static_cast<B*>(this)->mColumnIterator)), std::decay_t<decltype(B::mColumnIterator)>*>, "foo");
-    return &(static_cast<B*>(this)->mColumnIterator);
-    // return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
-  }
-
-  template <typename B>
-  decltype(auto) getDynamicBinding()
+  template <typename DC, typename... B>
+  auto bindDynamicColumn(framework::pack<B...>)
   {
-    return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
+    DC::boundIterators = std::make_tuple([this]<typename Bi>() {
+      if constexpr (can_bind<self_t, Bi>) {
+        return &(static_cast<Bi*>(this)->mColumnIterator);
+      } else {
+        return static_cast<std::decay_t<decltype(Bi::mColumnIterator)>*>(nullptr);
+      }
+    }.template operator()<B>()...);
   }
 };
 
@@ -1373,25 +1373,39 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
-  return (o2::soa::is_binding_compatible_v<B, typename C::binding_t>() || ...);
+  return ([]<soa::is_column CC, typename BB>() {
+    if constexpr (soa::is_index_column<CC> && !soa::is_self_index_column<CC>) {
+      return o2::soa::is_binding_compatible_v<BB, typename CC::binding_t>();
+    } else {
+      return false;
+    }
+  }.template operator()<C, B>() ||
+          ...);
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
-  return ((C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()) || ...);
+  return ([]<soa::is_column CC, typename BB>() {
+    if constexpr (soa::is_index_column<CC> && !soa::is_self_index_column<CC>) {
+      return CC::sorted && o2::soa::is_binding_compatible_v<B, typename CC::binding_t>();
+    } else {
+      return false;
+    }
+  }.template operator()<C, B>() ||
+          ...);
 }
 
 template <typename B, typename Z>
 consteval static bool relatedByIndex()
 {
-  return hasIndexTo<B>(typename Z::table_t::external_index_columns_t{});
+  return hasIndexTo<B>(typename Z::table_t::columns_t{});
 }
 
 template <typename B, typename Z>
 consteval static bool relatedBySortedIndex()
 {
-  return hasSortedIndexTo<B>(typename Z::table_t::external_index_columns_t{});
+  return hasSortedIndexTo<B>(typename Z::table_t::columns_t{});
 }
 } // namespace o2::soa
 
@@ -1719,17 +1733,12 @@ class Table
   using persistent_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_persistent_column_t, C...> {}(columns_t{}));
   using column_types = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::type...> {}(persistent_columns_t{}));
 
-  using external_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_external_index_t, C...> {}(columns_t{}));
-  using internal_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_self_index_t, C...> {}(columns_t{}));
   template <typename IP>
   using base_iterator = decltype(base_iter<D, O, IP>(columns_t{}));
 
   template <typename IP, typename Parent, typename... T>
   struct TableIteratorBase : base_iterator<IP> {
     using columns_t = typename Parent::columns_t;
-    using external_index_columns_t = typename Parent::external_index_columns_t;
-    using bindings_pack_t = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::binding_t...> {}(external_index_columns_t{}));
-    // static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
     static constexpr auto originals = Parent::originals;
     using policy_t = IP;
     using parent_t = Parent;
@@ -1818,33 +1827,34 @@ class Table
     template <typename TI>
     auto getId() const
     {
-      using decayed = std::decay_t<TI>;
-      if constexpr (framework::has_type<decayed>(bindings_pack_t{})) { // index to another table
-        constexpr auto idx = framework::has_type_at_v<decayed>(bindings_pack_t{});
-        return framework::pack_element_t<idx, external_index_columns_t>::getId();
-      } else if constexpr (std::same_as<decayed, Parent>) { // self index
-        return this->globalIndex();
-      } else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
-        return this->globalIndex();
-      } else {
-        return static_cast<int32_t>(-1);
-      }
+      return static_cast<int32_t>(-1);
     }
 
-    template <typename CD, typename... CDArgs>
+    template <typename TI>
+      requires(std::same_as<std::decay_t<TI>, Parent> || is_indexing_column<std::decay_t<TI>>)
+    auto getId() const
+    {
+      return this->globalIndex();
+    }
+
+    template <typename TI>
+      requires(inBindings<std::decay_t<TI>>(typename Parent::all_columns{}) < framework::pack_size(typename Parent::all_columns{}))
+    auto getId() const
+    {
+      return inBindings<std::decay_t<TI>>(typename Parent::all_columns{});
+    }
+
+    template <soa::is_dynamic_column CD, typename... CDArgs>
     auto getDynamicColumn() const
     {
-      using decayed = std::decay_t<CD>;
-      static_assert(is_dynamic_t<decayed>(), "Requested column is not a dynamic column");
-      return static_cast<decayed>(*this).template getDynamicValue<CDArgs...>();
+      return static_cast<std::decay_t<CD>>(*this).template getDynamicValue<CDArgs...>();
     }
 
     template <typename B, typename CC>
+      requires(is_dynamic_column<CC> || is_persistent_column<CC>)
     auto getValue() const
     {
-      using COL = std::decay_t<CC>;
-      static_assert(is_dynamic_t<COL>() || soa::is_persistent_column<COL>, "Should be persistent or dynamic column with no argument that has a return type convertable to float");
-      return static_cast<B>(static_cast<COL>(*this).get());
+      return static_cast<B>(static_cast<std::decay_t<CC>>(*this).get());
     }
 
     template <typename B, typename... CCs>
@@ -2049,13 +2059,18 @@ class Table
 
   void bindInternalIndicesExplicit(o2::soa::Binding binding)
   {
-    doBindInternalIndicesExplicit(internal_index_columns_t{}, binding);
+    doBindInternalIndicesExplicit(columns_t{}, binding);
   }
 
   template <typename... Cs>
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
-    (static_cast<Cs>(mBegin).setCurrentRaw(binding), ...);
+    ([this]<soa::is_column CL>(o2::soa::Binding b) {
+      if constexpr (soa::is_self_index_column<CL>) {
+        static_cast<CL>(mBegin).setCurrentRaw(b);
+      }
+    }.template operator()<Cs>(binding),
+     ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
@@ -2072,7 +2087,7 @@ class Table
   template <typename T>
   void copyIndexBindings(T& dest) const
   {
-    doCopyIndexBindings(external_index_columns_t{}, dest);
+    doCopyIndexBindings(columns_t{}, dest);
   }
 
   auto select(framework::expressions::Filter const& f) const
@@ -3349,7 +3364,6 @@ class FilteredBase : public T
   using T::originals;
   using columns_t = typename T::columns_t;
   using persistent_columns_t = typename T::persistent_columns_t;
-  using external_index_columns_t = typename T::external_index_columns_t;
 
   using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
   using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
@@ -3495,7 +3509,7 @@ class FilteredBase : public T
   template <typename T1>
   void copyIndexBindings(T1& dest) const
   {
-    doCopyIndexBindings(external_index_columns_t{}, dest);
+    doCopyIndexBindings(columns_t{}, dest);
   }
 
   template <typename T1>

Framework/Core/include/Framework/GroupedCombinations.h

@@ -35,13 +35,18 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
 }
 
 template <typename T, typename G>
-using is_index_to_g_t = typename std::conditional<o2::soa::is_binding_compatible_v<G, typename T::binding_t>(), std::true_type, std::false_type>::type;
+using is_index_to_g_t = decltype([]() {
+  if constexpr (soa::is_index_column<T> && !soa::is_self_index_column<T>) {
+    return std::conditional_t<o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>(), std::true_type, std::false_type>{};
+  } else {
+    return std::false_type{};
+  }
+}());
 
 template <typename G, typename A>
 expressions::BindingNode getMatchingIndexNode()
 {
-  using external_index_columns_pack = typename A::external_index_columns_t;
-  using selected_indices_t = selected_pack_multicondition<is_index_to_g_t, pack<G>, external_index_columns_pack>;
+  using selected_indices_t = selected_pack_multicondition<is_index_to_g_t, pack<G>, typename A::columns_t>;
   static_assert(pack_size(selected_indices_t{}) == 1, "No matching index column from associated to grouping");
   using index_column_t = pack_head_t<selected_indices_t>;
   return expressions::BindingNode{index_column_t::mLabel, o2::framework::TypeIdHelpers::uniqueId<typename index_column_t::column_t>(), expressions::selectArrowType<typename index_column_t::type>()};