move concepts out of AnalysisHelpers.h

Author: aalkin

Framework/Core/include/Framework/AnalysisHelpers.h

@@ -492,12 +492,6 @@ class TableConsumer;
 /// Helper class actually implementing the cursor which can write to
 /// a table. The provided template arguments are if type Column and
 /// therefore refer only to the persisted columns.
-template <typename T>
-concept is_producable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> || soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::parent_t::ref.desc_hash>>>;
-
-template <typename T>
-concept is_enumerated_iterator = requires(T t) { t.globalIndex(); };
-
 template <is_producable T>
 struct WritingCursor {
  public:
@@ -579,13 +573,13 @@ struct WritingCursor {
   decltype(FFL(std::declval<cursor_t>())) cursor;
 
  private:
-  static decltype(auto) extract(is_enumerated_iterator auto const& arg)
+  static decltype(auto) extract(soa::is_enumerated_iterator auto const& arg)
   {
     return arg.globalIndex();
   }
 
   template <typename A>
-    requires(!is_enumerated_iterator<A>)
+    requires(!soa::is_enumerated_iterator<A>)
   static decltype(auto) extract(A&& arg)
   {
     return arg;
@@ -642,9 +636,6 @@ 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:
@@ -654,11 +645,10 @@ concept is_produces = requires(T t) { typename T::cursor_t; typename T::persiste
 ///
 /// Notice the label MySetOfProduces is just a mnemonic and can be omitted.
 struct ProducesGroup {
+  static constexpr void isProducesGroup()
+  {};
 };
 
-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 {
@@ -682,12 +672,6 @@ struct TableTransform {
 
 /// This helper struct allows you to declare extended tables which should be
 /// created by the task (as opposed to those pre-defined by data model)
-template <typename T>
-concept is_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
-
-template <typename T>
-concept is_dynamically_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_configurable_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
-
 template <is_spawnable T>
 consteval auto transformBase()
 {
@@ -736,13 +720,6 @@ struct Spawns : decltype(transformBase<T>()) {
   }();
 };
 
-template <typename T>
-concept is_spawns = requires(T t) {
-  typename T::metadata;
-  typename T::expression_pack_t;
-  requires std::same_as<decltype(t.projector), std::shared_ptr<gandiva::Projector>>;
-};
-
 /// This helper struct allows you to declare extended tables with dynamically-supplied
 /// expressions to be created by the task
 /// The actual expressions have to be set in init() for the configurable expression
@@ -792,15 +769,6 @@ struct Defines : decltype(transformBase<T>()) {
 template <is_dynamically_spawnable T>
 using DefinesDelayed = Defines<T, true>;
 
-template <typename T>
-concept is_defines = requires(T t) {
-  typename T::metadata;
-  typename T::placeholders_pack_t;
-  requires std::same_as<decltype(t.projector), std::shared_ptr<gandiva::Projector>>;
-  requires std::same_as<decltype(t.needRecompilation), bool>;
-  &T::recompile;
-};
-
 /// 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) to T1
@@ -859,13 +827,6 @@ struct Builds : decltype(transformBase<T>()) {
   }
 };
 
-template <typename T>
-concept is_builds = requires(T t) {
-  typename T::metadata;
-  typename T::Key;
-  requires std::same_as<decltype(t.map), std::vector<soa::IndexRecord>>;
-};
-
 /// a task with rewritten origin, if running together with a task with the default, will
 /// have a different name and thus its output would be routed separately
 
@@ -877,6 +838,7 @@ concept is_builds = requires(T t) {
 /// to determine the target file, e.g. analysis result, QA or control histogram,
 /// etc.
 template <typename T>
+  requires(std::derived_from<T, TNamed>)
 struct OutputObj {
   using obj_t = T;
 
@@ -964,15 +926,6 @@ struct OutputObj {
   uint32_t mTaskHash;
 };
 
-template <typename T>
-concept is_outputobj = requires(T t) {
-  &T::setHash;
-  &T::spec;
-  &T::ref;
-  requires std::same_as<decltype(t.operator->()), typename T::obj_t*>;
-  requires 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.
@@ -991,12 +944,6 @@ struct Service {
   }
 };
 
-template <typename T>
-concept is_service = requires(T t) {
-  requires 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));
@@ -1016,7 +963,7 @@ void initializePartitionCaches(std::set<uint32_t> const& hashes, std::shared_ptr
 ///        the real reason is to provide grouped parts for the process functions that request it
 ///        better solution would be to "slice" the selection, as is already done in GroupSlicer
 ///        for the same purpose, instead of reapplying the filtering
-template <typename T>
+template <soa::is_table T>
 struct Partition {
   using content_t = T;
   Partition(expressions::Node&& filter_) : filter{std::forward<expressions::Node>(filter_)}
@@ -1128,13 +1075,6 @@ struct Partition {
     return mFiltered->size();
   }
 };
-
-template <typename T>
-concept is_partition = requires(T t) {
-  &T::updatePlaceholders;
-  requires std::same_as<decltype(t.filter), expressions::Filter>;
-  requires std::same_as<decltype(t.mFiltered), std::unique_ptr<o2::soa::Filtered<typename T::content_t>>>;
-};
 } // namespace o2::framework
 
 namespace o2::soa

Framework/Core/include/Framework/Concepts.h

@@ -164,6 +164,10 @@ concept is_not_filtered_table = is_table<T> && !is_filtered_table<T>;
 template <typename T>
 concept is_join = requires(T t) { t.isJoin(); };
 
+/// 17. require an enumerated iterator
+template <typename T>
+concept is_enumerated_iterator = requires(T t) { t.globalIndex(); };
+
 /// misc
 /// 1. require a type with originals container
 template <typename T>
@@ -227,9 +231,84 @@ concept is_preslice_policy = requires(T t) { t.isPreslicePolicy(); };
 template <typename T>
 concept is_preslice = requires(T t) { t.isPresliceContainer(); };
 
-/// 3. reqiures a preslice group
+/// 3. reqiure a preslice group
 template <typename T>
 concept is_preslice_group = requires(T t) { t.isPresliceGroup(); };
+
+/// 4. require a producable entity
+template <typename T>
+concept is_producable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> || soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::parent_t::ref.desc_hash>>>;
+
+/// 5. require produces declaration
+template <typename T>
+concept is_produces = requires(T t) { typename T::cursor_t; typename T::persistent_table_t; &T::cursor; };
+
+/// 6. require produces group
+template <typename T>
+concept is_produces_group = requires(T t) { t.isProducesGroup(); };
+
+/// 7. require spawnable entity
+template <typename T>
+concept is_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
+
+/// 8. require dynamically spawnable entity
+template <typename T>
+concept is_dynamically_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_configurable_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
+
+/// 9. require spawns declaration
+template <typename T>
+concept is_spawns = requires(T t) {
+  typename T::metadata;
+  typename T::expression_pack_t;
+  t.projector.get();
+};
+
+/// 10. require defines declaration
+template <typename T>
+concept is_defines = requires(T t) {
+  typename T::metadata;
+  typename T::placeholders_pack_t;
+  t.projector.get();
+  requires std::same_as<decltype(t.needRecompilation), bool>;
+  t.recompile();
+};
+
+/// 11. require builds declaration
+template <typename T>
+concept is_builds = requires(T t) {
+  typename T::metadata;
+  typename T::Key;
+  t.map.size();
+};
+
+/// 12. require outputobj declaration
+template <typename T>
+concept is_outputobj = requires(T t) {
+  &T::setHash;
+  &T::spec;
+  &T::ref;
+  requires std::same_as<decltype(t.operator->()), typename T::obj_t*>;
+  requires std::same_as<decltype(t.object.get()), typename T::obj_t*>;
+};
+
+/// 13. require service declaration
+template <typename T>
+concept is_service = requires(T t) {
+  requires std::same_as<decltype(t.service), typename T::service_t*>;
+  &T::operator->;
+};
+
+/// 14. require partition declaration
+template <typename T>
+concept is_partition = requires(T t) {
+  &T::updatePlaceholders;
+  t.mFiltered.get();
+  &T::operator->;
+  requires std::same_as<decltype(t.dataframeChanged), bool>;
+  t.begin();
+  t.end();
+  t.size();
+};
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_CONCEPTS_H