Skip to content

Commit bd8082a

Browse files
aalkinaalkin
committed
use compile-time process/argument indices
1 parent bc5ae33 commit bd8082a

1 file changed

Lines changed: 27 additions & 27 deletions

File tree

‎Framework/Core/include/Framework/AnalysisTask.h‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -102,15 +102,15 @@ struct AnalysisDataProcessorBuilder {
102102
(doAppendInputWithMetadata<Args>(inputs), ...);
103103
}
104104

105-
template <typename T>
106-
static void appendSomethingWithMetadata(std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, int processIndex, int argumentIndex)
105+
template <typename T, int PI, int AI>
106+
static void appendSomethingWithMetadata(std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos)
107107
{
108108
using dT = std::decay_t<T>;
109109
if constexpr (framework::is_specialization<dT, soa::Filtered>::value) {
110-
eInfos.push_back({argumentIndex, processIndex, dT::hashes(), o2::soa::createSchemaFromColumns(typename dT::table_t::persistent_columns_t{}), nullptr});
110+
eInfos.push_back({AI, PI, dT::hashes(), o2::soa::createSchemaFromColumns(typename dT::table_t::persistent_columns_t{}), nullptr});
111111
} else if constexpr (soa::is_soa_iterator_t<dT>::value) {
112112
if constexpr (std::is_same_v<typename dT::policy_t, soa::FilteredIndexPolicy>) {
113-
eInfos.push_back({argumentIndex, processIndex, dT::parent_t::hashes(), o2::soa::createSchemaFromColumns(typename dT::table_t::persistent_columns_t{}), nullptr});
113+
eInfos.push_back({AI, PI, dT::parent_t::hashes(), o2::soa::createSchemaFromColumns(typename dT::table_t::persistent_columns_t{}), nullptr});
114114
}
115115
}
116116
doAppendInputWithMetadata(soa::make_originals_from_type<dT>(), inputs);
@@ -119,13 +119,13 @@ struct AnalysisDataProcessorBuilder {
119119
template <typename... T>
120120
static void inputsFromArgsTuple(std::tuple<T...>& processTuple, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos)
121121
{
122-
(inputsFromArgs(std::get<T>(processTuple), inputs, eInfos, o2::framework::has_type_at_v<T>(pack<T...>{})), ...);
122+
(inputsFromArgs<o2::framework::has_type_at_v<T>(pack<T...>{})>(std::get<T>(processTuple), inputs, eInfos), ...);
123123
}
124124

125-
template <typename R, typename C, typename... Args>
126-
static void inputsFromArgs(R (C::*)(Args...), std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, int processIndex)
125+
template <int PI, typename R, typename C, typename... Args>
126+
static void inputsFromArgs(R (C::*)(Args...), std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos)
127127
{
128-
(appendSomethingWithMetadata<Args>(inputs, eInfos, processIndex, o2::framework::has_type_at_v<Args>(pack<Args...>{})), ...);
128+
(appendSomethingWithMetadata<Args, PI, o2::framework::has_type_at_v<Args>(pack<Args...>{})>(inputs, eInfos), ...);
129129
}
130130

131131
template <typename R, typename C, typename Grouping, typename... Args>
@@ -134,14 +134,14 @@ struct AnalysisDataProcessorBuilder {
134134
return std::declval<std::tuple<Grouping, Args...>>();
135135
}
136136

137-
template <typename R, typename C, typename Grouping, typename... Args>
138-
static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo> const& infos, int processIndex)
137+
template <int PI, typename R, typename C, typename Grouping, typename... Args>
138+
static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo> const& infos)
139139
{
140-
return extractSomethingFromRecord<Grouping>(record, infos, processIndex, 0);
140+
return extractSomethingFromRecord<Grouping, PI, 0>(record, infos);
141141
}
142142

143-
template <typename R, typename C>
144-
static auto bindGroupingTable(InputRecord&, R (C::*)(), std::vector<ExpressionInfo> const&, int)
143+
template <int PI, typename R, typename C>
144+
static auto bindGroupingTable(InputRecord&, R (C::*)(), std::vector<ExpressionInfo> const&)
145145
{
146146
static_assert(always_static_assert_v<C>, "Your task process method needs at least one argument");
147147
return o2::soa::Table<>{nullptr};
@@ -182,21 +182,21 @@ struct AnalysisDataProcessorBuilder {
182182
}
183183
}
184184

