Data used in aggregators

Author: Michal Tichák

Framework/include/QualityControl/AggregatorInterface.h

@@ -23,6 +23,7 @@
 #include "QualityControl/UserCodeInterface.h"
 #include "QualityControl/Quality.h"
 #include "QualityControl/Activity.h"
+#include "QualityControl/Data.h"
 
 namespace o2::quality_control::checker
 {
@@ -42,7 +43,13 @@ class AggregatorInterface : public o2::quality_control::core::UserCodeInterface
   ///
   /// @param qoMap A map of the the QualityObjects to aggregate and their full names.
   /// @return The new qualities, associated with a name.
-  virtual std::map<std::string, core::Quality> aggregate(std::map<std::string, std::shared_ptr<const core::QualityObject>>& qoMap) = 0;
+  virtual std::map<std::string, core::Quality> aggregate(std::map<std::string, std::shared_ptr<const core::QualityObject>>& qoMap);
+
+  /// \brief Returns new qualities (usually fewer) based on the input qualities stored in Data structure
+  ///
+  /// @param data A generic data structure containing QualityObjects or possible other inputs.
+  /// @return The new qualities, associated with a name.
+  virtual std::map<std::string, core::Quality> aggregate(const core::Data& data);
 
   virtual void startOfActivity(const core::Activity& activity);
   virtual void endOfActivity(const core::Activity& activity);

Framework/include/QualityControl/Data.h

@@ -64,11 +64,21 @@ class Data
   template <typename T>
   static const T* any_cast_try_shared_ptr(const std::any& value)
   {
+    // sadly it is necessary to check for any of these types if we want to test for
+    // shared_ptr, raw ptr and a value
     if (auto* casted = std::any_cast<std::shared_ptr<T>>(&value); casted != nullptr) {
       return casted->get();
-    } else {
-      return std::any_cast<T>(&value);
     }
+    if (auto* casted = std::any_cast<std::shared_ptr<const T>>(&value); casted != nullptr) {
+      return casted->get();
+    }
+    if (auto* casted = std::any_cast<T*>(&value); casted != nullptr) {
+      return *casted;
+    }
+    if (auto* casted = std::any_cast<const T*>(&value); casted != nullptr) {
+      return *casted;
+    }
+    return std::any_cast<T>(&value);
   }
 
   template <typename T>

Framework/include/QualityControl/DataAdapters.h

@@ -19,11 +19,13 @@
 
 #include "Data.h"
 #include "QualityControl/MonitorObject.h"
+#include "QualityObject.h"
 
 namespace o2::quality_control::core
 {
 
 Data createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
+Data createData(const QualityObjectsMapType& moMap);
 
 template <typename Result>
 auto iterateMOsFilterByNameAndTransform(const Data& data, std::string_view moName)
@@ -33,6 +35,14 @@ auto iterateMOsFilterByNameAndTransform(const Data& data, std::string_view moNam
     [](const MonitorObject* ptr) -> const Result* { return dynamic_cast<const Result*>(ptr->getObject()); });
 }
 
+template <typename Result>
+auto iterateQOsFilterByNameAndTransform(const Data& data, std::string_view moName)
+{
+  return data.iterateByTypeFilterAndTransform<MonitorObject, Result>(
+    [name = std::string{ moName }](const std::pair<std::string_view, const MonitorObject*>& pair) -> bool { return std::string_view{ pair.second->GetName() } == name; },
+    [](const MonitorObject* ptr) -> const Result* { return dynamic_cast<const Result*>(ptr->getObject()); });
+}
+
 } // namespace o2::quality_control::core
 
 #endif

Framework/src/AggregatorInterface.cxx

@@ -15,13 +15,25 @@
 ///
 
 #include "QualityControl/AggregatorInterface.h"
+#include "QualityControl/DataAdapters.h"
 
 using namespace std;
 using namespace o2::quality_control::core;
 
 namespace o2::quality_control::checker
 {
 
+std::map<std::string, core::Quality> AggregatorInterface::aggregate(std::map<std::string, std::shared_ptr<const core::QualityObject>>& qoMap)
+{
+  auto data = createData(qoMap);
+  return aggregate(data);
+}
+
+std::map<std::string, core::Quality> AggregatorInterface::aggregate(const core::Data& data)
+{
+  return {};
+}
+
 void AggregatorInterface::startOfActivity(const Activity& activity)
 {
   // noop, override it if you want.

Framework/src/DataAdapters.cxx

@@ -28,4 +28,13 @@ Data createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moM
   return data;
 }
 
+Data createData(const QualityObjectsMapType& qoMap)
+{
+  Data data;
+  for (const auto& [key, qo] : qoMap) {
+    data.insert(key, qo);
+  }
+  return data;
+}
+
 } // namespace o2::quality_control::core

Framework/test/testData.cxx

@@ -118,7 +118,7 @@ TEST_CASE("Data - iterateByTypeFilterAndTransform", "[Data]")
   REQUIRE(count == 1);
 }
 
