Skip to content

Commit 53ed758

Browse files
aalkinaalkin
authored
DPL Analysis: remove unnecessary instances of selected_pack (#13892)
1 parent 8baefd9 commit 53ed758

File tree

3 files changed

+101
-41
lines changed

3 files changed

+101
-41
lines changed

‎Framework/Core/include/Framework/ASoA.h‎

Lines changed: 78 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -208,8 +208,6 @@ template <typename D, typename... Cs>
208208
struct TableMetadata {
209209
using columns = framework::pack<Cs...>;
210210
using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, Cs...>;
211-
using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, Cs...>;
212-
using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, Cs...>;
213211

214212
template <typename Key, typename... PCs>
215213
static consteval std::array<bool, sizeof...(PCs)> getMap(framework::pack<PCs...>)
@@ -806,9 +804,6 @@ concept is_dynamic_column = requires(C& c) {
806804
template <typename C>
807805
concept is_marker_column = requires { &C::mark; };
808806

809-
template <typename T>
810-
using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
811-
812807
template <typename T>
813808
concept is_column = is_persistent_column<T> || is_dynamic_column<T> || is_indexing_column<T> || is_marker_column<T>;
814809

@@ -1031,16 +1026,27 @@ concept can_bind = requires(T&& t) {
10311026
template <typename... C>
10321027
concept has_index = (is_indexing_column<C> || ...);
10331028

1029+
template <is_index_column C>
1030+
requires(!is_self_index_column<C>)
1031+
consteval auto getBinding() -> typename C::binding_t
1032+
{
1033+
}
1034+
1035+
template <typename C>
1036+
consteval auto getBinding() -> void
1037+
{
1038+
}
1039+
10341040
template <typename D, typename O, typename IP, typename... C>
10351041
struct TableIterator : IP, C... {
10361042
public:
10371043
using self_t = TableIterator<D, O, IP, C...>;
10381044
using policy_t = IP;
10391045
using all_columns = framework::pack<C...>;
10401046
using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, C...>;
1041-
using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, C...>;
1042-
using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, C...>;
1043-
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{}));
1047+
using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) {
1048+
return framework::pack<decltype(getBinding<Cs>())...>{};
1049+
}(all_columns{}));
10441050

10451051
TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
10461052
: IP{policy},
@@ -1133,7 +1139,13 @@ struct TableIterator : IP, C... {
11331139
template <typename... CL, typename TA>
11341140
void doSetCurrentIndex(framework::pack<CL...>, TA* current)
11351141
{
1136-
(CL::setCurrent(current), ...);
1142+
(framework::overloaded{
1143+
[&current, this]<is_index_column CI>
1144+
requires(!is_self_index_column<CI>)
1145+
() { CI::setCurrent(current); },
1146+
[]<typename CI>() {}}
1147+
.template operator()<CL>(),
1148+
...);
11371149
}
11381150

11391151
template <typename CL>
@@ -1145,43 +1157,63 @@ struct TableIterator : IP, C... {
11451157
template <typename... Cs>
11461158
auto getIndexBindingsImpl(framework::pack<Cs...>) const
11471159
{
1148-
return std::vector<o2::soa::Binding>{static_cast<Cs const&>(*this).getCurrentRaw()...};
1160+
std::vector<o2::soa::Binding> result;
1161+
(framework::overloaded{
1162+
[this, &result]<is_index_column CI>
1163+
requires(!is_self_index_column<CI>)
1164+
() mutable {
1165+
result.emplace_back(CI::getCurrentRaw());
1166+
},
1167+
[]<typename CI>() {}}
1168+
.template operator()<Cs>(),
1169+
...);
1170+
return result;
11491171
}
11501172

11511173
auto getIndexBindings() const
11521174
{
1153-
return getIndexBindingsImpl(external_index_columns_t{});
1175+
return getIndexBindingsImpl(all_columns{});
11541176
}
11551177

11561178
template <typename... TA>
11571179
void bindExternalIndices(TA*... current)
11581180
{
1159-
(doSetCurrentIndex(external_index_columns_t{}, current), ...);
1181+
(doSetCurrentIndex(all_columns{}, current), ...);
11601182
}
11611183

11621184
template <typename... Cs>
11631185
void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
11641186
{
1165-
(Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]), ...);
1187+
(framework::overloaded{
1188+
[&ptrs, p, this]<is_self_index_column CI>
1189+
requires(!is_self_index_column<CI>)
1190+
() { CI::setCurrentRaw(ptrs[framework::has_type_at_v<CI>(p)]); },
1191+
[]<typename CI>() {}}
1192+
.template operator()<Cs>(),
1193+
...);
11661194
}
11671195

11681196
template <typename... Cs, typename I>
11691197
void doSetCurrentInternal(framework::pack<Cs...>, I const* ptr)
11701198
{
11711199
o2::soa::Binding b;
11721200
b.bind(ptr);
1173-
(Cs::setCurrentRaw(b), ...);
1201+
(framework::overloaded{
1202+
[&ptr, &b, this]<is_self_index_column CI>() { CI::setCurrentRaw(b); },
1203+
[]<typename CI>() {}}
1204+
.template operator()<Cs>(),
1205+
...);
11741206
}
11751207

11761208
void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
11771209
{
1178-
doSetCurrentIndexRaw(external_index_columns_t{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
1210+
doSetCurrentIndexRaw(all_columns{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
11791211
}
11801212

11811213
template <typename I>
11821214
void bindInternalIndices(I const* table)
11831215
{
1184-
doSetCurrentInternal(internal_index_columns_t{}, table);
1216+
doSetCurrentInternal(all_columns{}, table);
11851217
}
11861218

11871219
private:
@@ -1365,25 +1397,37 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
13651397
template <typename B, typename... C>
13661398
consteval static bool hasIndexTo(framework::pack<C...>&&)
13671399
{
1368-
return (o2::soa::is_binding_compatible_v<B, typename C::binding_t>() || ...);
1400+
return (framework::overloaded{
1401+
[]<is_index_column CI>
1402+
requires(!is_self_index_column<CI>)
1403+
() { return o2::soa::is_binding_compatible_v<B, typename CI::binding_t>(); },
1404+
[]<typename CI>() { return false; }}
1405+
.template operator()<C>() ||
1406+
...);
13691407
}
13701408

13711409
template <typename B, typename... C>
13721410
consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
13731411
{
1374-
return ((C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()) || ...);
1412+
return (framework::overloaded{
1413+
[]<is_index_column CI>
1414+
requires(!is_self_index_column<CI>)
1415+
() { return (CI::sorted && o2::soa::is_binding_compatible_v<B, typename CI::binding_t>()); },
1416+
[]<typename CI>() {}}
1417+
.template operator()<C>() ||
1418+
...);
13751419
}
13761420

13771421
template <typename B, typename Z>
13781422
consteval static bool relatedByIndex()
13791423
{
1380-
return hasIndexTo<B>(typename Z::table_t::external_index_columns_t{});
1424+
return hasIndexTo<B>(typename Z::table_t::columns_t{});
13811425
}
13821426

13831427
template <typename B, typename Z>
13841428
consteval static bool relatedBySortedIndex()
13851429
{
1386-
return hasSortedIndexTo<B>(typename Z::table_t::external_index_columns_t{});
1430+
return hasSortedIndexTo<B>(typename Z::table_t::columns_t{});
13871431
}
13881432
} // namespace o2::soa
13891433

@@ -1726,16 +1770,13 @@ class Table
17261770
using persistent_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_persistent_column_t, C...> {}(columns_t{}));
17271771
using column_types = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::type...> {}(persistent_columns_t{}));
17281772

1729-
using external_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_external_index_t, C...> {}(columns_t{}));
1730-
using internal_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_self_index_t, C...> {}(columns_t{}));
17311773
template <typename IP>
17321774
using base_iterator = decltype(base_iter<D, O, IP>(columns_t{}));
17331775

