reworded docs and removed generic container from QCInputs

Author: Michal Tichák

Framework/include/QualityControl/CheckInterface.h

@@ -48,6 +48,8 @@ class CheckInterface : public core::UserCodeInterface
   virtual ~CheckInterface() = default;
 
   /// \brief Returns the quality associated with these objects.
+  /// \deprecated This function won't be deleted in future releases for compatibility reasons but users should
+  ///             use check(const Data&) for any new Checks.
   ///
   /// @param moMap A map of the the MonitorObjects to check and their full names (i.e. <task_name>/<mo name>) as keys.
   /// @return The quality associated with these objects.

Framework/include/QualityControl/QCInputs.h

@@ -17,11 +17,13 @@
 /// \par Example
 /// \code{.cpp}
 /// QCInputs data;
-/// data.insert("count", 42u);
-/// if (auto opt = data.get<unsigned>("count")) {
-///   std::cout << "Count: " << opt->get() << std::endl;
+/// auto* h1 = new TH1F("th11", "th11", 100, 0, 99);
+/// data.insert("mo", std::make_shared<MonitorObject>(h1, "taskname", "class1", "TST"));
+/// if (auto opt = data.get<MonitorObject>("mo")) {
+///   MonitorObject& moObject = opt.value();
+///   std::cout << "mo name: " << moObject.getName() << std::endl;
 /// }
-/// for (const auto& v : data.iterateByType<unsigned>()) {
+/// for (const auto& mo : data.iterateByType<MonitorObject>()) {
 ///   // process each value
 /// }
 /// \endcode
@@ -52,22 +54,20 @@ concept invocable_r = std::invocable<Function, Args...> &&
 
 /// \brief Heterogeneous storage for named QC input objects.
 ///
-/// Stores values in an std::any-based container keyed by strings,
+/// Stores values in an std::unordered_map<std::string, std::any> while
 /// offering type-safe get, iteration, filtering, and transformation.
