rename Data to QCInputs

Author: justonedev1

Framework/include/QualityControl/AggregatorInterface.h

@@ -49,7 +49,7 @@ class AggregatorInterface : public o2::quality_control::core::UserCodeInterface
   ///
   /// @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 std::map<std::string, core::Quality> aggregate(const core::QCInputs& data);
 
   virtual void startOfActivity(const core::Activity& activity);
   virtual void endOfActivity(const core::Activity& activity);

Framework/include/QualityControl/CheckInterface.h

@@ -57,7 +57,7 @@ class CheckInterface : public core::UserCodeInterface
   ///
   /// @param data An object with any type of data possible accesible via full names (i.e. <task_name>/<mo name> in case of MOs) as keys.
   /// @return The quality associated with these objects.
-  virtual core::Quality check(const core::Data& data);
+  virtual core::Quality check(const core::QCInputs& data);
 
   /// \brief Modify the aspect of the plot.
   ///

Framework/include/QualityControl/Data.h

@@ -33,10 +33,10 @@ template <typename Function, typename Result, typename... Args>
 concept invocable_r = std::invocable<Function, Args...> && std::same_as<std::invoke_result_t<Function, Args...>, Result>;
 
 template <typename ContainerMap>
-class DataGeneric
+class QCInputsGeneric
 {
  public:
-  DataGeneric() = default;
+  QCInputsGeneric() = default;
 
   template <typename Result>
   std::optional<std::reference_wrapper<const Result>> get(std::string_view key);
@@ -78,7 +78,7 @@ struct StringHash {
 
 using transparent_unordered_map = std::unordered_map<std::string, std::any, StringHash, std::equal_to<>>;
 
-using Data = DataGeneric<transparent_unordered_map>;
+using QCInputs = QCInputsGeneric<transparent_unordered_map>;
 
 } // namespace o2::quality_control::core
 

Framework/include/QualityControl/Data.inl

@@ -22,7 +22,7 @@ namespace o2::quality_control::core
 
 template <typename ContainerMap>
 template <typename Result>
-std::optional<std::reference_wrapper<const Result>> DataGeneric<ContainerMap>::get(std::string_view key)
+std::optional<std::reference_wrapper<const Result>> QCInputsGeneric<ContainerMap>::get(std::string_view key)
 {
   if (const auto foundIt = mObjects.find(key); foundIt != mObjects.end()) {
     if (auto* casted = std::any_cast<Result>(&foundIt->second); casted != nullptr) {
@@ -34,14 +34,14 @@ std::optional<std::reference_wrapper<const Result>> DataGeneric<ContainerMap>::g
 
 template <typename ContainerMap>
 template <typename T, typename... Args>
-void DataGeneric<ContainerMap>::emplace(std::string_view key, Args&&... args)
+void QCInputsGeneric<ContainerMap>::emplace(std::string_view key, Args&&... args)
 {
   mObjects.emplace(key, std::any{ std::in_place_type<T>, std::forward<Args>(args)... });
 }
 
 template <typename ContainerMap>
 template <typename T>
-void DataGeneric<ContainerMap>::insert(std::string_view key, const T& value)
+void QCInputsGeneric<ContainerMap>::insert(std::string_view key, const T& value)
 {
   mObjects.insert({ std::string{ key }, value });
 }
@@ -86,23 +86,23 @@ static constexpr auto pointer_to_reference = std::views::transform([](const auto
 
 template <typename ContainerMap>
 template <typename T>
-auto DataGeneric<ContainerMap>::iterateByType() const
+auto QCInputsGeneric<ContainerMap>::iterateByType() const
 {
   using namespace internal;
   return mObjects | any_to_specific<T> | filter_nullptr_in_pair | pair_to_reference;
 }
 
 template <typename ContainerMap>
 template <typename T, std::predicate<const std::pair<std::string_view, const T*>&> Pred>
-auto DataGeneric<ContainerMap>::iterateByTypeAndFilter(Pred&& filter) const
+auto QCInputsGeneric<ContainerMap>::iterateByTypeAndFilter(Pred&& filter) const
 {
   using namespace internal;
   return mObjects | any_to_specific<T> | filter_nullptr_in_pair | std::views::filter(filter) | pair_to_reference;
 }
 
 template <typename ContainerMap>
 template <typename StoredType, typename ResultingType, std::predicate<const std::pair<std::string_view, const StoredType*>&> Pred, invocable_r<const ResultingType*, const StoredType*> Transform>
-auto DataGeneric<ContainerMap>::iterateByTypeFilterAndTransform(Pred&& filter, Transform&& transform) const
+auto QCInputsGeneric<ContainerMap>::iterateByTypeFilterAndTransform(Pred&& filter, Transform&& transform) const
 {
   using namespace internal;
   return mObjects |
@@ -116,7 +116,7 @@ auto DataGeneric<ContainerMap>::iterateByTypeFilterAndTransform(Pred&& filter, T
 }
 
 template <typename ContainerMap>
-size_t DataGeneric<ContainerMap>::size() const noexcept
+size_t QCInputsGeneric<ContainerMap>::size() const noexcept
 {
   return mObjects.size();
 }

Framework/include/QualityControl/DataAdapters.h

@@ -24,22 +24,22 @@
 namespace o2::quality_control::core
 {
 
-Data createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
-Data createData(const QualityObjectsMapType& moMap);
+QCInputs createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
+QCInputs createData(const QualityObjectsMapType& moMap);
 
-inline auto iterateMonitorObjects(const Data& data);
-inline auto iterateMonitorObjects(const Data& data, std::string_view taskName);
+inline auto iterateMonitorObjects(const QCInputs& data);
+inline auto iterateMonitorObjects(const QCInputs& data, std::string_view taskName);
 
 template <typename StoredType = MonitorObject>
-std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const Data& data, std::string_view objectName, std::string_view taskName);
+std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const QCInputs& data, std::string_view objectName, std::string_view taskName);
 
 // returns first occurence of MO with given name (possible name clash)
 template <typename StoredType = MonitorObject>
-std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const Data& data, std::string_view objectName);
+std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const QCInputs& data, std::string_view objectName);
 
-inline auto iterateQualityObjects(const Data& data);
+inline auto iterateQualityObjects(const QCInputs& data);
 
-std::optional<std::reference_wrapper<const QualityObject>> getQualityObject(const Data& data, std::string_view checkName);
+std::optional<std::reference_wrapper<const QualityObject>> getQualityObject(const QCInputs& data, std::string_view checkName);
 
 } // namespace o2::quality_control::core
 

Framework/include/QualityControl/DataAdapters.inl

@@ -30,12 +30,12 @@
 namespace o2::quality_control::core
 {
 
-inline auto iterateMonitorObjects(const o2::quality_control::core::Data& data)
+inline auto iterateMonitorObjects(const o2::quality_control::core::QCInputs& data)
 {
   return data.iterateByType<o2::quality_control::core::MonitorObject>();
 }
 
-inline auto iterateMonitorObjects(const Data& data, std::string_view taskName)
+inline auto iterateMonitorObjects(const QCInputs& data, std::string_view taskName)
 {
   const auto filterMOByTaskName = [taskName](const auto& pair) {
     return pair.second->getTaskName() == taskName;
@@ -48,7 +48,7 @@ namespace helpers
 {
 
 template <typename StoredType, typename Filter>
-std::optional<std::reference_wrapper<const StoredType>> getMonitorObjectCommon(const Data& data, Filter&& filter)
+std::optional<std::reference_wrapper<const StoredType>> getMonitorObjectCommon(const QCInputs& data, Filter&& filter)
 {
   if constexpr (std::same_as<StoredType, MonitorObject>) {
     for (const auto& mo : data.iterateByTypeAndFilter<o2::quality_control::core::MonitorObject>(filter)) {
@@ -68,7 +68,7 @@ std::optional<std::reference_wrapper<const StoredType>> getMonitorObjectCommon(c
 } // namespace helpers
 
 template <typename StoredType>
-std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const Data& data, std::string_view objectName, std::string_view taskName)
+std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const QCInputs& data, std::string_view objectName, std::string_view taskName)
 {
   const auto filterMOByNameAndTaskName = [objectName, taskName](const auto& pair) {
     return std::tuple{ std::string_view{ pair.second->GetName() }, pair.second->getTaskName() } == std::tuple{ objectName, taskName };
@@ -78,7 +78,7 @@ std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const D
 }
 
 template <typename StoredType>
-std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const Data& data, std::string_view objectName)
+std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const QCInputs& data, std::string_view objectName)
 {
   const auto filterMOByName = [objectName](const auto& pair) {
     return std::string_view(pair.second->GetName()) == objectName;
@@ -87,7 +87,7 @@ std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const D
   return helpers::getMonitorObjectCommon<StoredType>(data, filterMOByName);
 }
 
-inline auto iterateQualityObjects(const Data& data)
+inline auto iterateQualityObjects(const QCInputs& data)
 {
   return data.iterateByType<o2::quality_control::core::QualityObject>();
 }

Framework/src/AggregatorInterface.cxx

@@ -29,7 +29,7 @@ std::map<std::string, core::Quality> AggregatorInterface::aggregate(std::map<std
   return aggregate(data);
 }
 
-std::map<std::string, core::Quality> AggregatorInterface::aggregate(const core::Data& data)
+std::map<std::string, core::Quality> AggregatorInterface::aggregate(const core::QCInputs& data)
 {
   return {};
 }

Framework/src/CheckInterface.cxx

@@ -32,7 +32,7 @@ core::Quality CheckInterface::check(std::map<std::string, std::shared_ptr<core::
   return check(data);
 };
 
-core::Quality CheckInterface::check(const core::Data& data)
+core::Quality CheckInterface::check(const core::QCInputs& data)
 {
   return core::Quality{};
 };

Framework/src/DataAdapters.cxx

@@ -19,25 +19,25 @@
 namespace o2::quality_control::core
 {
 
-Data createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap)
+QCInputs createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap)
 {
-  Data data;
+  QCInputs data;
   for (const auto& [key, mo] : moMap) {
     data.insert(key, mo);
   }
   return data;
 }
 
-Data createData(const QualityObjectsMapType& qoMap)
+QCInputs createData(const QualityObjectsMapType& qoMap)
 {
-  Data data;
+  QCInputs data;
   for (const auto& [key, qo] : qoMap) {
     data.insert(key, qo);
   }
   return data;
 }
 
-std::optional<std::reference_wrapper<const QualityObject>> getQualityObject(const Data& data, std::string_view objectName)
+std::optional<std::reference_wrapper<const QualityObject>> getQualityObject(const QCInputs& data, std::string_view objectName)
 {
   const auto filterQOByName = [objectName](const auto& pair) {
     return std::string_view(pair.second->GetName()) == objectName;

Framework/test/testData.cxx

@@ -32,12 +32,12 @@ struct nonexistent {
 
 TEST_CASE("Data - constructor", "[Data]")
 {
-  REQUIRE_NOTHROW([]() { Data data{}; });
+  REQUIRE_NOTHROW([]() { QCInputs data{}; });
 }
 
 TEST_CASE("Data insert and get", "[Data]")
 {
-  Data data;
+  QCInputs data;
   data.insert("test", 1);
   auto valueStr = data.get<std::string>("test");
   REQUIRE(!valueStr.has_value());
@@ -48,7 +48,7 @@ TEST_CASE("Data insert and get", "[Data]")
 
 TEST_CASE("Data - iterateByType", "[Data]")
 {
-  Data data;
+  QCInputs data;
   data.insert("testint1", 1);
   data.insert("teststr1", std::string{ "1" });
   REQUIRE(data.size() == 2);
@@ -72,7 +72,7 @@ TEST_CASE("Data - iterateByType", "[Data]")
 
 TEST_CASE("Data - iterateByTypeAndFilter", "[Data]")
 {
-  Data data;
+  QCInputs data;
   data.insert("1", 1);
   data.insert("2", 2);
   data.insert("str", "str");
@@ -95,7 +95,7 @@ TEST_CASE("Data - iterateByTypeFilterAndTransform", "[Data]")
   auto h2 = new TH1F("th12", "th12", 100, 0, 99);
   std::shared_ptr<MonitorObject> mo2 = std::make_shared<MonitorObject>(h2, "taskname", "class2", "TST");
 
-  Data data;
+  QCInputs data;
   data.insert("1", mo1);
   data.insert("2", mo2);
   data.insert("str", "str");
@@ -115,7 +115,7 @@ TEST_CASE("Data - iterateByTypeFilterAndTransform", "[Data]")
 
 TEST_CASE("Data - raw pointers", "[Data]")
 {
-  Data data;
+  QCInputs data;
   int a = 1;
   int b = 2;
   data.insert("1", &a);
@@ -141,7 +141,7 @@ TEMPLATE_TEST_CASE("Data - inserting fundamental types", "[.Data-benchmark]", st
 
   BENCHMARK("insert size_t")
   {
-    DataGeneric<TestType> data;
+    QCInputsGeneric<TestType> data;
     // for (size_t i = 0; i != iterations; ++i) {
     for (size_t i = iterations; i != 0; --i) {
       data.insert(std::to_string(i), i);
@@ -152,7 +152,7 @@ TEMPLATE_TEST_CASE("Data - inserting fundamental types", "[.Data-benchmark]", st
 TEMPLATE_TEST_CASE("Data - iterating fundamental types", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
 {
   constexpr size_t iterations = 20000;
-  DataGeneric<TestType> data;
+  QCInputsGeneric<TestType> data;
   for (size_t i = 0; i != iterations; ++i) {
     data.insert(std::to_string(i), i);
   }
@@ -174,7 +174,7 @@ TEMPLATE_TEST_CASE("Data - iterating fundamental types", "[.Data-benchmark]", st
 TEMPLATE_TEST_CASE("Data - get fundamental types", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
 {
   constexpr size_t iterations = 20000;
-  DataGeneric<TestType> data;
+  QCInputsGeneric<TestType> data;
   for (size_t i = 0; i != iterations; ++i) {
     data.insert(std::to_string(i), i);
   }
@@ -221,7 +221,7 @@ TEMPLATE_TEST_CASE("Data - inserting and iterating MOs", "[.Data-benchmark]", st
 
   BENCHMARK("insert - iterate MOs")
   {
-    DataGeneric<TestType> data;
+    QCInputsGeneric<TestType> data;
     for (const auto& mo : MOs) {
       data.insert(mo->getFullName(), mo);
     }
@@ -240,7 +240,7 @@ TEMPLATE_TEST_CASE("Data - inserting and iterating MOs", "[.Data-benchmark]", st
 TEST_CASE("Data adapters - helper functions", "[Data]")
 {
 
-  Data data;
+  QCInputs data;
   {
     for (size_t i{}; i != 10; ++i) {
       const auto iStr = std::to_string(i);