17341776
template <typename IP, typename Parent, typename... T>
17351777
struct TableIteratorBase : base_iterator<IP> {
17361778
using columns_t = typename Parent::columns_t;
1737-
using external_index_columns_t = typename Parent::external_index_columns_t;
1738-
using bindings_pack_t = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::binding_t...> {}(external_index_columns_t{}));
1779+
using bindings_pack_t = typename base_iterator<IP>::bindings_pack_t;
17391780
// static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
17401781
static constexpr auto originals = Parent::originals;
17411782
using policy_t = IP;
@@ -1828,7 +1869,7 @@ class Table
18281869
using decayed = std::decay_t<TI>;
18291870
if constexpr (framework::has_type<decayed>(bindings_pack_t{})) { // index to another table
18301871
constexpr auto idx = framework::has_type_at_v<decayed>(bindings_pack_t{});
1831-
return framework::pack_element_t<idx, external_index_columns_t>::getId();
1872+
return framework::pack_element_t<idx, columns_t>::getId();
18321873
} else if constexpr (std::same_as<decayed, Parent>) { // self index
18331874
return this->globalIndex();
18341875
} else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
@@ -1838,20 +1879,17 @@ class Table
18381879
}
18391880
}
18401881

1841-
template <typename CD, typename... CDArgs>
1882+
template <soa::is_dynamic_column CD, typename... CDArgs>
18421883
auto getDynamicColumn() const
18431884
{
1844-
using decayed = std::decay_t<CD>;
1845-
static_assert(is_dynamic_t<decayed>(), "Requested column is not a dynamic column");
1846-
return static_cast<decayed>(*this).template getDynamicValue<CDArgs...>();
1885+
return static_cast<std::decay_t<CD>>(*this).template getDynamicValue<CDArgs...>();
18471886
}
18481887

18491888
template <typename B, typename CC>
1889+
requires(is_dynamic_column<CC> || is_persistent_column<CC>)
18501890
auto getValue() const
18511891
{
1852-
using COL = std::decay_t<CC>;
1853-
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");
1854-
return static_cast<B>(static_cast<COL>(*this).get());
1892+
return static_cast<B>(static_cast<std::decay_t<CC>>(*this).get());
18551893
}
18561894