-/// Example of such container is transparent_unordered_map at the end of this file
-template <typename ContainerMap>
-class QCInputsGeneric
+class QCInputs
 {
  public:
-  QCInputsGeneric() = default;
+  QCInputs() = default;
 
   /// \brief Retrieve the object stored under the given key with matching type.
   /// \tparam Result Expected stored type.
   /// \param key Identifier for the stored object.
   /// \returns Optional reference to const Result if found desired item of type Result.
   /// \par Example
   /// \code{.cpp}
-  /// if (auto opt = data.get<unsigned>("count")) {
+  /// if (auto opt = data.get<MonitorObject>("mo")) {
   ///   if (opt.has_value()){
   ///     const unsigned& value = opt.value(); // careful about using auto here as we want to invoke implicit conversion operator of reference_wrapper
   ///   }
@@ -82,7 +82,8 @@ class QCInputsGeneric
   /// \param args Arguments forwarded to T's constructor.
   /// \par Example
   /// \code{.cpp}
-  /// data.emplace<std::string>("greeting", "hello");
+  /// auto* h1 = new TH1F("th11", "th11", 100, 0, 99);
+  /// data.emplace<MonitorObject>("mo", h1, "taskname", "class1", "TST");
   /// \endcode
   template <typename T, typename... Args>
   void emplace(std::string_view key, Args&&... args);
@@ -93,7 +94,8 @@ class QCInputsGeneric
   /// \param value Const reference to the value to insert.
   /// \par Example
   /// \code{.cpp}
-  /// data.insert("count", 10u);
+  /// auto* h1 = new TH1F("th11", "th11", 100, 0, 99);
+  /// data.insert("mo", std::make_shared<MonitorObject>(h1, "taskname", "class1", "TST"));
   /// \endcode
   template <typename T>
   void insert(std::string_view key, const T& value);
@@ -103,7 +105,7 @@ class QCInputsGeneric
   /// \returns Range of const references to stored Result instances.
   /// \par Example
   /// \code{.cpp}
-  /// for (auto& val : data.iterateByResultype<unsigned>()) {
+  /// for (auto& mo : data.iterateByType<MonitorObject>()) {
   ///   // use val
   /// }
   /// \endcode
@@ -117,9 +119,9 @@ class QCInputsGeneric
   /// \returns Range of const references to Result passing the filter.
   /// \par Example
   /// \code{.cpp}
-  /// auto even = [](auto const& pair) { return pair.second % 2 == 0; };
-  /// for (auto& val : data.iterateByTypeAndFilter<unsigned>(even)) {
-  ///   // use val
+  /// auto nameFilter = [](auto const& pair) { return pair.second->getName() == "name"; };
+  /// for (auto& mo : data.iterateByTypeAndFilter<MonitorObject>(nameFilter)) {
+  ///   // use mo
   /// }
   /// \endcode
   template <typename Result, std::predicate<const std::pair<std::string_view, const Result*>&> Pred>
@@ -138,8 +140,9 @@ class QCInputsGeneric
   /// \par Example
   /// \code{.cpp}
   /// // if we stored some MOs that are not TH1F, these will be filtered out of results
-  /// auto toHistogram = [](auto const& p) { return dynamic_cast<TH1F*>(p.second->getObject()); };
-  /// for (auto& h : data.iterateByTypeFilterAndTransform<MonitorObject, TH1F>([](auto const& p){ return p.first=="histo"; }, toHistogram)) {
+  /// auto toHistogram = [](auto const& p) -> const auto* { return dynamic_cast<TH1F*>(p.second->getObject()); };
+  /// auto nameFilter = [](auto const& p){ return p.first == "histo"; };
+  /// for (auto& h : data.iterateByTypeFilterAndTransform<MonitorObject, TH1F>(nameFilter, toHistogram)) {
   ///   // use histogram h
   /// }
   /// \endcode
@@ -155,33 +158,26 @@ class QCInputsGeneric
   size_t size() const noexcept;
 
  private:
-  ContainerMap mObjects;
-};
-
-/// \brief Transparent hash functor for string and string_view.
-///
-/// Enables heterogeneous lookup in unordered maps keyed by std::string.
-struct StringHash {
-  using is_transparent = void; // Required for heterogeneous lookup
-
-  std::size_t operator()(const std::string& str) const
-  {
-    return std::hash<std::string>{}(str);
-  }
-
-  std::size_t operator()(std::string_view sv) const
-  {
-    return std::hash<std::string_view>{}(sv);
-  }
+  /// \brief Transparent hash functor for string and string_view.
+  ///
+  /// Enables heterogeneous lookup in unordered maps keyed by std::string.
+  struct StringHash {
+    using is_transparent = void; // Required for heterogeneous lookup
+
+    std::size_t operator()(const std::string& str) const
+    {
+      return std::hash<std::string>{}(str);
+    }
+
+    std::size_t operator()(std::string_view sv) const
+    {
+      return std::hash<std::string_view>{}(sv);
+    }
+  };
+
+  std::unordered_map<std::string, std::any, StringHash, std::equal_to<>> mObjects;
 };
 
-/// \brief Unordered map storing std::any values with heterogeneous key lookup. It was chosen based on benchmark
-///        in testQCInputs.cxx
-using transparent_unordered_map = std::unordered_map<std::string, std::any, StringHash, std::equal_to<>>;
-
-/// \brief Default alias for QC inputs using transparent_unordered_map container.
-using QCInputs = QCInputsGeneric<transparent_unordered_map>;
-
 } // namespace o2::quality_control::core
 
 #include "QCInputs.inl"

Framework/include/QualityControl/QCInputs.inl

@@ -20,9 +20,8 @@
 namespace o2::quality_control::core
 {
 
-template <typename ContainerMap>
 template <typename Result>
-std::optional<std::reference_wrapper<const Result>> QCInputsGeneric<ContainerMap>::get(std::string_view key)
+std::optional<std::reference_wrapper<const Result>> QCInputs::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) {
@@ -32,16 +31,14 @@ std::optional<std::reference_wrapper<const Result>> QCInputsGeneric<ContainerMap
   return std::nullopt;
 }
 