185-
template <typename T>
186-
static auto extractSomethingFromRecord(InputRecord& record, std::vector<ExpressionInfo> const infos, int processIndex, int argumentIndex)
185+
template <typename T, int PI, int AI>
186+
static auto extractSomethingFromRecord(InputRecord& record, std::vector<ExpressionInfo> const infos)
187187
{
188188
using decayed = std::decay_t<T>;
189189

190190
if constexpr (soa::is_soa_filtered_t<decayed>::value) {
191191
for (auto& info : infos) {
192-
if (info.processIndex == processIndex && info.argumentIndex == argumentIndex) {
192+
if (info.processIndex == PI && info.argumentIndex == AI) {
193193
return extractFilteredFromRecord<decayed>(record, info, soa::make_originals_from_type<decayed>());
194194
}
195195
}
196196
} else if constexpr (soa::is_soa_iterator_t<decayed>::value) {
197197
if constexpr (std::is_same_v<typename decayed::policy_t, soa::FilteredIndexPolicy>) {
198198
for (auto& info : infos) {
199-
if (info.processIndex == processIndex && info.argumentIndex == argumentIndex) {
199+
if (info.processIndex == PI && info.argumentIndex == AI) {
200200
return extractFilteredFromRecord<decayed>(record, info, soa::make_originals_from_type<decayed>());
201201
}
202202
}
@@ -209,14 +209,14 @@ struct AnalysisDataProcessorBuilder {
209209
O2_BUILTIN_UNREACHABLE();
210210
}
211211

212-
template <typename R, typename C, typename Grouping, typename... Args>
213-
static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo> const infos, int processIndex)
212+
template <int PI, typename R, typename C, typename Grouping, typename... Args>
213+
static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo> const infos)
214214
{
215-
return std::make_tuple(extractSomethingFromRecord<Args>(record, infos, processIndex, has_type_at_v<Args>(pack<Args...>{}) + 1u)...);
215+
return std::make_tuple(extractSomethingFromRecord<Args, PI, has_type_at_v<Args>(pack<Args...>{}) + 1>(record, infos)...);
216216
}
217217

218-
template <typename R, typename C>
219-
static auto bindAssociatedTables(InputRecord&, R (C::*)(), std::vector<ExpressionInfo> const, int)
218+
template <int PI, typename R, typename C>
219+
static auto bindAssociatedTables(InputRecord&, R (C::*)(), std::vector<ExpressionInfo> const)
220220
{
221221
static_assert(always_static_assert_v<C>, "Your task process method needs at least one argument");
222222
return std::tuple<>{};
@@ -449,15 +449,15 @@ struct AnalysisDataProcessorBuilder {
449449
template <typename Task, typename... T>
450450
static void invokeProcessTuple(Task& task, InputRecord& inputs, std::tuple<T...> const& processTuple, std::vector<ExpressionInfo> const& infos)
451451
{
452-
(invokeProcess(task, inputs, std::get<T>(processTuple), infos, o2::framework::has_type_at_v<T>(pack<T...>{})), ...);
452+
(invokeProcess<o2::framework::has_type_at_v<T>(pack<T...>{})>(task, inputs, std::get<T>(processTuple), infos), ...);
453453
}
454454

455-
template <typename Task, typename R, typename C, typename Grouping, typename... Associated>
456-
static void invokeProcess(Task& task, InputRecord& inputs, R (C::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo> const& infos, int processIndex)
455+
template <int PI, typename Task, typename R, typename C, typename Grouping, typename... Associated>
456+
static void invokeProcess(Task& task, InputRecord& inputs, R (C::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo> const& infos)
457457
{
458458
auto tupledTask = o2::framework::to_tuple_refs(task);
459459
using G = std::decay_t<Grouping>;
460-
auto groupingTable = AnalysisDataProcessorBuilder::bindGroupingTable(inputs, processingFunction, infos, processIndex);
460+
auto groupingTable = AnalysisDataProcessorBuilder::bindGroupingTable<PI>(inputs, processingFunction, infos);
461461

462462
// set filtered tables for partitions with grouping
463463
std::apply([&groupingTable](auto&... x) {
@@ -485,7 +485,7 @@ struct AnalysisDataProcessorBuilder {
485485
// multiple arguments to process
486486
static_assert(((soa::is_soa_iterator_t<std::decay_t<Associated>>::value == false) && ...),
487487
"Associated arguments of process() should not be iterators");
488-
auto associatedTables = AnalysisDataProcessorBuilder::bindAssociatedTables(inputs, processingFunction, infos, processIndex);
488+
auto associatedTables = AnalysisDataProcessorBuilder::bindAssociatedTables<PI>(inputs, processingFunction, infos);
489489
auto binder = [&](auto&& x) {
490490
x.bindExternalIndices(&groupingTable, &std::get<std::decay_t<Associated>>(associatedTables)...);
491491
std::apply([&x](auto&... t) {

0 commit comments

Comments
 (0)