DPL Analysis: replace SFINAE with overloaded restricted templates

Author: aalkin

Framework/Core/include/Framework/AnalysisHelpers.h

@@ -190,6 +190,9 @@ template <is_producable T>
 struct Produces : WritingCursor<T> {
 };
 
+template <typename T>
+concept is_produces = requires (T t) { typename T::cursor_t; typename T::persistent_table_t; &T::cursor; };
+
 /// Use this to group together produces. Useful to separate them logically
 /// or simply to stay within the 100 elements per Task limit.
 /// Use as:
@@ -201,6 +204,9 @@ struct Produces : WritingCursor<T> {
 struct ProducesGroup {
 };
 
+template <typename T>
+concept is_produces_group = std::derived_from<T, ProducesGroup>;
+
 /// Helper template for table transformations
 template <soa::is_metadata M, soa::TableRef Ref>
 struct TableTransform {
@@ -250,6 +256,7 @@ constexpr auto transformBase()
 
 template <is_spawnable T>
 struct Spawns : decltype(transformBase<T>()) {
+  using spawnable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
   using extension_t = typename metadata::extension_table_t;
   using base_table_t = typename metadata::base_table_t;
@@ -277,6 +284,12 @@ struct Spawns : decltype(transformBase<T>()) {
   std::shared_ptr<extension_t> extension = nullptr;
 };
 
+template <typename T>
+concept is_spawns = requires(T t) {
+  typename T::metadata;
+  std::same_as<decltype(t.pack()), typename T::expression_pack_t>;
+};
+
 /// Policy to control index building
 /// Exclusive index: each entry in a row has a valid index
 /// Sparse index: values in a row can be (-1), index table is isomorphic (joinable)
@@ -420,6 +433,7 @@ constexpr auto transformBase()
 
 template <soa::is_index_table T>
 struct Builds : decltype(transformBase<T>()) {
+  using buildable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
   using IP = std::conditional_t<metadata::exclusive, IndexBuilder<Exclusive>, IndexBuilder<Sparse>>;
   using Key = metadata::Key;
@@ -455,6 +469,13 @@ struct Builds : decltype(transformBase<T>()) {
   }
 };
 
+template <typename T>
+concept is_builds = requires(T t) {
+  typename T::metadata;
+  typename T::Key;
+  std::same_as<decltype(t.pack()), typename T::index_pack_t>;
+};
+
 /// This helper class allows you to declare things which will be created by a
 /// given analysis task. Currently wrapped objects are limited to be TNamed
 /// descendants. Objects will be written to a ROOT file at the end of the
@@ -550,11 +571,15 @@ struct OutputObj {
   uint32_t mTaskHash;
 };
 
+template <typename T>
+concept is_outputobj = requires (T t) { &T::setObject; std::same_as<decltype(t.object), std::shared_ptr<typename T::obj_t>>; };
+
 /// This helper allows you to fetch a Sevice from the context or
 /// by using some singleton. This hopefully will hide the Singleton and
 /// We will be able to retrieve it in a more thread safe manner later on.
 template <typename T>
 struct Service {
+  using service_t = T;
   T* service;
 
   decltype(auto) operator->() const
@@ -567,6 +592,9 @@ struct Service {
   }
 };
 
+template <typename T>
+concept is_service = requires (T t) { std::same_as<decltype(t.service), typename T::service_t*>; &T::operator->;};
+
 auto getTableFromFilter(soa::is_filtered_table auto const& table, soa::SelectionVector&& selection)
 {
   return std::make_unique<o2::soa::Filtered<std::decay_t<decltype(table)>>>(std::vector{table}, std::forward<soa::SelectionVector>(selection));
@@ -581,6 +609,7 @@ void initializePartitionCaches(std::set<uint32_t> const& hashes, std::shared_ptr
 
 template <typename T>
 struct Partition {
+  using content_t = T;
   Partition(expressions::Node&& filter_) : filter{std::forward<expressions::Node>(filter_)}
   {
   }
@@ -690,6 +719,9 @@ struct Partition {
     return mFiltered->size();
   }
 };
+
+template <typename T>
+concept is_partition = requires (T t) {&T::updatePlaceholders; std::same_as<decltype(t.filter), expressions::Filter>; std::same_as<decltype(t.mFiltered), std::unique_ptr<o2::soa::Filtered<typename T::content_t>>>;};
 }  // namespace o2::framework
 
 namespace o2::soa