-template <typename ContainerMap>
 template <typename Result, typename... Args>
-void QCInputsGeneric<ContainerMap>::emplace(std::string_view key, Args&&... args)
+void QCInputs::emplace(std::string_view key, Args&&... args)
 {
   mObjects.emplace(key, std::any{ std::in_place_type<Result>, std::forward<Args>(args)... });
 }
 
-template <typename ContainerMap>
 template <typename T>
-void QCInputsGeneric<ContainerMap>::insert(std::string_view key, const T& value)
+void QCInputs::insert(std::string_view key, const T& value)
 {
   mObjects.insert({ std::string{ key }, value });
 }
@@ -102,25 +99,22 @@ static constexpr auto pointer_to_reference = std::views::transform(
 
 } // namespace internal
 
-template <typename ContainerMap>
 template <typename T>
-auto QCInputsGeneric<ContainerMap>::iterateByType() const
+auto QCInputs::iterateByType() const
 {
   using namespace internal;
   return mObjects | any_to_specific<T> | filter_nullptr_in_pair | pair_to_value_const_ref;
 }
 
-template <typename ContainerMap>
 template <typename T, std::predicate<const std::pair<std::string_view, const T*>&> Pred>
-auto QCInputsGeneric<ContainerMap>::iterateByTypeAndFilter(Pred&& filter) const
+auto QCInputs::iterateByTypeAndFilter(Pred&& filter) const
 {
   using namespace internal;
   return mObjects | any_to_specific<T> | filter_nullptr_in_pair | std::views::filter(filter) | pair_to_value_const_ref;
 }
 