18571895
template <typename B, typename... CCs>
@@ -2056,13 +2094,17 @@ class Table
20562094

20572095
void bindInternalIndicesExplicit(o2::soa::Binding binding)
20582096
{
2059-
doBindInternalIndicesExplicit(internal_index_columns_t{}, binding);
2097+
doBindInternalIndicesExplicit(columns_t{}, binding);
20602098
}
20612099

20622100
template <typename... Cs>
20632101
void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
20642102
{
2065-
(static_cast<Cs>(mBegin).setCurrentRaw(binding), ...);
2103+
(framework::overloaded{
2104+
[this, &binding]<is_self_index_column CI>() { static_cast<CI>(mBegin).setCurrentRaw(binding); },
2105+
[]<typename CI>() {}}
2106+
.template operator()<Cs>(),
2107+
...);
20662108
}
20672109

20682110
void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
@@ -2079,7 +2121,7 @@ class Table
20792121
template <typename T>
20802122
void copyIndexBindings(T& dest) const
20812123
{
2082-
doCopyIndexBindings(external_index_columns_t{}, dest);
2124+
doCopyIndexBindings(columns_t{}, dest);
20832125
}
20842126

20852127
auto select(framework::expressions::Filter const& f) const
@@ -3298,7 +3340,6 @@ class FilteredBase : public T
32983340
using T::originals;
32993341
using columns_t = typename T::columns_t;
33003342
using persistent_columns_t = typename T::persistent_columns_t;
3301-
using external_index_columns_t = typename T::external_index_columns_t;
33023343

33033344
using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
33043345
using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
@@ -3444,7 +3485,7 @@ class FilteredBase : public T
34443485
template <typename T1>
34453486
void copyIndexBindings(T1& dest) const
34463487
{
3447-
doCopyIndexBindings(external_index_columns_t{}, dest);
3488+
doCopyIndexBindings(columns_t{}, dest);
34483489
}
34493490

34503491
template <typename T1>

‎Framework/Core/include/Framework/Configurable.h‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,9 @@ struct Configurable : IP {
8383
template <typename T, ConfigParamKind K = ConfigParamKind::kGeneric>
8484
using MutableConfigurable = Configurable<T, K, ConfigurablePolicyMutable<T, K>>;
8585

86+
template <typename T>
87+
concept is_configurable = requires(T& t) { &T::operator typename T::type; };
88+
8689
using ConfigurableAxis = Configurable<std::vector<double>, ConfigParamKind::kAxisSpec, ConfigurablePolicyConst<std::vector<double>, ConfigParamKind::kAxisSpec>>;
8790

8891
template <typename R, typename T, typename... As>
@@ -97,7 +100,7 @@ struct ProcessConfigurable : Configurable<bool, ConfigParamKind::kProcessFlag> {
97100
};
98101

99102
template <typename T>
100-
concept is_process_configurable = base_of_template<ProcessConfigurable, T>;
103+
concept is_process_configurable = is_configurable<T> && requires(T& t) { t.process; };
101104

102105
#define PROCESS_SWITCH(_Class_, _Name_, _Help_, _Default_) \
103106
decltype(ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_}) do##_Name_ = ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_};

‎Framework/Core/include/Framework/GroupedCombinations.h‎

Lines changed: 19 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -34,14 +34,30 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
3434
return interleaveTuplesImpl(t1, t2, std::index_sequence_for<T1s...>());
3535
}
3636

37+
template <soa::is_index_column T, typename G>
38+
requires(!soa::is_self_index_column<T>)
39+
consteval auto isIndexTo()
40+
{
41+
if constexpr (o2::soa::is_binding_compatible_v<G, typename T::binding_t>()) {
42+
return std::true_type{};
43+
} else {
44+
return std::false_type{};
45+
}
46+
}
47+
48+
template <typename T, typename G>
49+
consteval auto isIndexTo()
50+
{
51+
return std::false_type{};
52+
}
53+
3754
template <typename T, typename G>
38-
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;
55+
using is_index_to_g_t = decltype(isIndexTo<T, G>());
3956

4057
template <typename G, typename A>
4158
expressions::BindingNode getMatchingIndexNode()
4259
{
43-
using external_index_columns_pack = typename A::external_index_columns_t;
44-
using selected_indices_t = selected_pack_multicondition<is_index_to_g_t, pack<G>, external_index_columns_pack>;
60+
using selected_indices_t = selected_pack_multicondition<is_index_to_g_t, pack<G>, typename A::columns_t>;
4561
static_assert(pack_size(selected_indices_t{}) == 1, "No matching index column from associated to grouping");
4662
using index_column_t = pack_head_t<selected_indices_t>;
4763
return expressions::BindingNode{index_column_t::mLabel, o2::framework::TypeIdHelpers::uniqueId<typename index_column_t::column_t>(), expressions::selectArrowType<typename index_column_t::type>()};

0 commit comments

Comments
 (0)