Skip to content

Commit f6ce9ae

Browse files
ktfktf
authored
Revert "DPL Analysis: remove unnecessary instances of selected_pack (#13892)" (#13913)
This reverts commit 53ed758.
1 parent dff469f commit f6ce9ae

File tree

3 files changed

+41
-101
lines changed

3 files changed

+41
-101
lines changed

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

Lines changed: 37 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -208,6 +208,8 @@ 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...>;
211213

212214
template <typename Key, typename... PCs>
213215
static consteval std::array<bool, sizeof...(PCs)> getMap(framework::pack<PCs...>)
@@ -804,6 +806,9 @@ concept is_dynamic_column = requires(C& c) {
804806
template <typename C>
805807
concept is_marker_column = requires { &C::mark; };
806808

809+
template <typename T>
810+
using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
811+
807812
template <typename T>
808813
concept is_column = is_persistent_column<T> || is_dynamic_column<T> || is_indexing_column<T> || is_marker_column<T>;
809814

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

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-
10401034
template <typename D, typename O, typename IP, typename... C>
10411035
struct TableIterator : IP, C... {
10421036
public:
10431037
using self_t = TableIterator<D, O, IP, C...>;
10441038
using policy_t = IP;
10451039
using all_columns = framework::pack<C...>;
10461040
using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, C...>;
1047-
using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) {
1048-
return framework::pack<decltype(getBinding<Cs>())...>{};
1049-
}(all_columns{}));
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{}));
10501044

10511045
TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
10521046
: IP{policy},
@@ -1139,13 +1133,7 @@ struct TableIterator : IP, C... {
11391133
template <typename... CL, typename TA>
11401134
void doSetCurrentIndex(framework::pack<CL...>, TA* current)
11411135
{
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-
...);
1136+
(CL::setCurrent(current), ...);
11491137
}
11501138

11511139
template <typename CL>
@@ -1157,63 +1145,43 @@ struct TableIterator : IP, C... {
11571145
template <typename... Cs>
11581146
auto getIndexBindingsImpl(framework::pack<Cs...>) const
11591147
{
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;
1148+
return std::vector<o2::soa::Binding>{static_cast<Cs const&>(*this).getCurrentRaw()...};
11711149
}
11721150

11731151
auto getIndexBindings() const
11741152
{
1175-
return getIndexBindingsImpl(all_columns{});
1153+
return getIndexBindingsImpl(external_index_columns_t{});
11761154
}
11771155

11781156
template <typename... TA>
11791157
void bindExternalIndices(TA*... current)
11801158
{
1181-
(doSetCurrentIndex(all_columns{}, current), ...);
1159+
(doSetCurrentIndex(external_index_columns_t{}, current), ...);
11821160
}
11831161

11841162
template <typename... Cs>
11851163
void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
11861164
{
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-
...);
1165+
(Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]), ...);
11941166
}
11951167

11961168
template <typename... Cs, typename I>
11971169
void doSetCurrentInternal(framework::pack<Cs...>, I const* ptr)
11981170
{
11991171
o2::soa::Binding b;
12001172
b.bind(ptr);
1201-
(framework::overloaded{
1202-
[&ptr, &b, this]<is_self_index_column CI>() { CI::setCurrentRaw(b); },
1203-
[]<typename CI>() {}}
1204-
.template operator()<Cs>(),
1205-
...);
1173+
(Cs::setCurrentRaw(b), ...);
12061174
}
12071175

12081176
void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
12091177
{
1210-
doSetCurrentIndexRaw(all_columns{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
1178+
doSetCurrentIndexRaw(external_index_columns_t{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
12111179
}
12121180

12131181
template <typename I>
12141182
void bindInternalIndices(I const* table)
12151183
{
1216-
doSetCurrentInternal(all_columns{}, table);
1184+
doSetCurrentInternal(internal_index_columns_t{}, table);
12171185
}
12181186

12191187
private:
@@ -1397,37 +1365,25 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
13971365
template <typename B, typename... C>
13981366
consteval static bool hasIndexTo(framework::pack<C...>&&)
13991367
{
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-
...);
1368+
return (o2::soa::is_binding_compatible_v<B, typename C::binding_t>() || ...);
14071369
}
14081370

14091371
template <typename B, typename... C>
14101372
consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
14111373
{
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-
...);
1374+
return ((C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()) || ...);
14191375
}
14201376

14211377
template <typename B, typename Z>
14221378
consteval static bool relatedByIndex()
14231379
{
1424-
return hasIndexTo<B>(typename Z::table_t::columns_t{});
1380+
return hasIndexTo<B>(typename Z::table_t::external_index_columns_t{});
14251381
}
14261382

14271383
template <typename B, typename Z>
14281384
consteval static bool relatedBySortedIndex()
14291385
{
1430-
return hasSortedIndexTo<B>(typename Z::table_t::columns_t{});
1386+
return hasSortedIndexTo<B>(typename Z::table_t::external_index_columns_t{});
14311387
}
14321388
} // namespace o2::soa
14331389

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

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{}));
17731731
template <typename IP>
17741732
using base_iterator = decltype(base_iter<D, O, IP>(columns_t{}));
17751733

