do not use external matchers in GroupSlicer

Author: aalkin

Framework/Core/include/Framework/AnalysisTask.h

@@ -371,7 +371,7 @@ struct AnalysisDataProcessorBuilder {
                                                 task);
       overwriteInternalIndices(associatedTables, associatedTables);
       if constexpr (soa::is_iterator<G>) {
-        auto slicer = GroupSlicer(groupingTable, associatedTables, slices, matchers, newOrigin);
+        auto slicer = GroupSlicer(groupingTable, associatedTables, slices, newOrigin);
         for (auto& slice : slicer) {
           auto associatedSlices = slice.associatedTables();
           overwriteInternalIndices(associatedSlices, associatedTables);

Framework/Core/include/Framework/GroupSlicer.h

@@ -35,12 +35,12 @@ auto getMatcherFor(std::string const& columnName, o2::header::DataOrigin newOrig
 
 namespace o2::framework
 {
-template <typename G, std::ranges::input_range R, typename... A>
+template <typename G, typename... A>
 struct GroupSlicer {
   using grouping_t = std::decay_t<G>;
-  GroupSlicer(G& gt, std::tuple<A...>& at, ArrowTableSlicingCache& slices, R matchers, header::DataOrigin newOrigin = header::DataOrigin{"AOD"})
+  GroupSlicer(G& gt, std::tuple<A...>& at, ArrowTableSlicingCache& slices, header::DataOrigin newOrigin = header::DataOrigin{"AOD"})
     : max{gt.size()},
-      mBegin{GroupSlicerIterator(gt, at, slices, matchers, newOrigin)}
+      mBegin{GroupSlicerIterator(gt, at, slices, newOrigin)}
   {
   }
 
@@ -95,15 +95,14 @@ struct GroupSlicer {
       starts[index] = selections[index]->begin();
     }
 
-    GroupSlicerIterator(G& gt, std::tuple<A...>& at, ArrowTableSlicingCache& slices, R matchers_, header::DataOrigin newOrigin = header::DataOrigin{"AOD"})
+    GroupSlicerIterator(G& gt, std::tuple<A...>& at, ArrowTableSlicingCache& slices, header::DataOrigin newOrigin = header::DataOrigin{"AOD"})
       : mIndexColumnName{std::string("fIndex") + o2::framework::cutString(o2::soa::getLabelFromType<G>())},
         mGt{&gt},
         mAt{&at},
         mGroupingElement{gt.begin()},
         position{0},
         mSlices{&slices},
-        replacementOrigin{newOrigin},
-        matchers{matchers_}
+        replacementOrigin{newOrigin}
     {
       if constexpr (soa::is_filtered_table<std::decay_t<G>>) {
         groupSelection = mGt->getSelectedRows();
@@ -281,7 +280,6 @@ struct GroupSlicer {
     std::array<SliceInfoUnsortedPtr, sizeof...(A)> sliceInfosUnsorted;
     ArrowTableSlicingCache* mSlices;
     header::DataOrigin replacementOrigin;
-    R matchers;
   };
 
   GroupSlicerIterator& begin()

Framework/Core/test/test_GroupSlicer.cxx

@@ -121,7 +121,7 @@ TEST_CASE("GroupSlicerOneAssociated")
   std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
   ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
-  o2::framework::GroupSlicer g(e, tt, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, tt, slices);
 
   auto count = 0;
   for (auto& slice : g) {
@@ -199,7 +199,7 @@ TEST_CASE("GroupSlicerSeveralAssociated")
   auto s = slices.updateCacheEntry(0, {trkTableX});
   s = slices.updateCacheEntry(1, {trkTableY});
   s = slices.updateCacheEntry(2, {trkTableZ});
-  o2::framework::GroupSlicer g(e, tt, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, tt, slices);
 
   auto count = 0;
   for (auto& slice : g) {
@@ -261,7 +261,7 @@ TEST_CASE("GroupSlicerMismatchedGroups")
   std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
   ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
-  o2::framework::GroupSlicer g(e, tt, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, tt, slices);
 
   for (auto& slice : g) {
     auto as = slice.associatedTables();
@@ -318,7 +318,7 @@ TEST_CASE("GroupSlicerMismatchedUnassignedGroups")
   std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
   ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
-  o2::framework::GroupSlicer g(e, tt, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, tt, slices);
 
   auto count = 0;
   for (auto& slice : g) {
@@ -369,7 +369,7 @@ TEST_CASE("GroupSlicerMismatchedFilteredGroups")
   std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
   ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
-  o2::framework::GroupSlicer g(e, tt, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, tt, slices);
 
   auto count = 0;
 
@@ -431,7 +431,7 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroups")
   std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
   ArrowTableSlicingCache slices({}, {{soa::getLabelFromType<aod::TrksXU>(), soa::getMatcherFromTypeForKey<aod::TrksXU>(key), key}});
   auto s = slices.updateCacheEntryUnsorted(0, trkTable);
-  o2::framework::GroupSlicer g(e, tt, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, tt, slices);
 
   unsigned int count = 0;
 
@@ -454,7 +454,7 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroups")
   std::vector<int64_t> sele;
   soa::SmallGroups<aod::TrksXU> te{{trkTableE}, std::move(sele)};
   auto tte = std::make_tuple(te);
-  o2::framework::GroupSlicer ge(e, tte, slices, Matchers{});
+  o2::framework::GroupSlicer ge(e, tte, slices);
 
   count = 0;
   for (auto& slice : ge) {
@@ -468,7 +468,7 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroups")
 
   soa::SmallGroupsUnfiltered<aod::TrksXU> tu{{trkTable}, std::vector<int64_t>{}};
   auto ttu = std::make_tuple(tu);
-  o2::framework::GroupSlicer gu(e, ttu, slices, Matchers{});
+  o2::framework::GroupSlicer gu(e, ttu, slices);
 
   count = 0;
   for (auto& slice : gu) {
@@ -558,7 +558,7 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
                                  {soa::getLabelFromType<aod::Things>(), soa::getMatcherFromTypeForKey<aod::Things>(key), key}});
   auto s0 = slices.updateCacheEntry(0, partsTable);
   auto s1 = slices.updateCacheEntry(1, thingsTable);
-  o2::framework::GroupSlicer g(e, associatedTuple, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, associatedTuple, slices);
 
   overwriteInternalIndices(associatedTuple, associatedTuple);
 
@@ -617,7 +617,7 @@ TEST_CASE("EmptySliceables")
   std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
   ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
-  o2::framework::GroupSlicer g(e, tt, slices, Matchers{});
+  o2::framework::GroupSlicer g(e, tt, slices);
 
   unsigned int count = 0;
   for (auto& slice : g) {