-TEST_CASE("Data - Monitor adaptors", "[Data]")
+TEST_CASE("Data - Monitor adaptors MOs", "[Data]")
 {
   auto* h1 = new TH1F("th11", "th11", 100, 0, 99);
   std::shared_ptr<MonitorObject> mo1 = std::make_shared<MonitorObject>(h1, "taskname", "class1", "TST");
@@ -135,12 +135,51 @@ TEST_CASE("Data - Monitor adaptors", "[Data]")
   REQUIRE(data.size() == 2);
 
   auto filteredHistos = iterateMOsFilterByNameAndTransform<TH1F>(data, "th11");
-  std::vector result(filteredHistos.begin(), filteredHistos.end());
-  // REQUIRE(!filteredHistos.empty());
+  REQUIRE(!filteredHistos.empty());
   size_t count{};
-  for (const auto& histo1d : result) {
+  for (const auto& histo1d : filteredHistos) {
     REQUIRE(std::string_view{ histo1d.GetName() } == "th11");
     ++count;
   }
   REQUIRE(count == 1);
 }
+
+TEST_CASE("Data - Monitor adaptors QOs", "[Data]")
+{
+  QualityObjectsMapType qoMap;
+  qoMap["1"] = std::make_shared<QualityObject>(Quality::Good, "1");
+  qoMap["2"] = std::make_shared<QualityObject>(Quality::Good, "2");
+
+  auto data = createData(qoMap);
+
+  REQUIRE(data.size() == 2);
+
+  auto filteredObjects = data.iterateByType<QualityObject>();
+  REQUIRE(!filteredObjects.empty());
+  size_t count{};
+  for (const auto& qo : filteredObjects) {
+    const auto& name = qo.getName();
+    REQUIRE((name == "1" || name == "2"));
+    ++count;
+  }
+  REQUIRE(count == 2);
+}
+
+TEST_CASE("Data - raw pointers", "[Data]")
+{
+  Data data;
+  int a = 1;
+  int b = 2;
+  data.insert("1", &a);
+  data.insert("2", &b);
+
+  auto ints = data.iterateByType<int>();
+  REQUIRE(!ints.empty());
+
+  size_t count{};
+  for (const auto& v : ints) {
+    REQUIRE((v == 1 || v == 2));
+    ++count;
+  }
+  REQUIRE(count == 2);
+}

Modules/Skeleton/include/Skeleton/SkeletonAggregator.h

@@ -21,6 +21,7 @@
 #include <Rtypes.h>
 // QC
 #include "QualityControl/AggregatorInterface.h"
+#include "QualityControl/Data.h"
 
 namespace o2::quality_control_modules::skeleton
 {
@@ -32,11 +33,11 @@ class SkeletonAggregator : public o2::quality_control::checker::AggregatorInterf
  public:
   // Override interface
   void configure() override;
-  std::map<std::string, o2::quality_control::core::Quality> aggregate(o2::quality_control::core::QualityObjectsMapType& qoMap) override;
+  std::map<std::string, o2::quality_control::core::Quality> aggregate(const o2::quality_control::core::Data& data) override;
 
   ClassDefOverride(SkeletonAggregator, 1);
 };
 
 } // namespace o2::quality_control_modules::skeleton
 
-#endif //QUALITYCONTROL_SKELETONAGGREGATOR_H
+#endif // QUALITYCONTROL_SKELETONAGGREGATOR_H

Modules/Skeleton/src/SkeletonAggregator.cxx

@@ -32,22 +32,20 @@ void SkeletonAggregator::configure()
   std::string parameter = mCustomParameters.atOrDefaultValue("myOwnKey", "fallback value");
 }
 
-std::map<std::string, Quality> SkeletonAggregator::aggregate(QualityObjectsMapType& qoMap)
+std::map<std::string, Quality> SkeletonAggregator::aggregate(const o2::quality_control::core::Data& data)
 {
   // THUS FUNCTION BODY IS AN EXAMPLE. PLEASE REMOVE EVERYTHING YOU DO NOT NEED.
   std::map<std::string, Quality> result;
 
   ILOG(Info, Devel) << "Entered SkeletonAggregator::aggregate" << ENDM;
-  ILOG(Info, Devel) << "   received a list of size : " << qoMap.size() << ENDM;
-  for (const auto& item : qoMap) {
-    ILOG(Info, Devel) << "Object: " << (*item.second) << ENDM;
-  }
+  ILOG(Info, Devel) << "   received a data of size : " << data.size() << ENDM;
 
   // we return the worse quality of all the objects we receive
   Quality current = Quality::Good;
-  for (const auto& qo : qoMap) {
-    if (qo.second->getQuality().isWorseThan(current)) {
-      current = qo.second->getQuality();
+  for (const auto& qo : data.iterateByType<QualityObject>()) {
+    ILOG(Info, Devel) << "Object: " << qo << ENDM;
+    if (qo.getQuality().isWorseThan(current)) {
+      current = qo.getQuality();
     }
   }