17761734
template <typename IP, typename Parent, typename... T>
17771735
struct TableIteratorBase : base_iterator<IP> {
17781736
using columns_t = typename Parent::columns_t;
1779-
using bindings_pack_t = typename base_iterator<IP>::bindings_pack_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{}));
17801739
// static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
17811740
static constexpr auto originals = Parent::originals;
17821741
using policy_t = IP;
@@ -1869,7 +1828,7 @@ class Table
18691828
using decayed = std::decay_t<TI>;
18701829
if constexpr (framework::has_type<decayed>(bindings_pack_t{})) { // index to another table
18711830
constexpr auto idx = framework::has_type_at_v<decayed>(bindings_pack_t{});
1872-
return framework::pack_element_t<idx, columns_t>::getId();
1831+
return framework::pack_element_t<idx, external_index_columns_t>::getId();
18731832
} else if constexpr (std::same_as<decayed, Parent>) { // self index
18741833
return this->globalIndex();
18751834
} else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
@@ -1879,17 +1838,20 @@ class Table
18791838
}
18801839
}
18811840

1882-
template <soa::is_dynamic_column CD, typename... CDArgs>
1841+
template <typename CD, typename... CDArgs>
18831842
auto getDynamicColumn() const
18841843
{
1885-
return static_cast<std::decay_t<CD>>(*this).template getDynamicValue<CDArgs...>();
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...>();
18861847
}
18871848

18881849
template <typename B, typename CC>
1889-
requires(is_dynamic_column<CC> || is_persistent_column<CC>)
18901850
auto getValue() const
18911851
{
1892-
return static_cast<B>(static_cast<std::decay_t<CC>>(*this).get());
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());
18931855
}
18941856

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

20952057
void bindInternalIndicesExplicit(o2::soa::Binding binding)
20962058
{
2097-
doBindInternalIndicesExplicit(columns_t{}, binding);
2059+
doBindInternalIndicesExplicit(internal_index_columns_t{}, binding);
20982060
}
20992061

21002062
template <typename... Cs>
21012063
void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
21022064
{
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-
...);
2065+
(static_cast<Cs>(mBegin).setCurrentRaw(binding), ...);
21082066
}
21092067

21102068
void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
@@ -2121,7 +2079,7 @@ class Table
21212079
template <typename T>
21222080
void copyIndexBindings(T& dest) const
21232081
{
2124-
doCopyIndexBindings(columns_t{}, dest);
2082+
doCopyIndexBindings(external_index_columns_t{}, dest);
21252083
}
21262084

21272085
auto select(framework::expressions::Filter const& f) const
@@ -3340,6 +3298,7 @@ class FilteredBase : public T
33403298
using T::originals;
33413299
using columns_t = typename T::columns_t;
33423300
using persistent_columns_t = typename T::persistent_columns_t;
3301+
using external_index_columns_t = typename T::external_index_columns_t;
33433302

33443303
using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
33453304
using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
@@ -3485,7 +3444,7 @@ class FilteredBase : public T
34853444
template <typename T1>
34863445
void copyIndexBindings(T1& dest) const
34873446
{
3488-
doCopyIndexBindings(columns_t{}, dest);
3447+
doCopyIndexBindings(external_index_columns_t{}, dest);
34893448
}
34903449

34913450
template <typename T1>

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

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -83,9 +83,6 @@ 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-
8986
using ConfigurableAxis = Configurable<std::vector<double>, ConfigParamKind::kAxisSpec, ConfigurablePolicyConst<std::vector<double>, ConfigParamKind::kAxisSpec>>;
9087

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

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

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

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

Lines changed: 3 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -34,30 +34,14 @@ 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-
5437
template <typename T, typename G>
55-
using is_index_to_g_t = decltype(isIndexTo<T, 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;
5639

5740
template <typename G, typename A>
5841
expressions::BindingNode getMatchingIndexNode()
5942
{
60-
using selected_indices_t = selected_pack_multicondition<is_index_to_g_t, pack<G>, typename A::columns_t>;
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>;
6145
static_assert(pack_size(selected_indices_t{}) == 1, "No matching index column from associated to grouping");
6246
using index_column_t = pack_head_t<selected_indices_t>;
6347
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)