DPL Analysis: initial support for Condition configurable

Author: ktf

Framework/Core/include/Framework/AnalysisManagers.h

@@ -18,9 +18,11 @@
 #include "Framework/ProcessingContext.h"
 #include "Framework/EndOfStreamContext.h"
 #include "Framework/HistogramRegistry.h"
+#include "Framework/CCDBParamSpec.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/ConfigurableHelpers.h"
+#include "Framework/Condition.h"
 #include "Framework/InitContext.h"
 #include "Framework/ConfigContext.h"
 #include "Framework/RootConfigParamHelpers.h"
@@ -155,6 +157,46 @@ struct FilterManager<expressions::Filter> {
   }
 };
 
+/// A manager which takes care of condition objects
+template <typename T>
+struct ConditionManager {
+  template <typename ANY>
+  static bool appendCondition(std::vector<InputSpec>& inputs, ANY& x)
+  {
+    if constexpr (std::is_base_of_v<ConditionGroup, ANY>) {
+      homogeneous_apply_refs<true>([&inputs](auto& y) { return ConditionManager<std::decay_t<decltype(y)>>::appendCondition(inputs, y); }, x);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  template <typename ANY>
+  static bool newDataframe(InputRecord& record, ANY& x)
+  {
+    if constexpr (std::is_base_of_v<ConfigurableGroup, ANY>) {
+      homogeneous_apply_refs<true>([&record](auto&& y) { return ConditionManager<std::decay_t<decltype(y)>>::newDataframe(record, y); }, x);
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
+template <typename OBJ>
+struct ConditionManager<Condition<OBJ>> {
+  static bool appendCondition(std::vector<InputSpec>& inputs, Condition<OBJ>& what)
+  {
+    inputs.emplace_back(InputSpec{what.path, "AODC", compile_time_hash(what.path.c_str()), Lifetime::Condition, ccdbParamSpec(what.path)});
+    return true;
+  }
+  static bool newDataframe(InputRecord& inputs, Condition<OBJ>& what)
+  {
+    what.instance(inputs.get<OBJ>(what.path));
+    return true;
+  }
+};
+
 /// SFINAE placeholder
 template <typename T>
 struct OutputManager {

Framework/Core/include/Framework/AnalysisTask.h

@@ -16,6 +16,7 @@
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/CallbackService.h"
 #include "Framework/ConfigContext.h"
+#include "Framework/Condition.h"
 #include "Framework/ControlService.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Expressions.h"
@@ -530,6 +531,8 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
 
   /// make sure options and configurables are set before expression infos are created
   homogeneous_apply_refs([&options, &hash](auto& x) { return OptionManager<std::decay_t<decltype(x)>>::appendOption(options, x); }, *task.get());
+  /// extract conditions and append them as inputs
+  homogeneous_apply_refs([&inputs](auto& x) { return ConditionManager<std::decay_t<decltype(x)>>::appendCondition(inputs, x); }, *task.get());
 
   /// parse process functions defined by corresponding configurables
   if constexpr (has_process_v<T>) {
@@ -605,6 +608,8 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
     }
 
     return [task, expressionInfos](ProcessingContext& pc) mutable {
+      // load the ccdb object from their cache
+      homogeneous_apply_refs([&pc](auto&& x) { return ConditionManager<std::decay_t<decltype(x)>>::newDataframe(pc.inputs(), x); }, *task.get());
       // reset partitions once per dataframe
       homogeneous_apply_refs([](auto&& x) { return PartitionManager<std::decay_t<decltype(x)>>::newDataframe(x); }, *task.get());
       // reset selections for the next dataframe

Framework/Core/include/Framework/Condition.h

@@ -0,0 +1,57 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_CONDITION_H_
+#define O2_FRAMEWORK_CONDITION_H_
+#include <string>
+
+namespace o2::framework
+{
+
+template <typename T>
+struct Condition {
+  std::string path;
+  T* instance;
+  using type = T;
+
+  Condition(std::string path)
+    : path(std::move(path))
+  {
+  }
+
+  operator T()
+  {
+    return *this->value;
+  }
+
+  T const* operator->() const
+  {
+    return this->value;
+  }
+};
+
+/// Can be used to group together a number of Configurables
+/// to overcome the limit of 100 Configurables per task.
+/// In order to do so you can do:
+///
+/// struct MyTask {
+///   struct : ConditionGroup {
+///     Condition<SomeConditionObject> someCondition{...};
+///   } group;
+/// };
+///
+/// and access it with
+///
+/// group.aCut;
+struct ConditionGroup {
+};
+
+} // namespace o2::framework
+#endif // O2_FRAMEWORK_CONDITION_H_

Framework/Core/test/test_AnalysisTask.cxx

@@ -129,12 +129,19 @@ struct JTask {
   }
 };
 
+struct TestCCDBObject {
+  int SomeObject;
+};
+
 struct KTask {
   struct : public ConfigurableGroup {
     Configurable<int> anInt{"someConfigurable", {}, "Some Configurable Object"};
     Configurable<int> anotherInt{"someOtherConfigurable", {}, "Some Configurable Object"};
   } foo;
   Configurable<int> anThirdInt{"someThirdConfigurable", {}, "Some Configurable Object"};
+  struct : public ConditionGroup {
+    Condition<TestCCDBObject> test{"path"};
+  } conditions;
   std::unique_ptr<int> someInt;
   std::shared_ptr<int> someSharedInt;
 };
@@ -192,9 +199,11 @@ BOOST_AUTO_TEST_CASE(AdaptorCompilation)
   BOOST_CHECK_EQUAL(task9.inputs.size(), 4);
 
   auto task10 = adaptAnalysisTask<JTask>(*cfgc, TaskName{"test10"});
+  BOOST_CHECK_EQUAL(task10.inputs.size(), 1);
 
   auto task11 = adaptAnalysisTask<KTask>(*cfgc, TaskName{"test11"});
   BOOST_CHECK_EQUAL(task11.options.size(), 3);
+  BOOST_CHECK_EQUAL(task11.inputs.size(), 1);
 }
 
 BOOST_AUTO_TEST_CASE(TestPartitionIteration)