-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 QCInputsGeneric<ContainerMap>::iterateByTypeFilterAndTransform(Pred&& filter, Transform&& transform) const
+auto QCInputs::iterateByTypeFilterAndTransform(Pred&& filter, Transform&& transform) const
 {
   using namespace internal;
   return mObjects |
@@ -133,8 +127,7 @@ auto QCInputsGeneric<ContainerMap>::iterateByTypeFilterAndTransform(Pred&& filte
          pointer_to_reference;
 }
 
-template <typename ContainerMap>
-size_t QCInputsGeneric<ContainerMap>::size() const noexcept
+inline size_t QCInputs::size() const noexcept
 {
   return mObjects.size();
 }

Framework/include/QualityControl/QCInputsAdapters.h

@@ -60,7 +60,7 @@ inline auto iterateMonitorObjects(const QCInputs& data);
 inline auto iterateMonitorObjects(const QCInputs& data, std::string_view taskName);
 
 /// \brief Retrieve the first MonitorObject of type StoredType matching both name and task.
-/// \tparam StoredType Type of MonitorObject or subclass to retrieve.
+/// \tparam StoredType Type of MonitorObject or stored class to retrieve.
 /// \param data QCInputs to search.
 /// \param objectName Name of the MonitorObject.
 /// \param taskName Name of the originating task.
@@ -70,7 +70,7 @@ std::optional<std::reference_wrapper<const StoredType>> getMonitorObject(const Q
 
 // returns first occurence of MO with given name (possible name clash)
 /// \brief Retrieve the first MonitorObject of type StoredType matching name.
-/// \tparam StoredType Type of MonitorObject or subclass to retrieve.
+/// \tparam StoredType Type of MonitorObject or stored class to retrieve.
 /// \param data QCInputs to search.
 /// \param objectName Name of the MonitorObject.
 /// \returns Optional reference to const StoredType if found.

Framework/include/QualityControl/QCInputsAdapters.inl

@@ -91,7 +91,7 @@ inline auto iterateQualityObjects(const QCInputs& data)
 inline auto iterateQualityObjects(const QCInputs& data, std::string_view checkName)
 {
   const auto filterQOByName = [checkName](const auto& pair) {
-    return std::string_view(pair.second->getName()) == checkName;
+    return std::string_view(pair.second->getCheckName()) == checkName;
   };
   return data.iterateByTypeAndFilter<QualityObject>(filterQOByName);
 }

Framework/src/QCInputsAdapters.cxx

@@ -22,7 +22,7 @@ namespace o2::quality_control::core
 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;
+    return std::string_view(pair.second->getCheckName()) == objectName;
   };
   for (const auto& qo : data.iterateByTypeAndFilter<QualityObject>(filterQOByName)) {
     return { qo };

Framework/test/testQCInputs.cxx

@@ -131,112 +131,6 @@ TEST_CASE("Data - raw pointers", "[Data]")
   REQUIRE(count == 2);
 }
 
-using stdmap = std::map<std::string, std::any, std::less<>>;
-using boostflatmap = boost::container::flat_map<std::string, std::any, std::less<>>;
-
-TEMPLATE_TEST_CASE("Data - inserting fundamental types", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
-{
-  constexpr size_t iterations = 20'000;
-
-  BENCHMARK("insert size_t")
-  {
-    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);
-    }
-  };
-}
-
-TEMPLATE_TEST_CASE("Data - iterating fundamental types", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
-{
-  constexpr size_t iterations = 20000;
-  QCInputsGeneric<TestType> data;
-  for (size_t i = 0; i != iterations; ++i) {
-    data.insert(std::to_string(i), i);
-  }
-
-  REQUIRE(data.size() == iterations);
-  BENCHMARK("iterate size_t")
-  {
-    REQUIRE(data.size() == iterations);
-    size_t r{};
-    size_t count{};
-    for (const auto& v : data.template iterateByType<size_t>()) {
-      r += v;
-      count++;
-    }
-    REQUIRE(count == iterations);
-  };
-}
-
-TEMPLATE_TEST_CASE("Data - get fundamental types", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
-{
-  constexpr size_t iterations = 20000;
-  QCInputsGeneric<TestType> data;
-  for (size_t i = 0; i != iterations; ++i) {
-    data.insert(std::to_string(i), i);
-  }
-
-  REQUIRE(data.size() == iterations);
-  BENCHMARK("iterate size_t")
-  {
-    size_t r{};
-    size_t count{};
-    for (size_t i = 0; i != iterations; ++i) {
-      auto opt = data.template get<size_t>(std::to_string(i));
-      r += opt.value();
-      auto& v = opt.value();
-      count++;
-    }
-    REQUIRE(count == iterations);
-  };
-}
-
-std::string generateRandomString(size_t length)
-{
-  static constexpr std::string_view CHARACTERS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  thread_local std::mt19937 generator(std::random_device{}());
-  std::uniform_int_distribution<size_t> distribution(0, CHARACTERS.length() - 1);
-
-  std::string random_string;
-  random_string.reserve(length);
-  for (size_t i = 0; i < length; ++i) {
-    random_string += CHARACTERS[distribution(generator)];
-  }
-  return random_string;
-}
-
-TEMPLATE_TEST_CASE("Data - inserting and iterating MOs", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
-{
-  constexpr size_t iterations = 1000;
-  std::vector<std::shared_ptr<MonitorObject>> MOs;
-
-  for (size_t i = 0; i != iterations; ++i) {
-    const auto name = generateRandomString(20);
-    auto* h = new TH1F(name.c_str(), name.c_str(), 100, 0, 99);
-    std::shared_ptr<MonitorObject> mo = std::make_shared<MonitorObject>(h, "taskname", "class1", "TST");
-    MOs.push_back(mo);
-  }
-
-  BENCHMARK("insert - iterate MOs")
-  {
-    QCInputsGeneric<TestType> data;
-    for (const auto& mo : MOs) {
-      data.insert(mo->getFullName(), mo);
-    }
-
-    const auto filterMOByName = [](const auto& pair) {
-      return std::string_view(pair.second->GetName()) == "nonexistent";
-    };
-
-    const auto getInternalObject = [](const MonitorObject* ptr) -> const auto* {
-      return dynamic_cast<const TH1F*>(ptr->getObject());
-    };
-    REQUIRE(data.template iterateByTypeFilterAndTransform<MonitorObject, TH1F>(filterMOByName, getInternalObject).empty());
-  };
-}
-
 TEST_CASE("Data adapters - helper functions", "[Data]")
 {