version 2

Author: Michal Tichák

Framework/CMakeLists.txt

@@ -137,7 +137,7 @@ add_library(O2QualityControl
   src/KafkaPoller.cxx
   src/FlagHelpers.cxx
   src/ObjectMetadataHelpers.cxx
-  src/Data.cxx
+  src/DataAdapters.cxx
 )
 
 target_include_directories(

Framework/include/QualityControl/Data.h

@@ -20,128 +20,23 @@
 #include <any>
 #include <concepts>
 #include <functional>
-#include <iterator>
 #include <map>
 #include <memory>
 #include <optional>
 #include <string>
-#include <vector>
+#include <ranges>
+#include <type_traits>
 
 namespace o2::quality_control::core
 {
 
-class MonitorObject;
+template <typename Function, typename Result, typename... Args>
+concept invocable_r = std::invocable<Function, Args...> && std::same_as<std::invoke_result_t<Function, Args...>, Result>;
 
 class Data
 {
-  // change this for boost::flat_map? or do a magic and split by different keys?
-  using InternalContainer = std::map<std::string, std::any, std::less<>>;
-  using InternalContainerConstIterator = InternalContainer::const_iterator;
-
-  template <typename T>
-  using value_type = std::pair<std::reference_wrapper<const std::string>, std::reference_wrapper<const T>>;
-
-  template <typename T>
-  struct NoPredicateIncrementPolicy {
-    bool increment(const InternalContainerConstIterator& it, std::optional<value_type<T>>& val)
-    {
-      if (auto* casted = std::any_cast<T>(&it->second); casted != nullptr) {
-        val.emplace(it->first, *casted);
-        return true;
-      }
-      return false;
-    }
-  };
-
-  template <typename T, std::predicate<const T&> Pred>
-  struct PredicateIncrementPolicy {
-    Pred filter;
-    bool increment(const InternalContainerConstIterator& it, std::optional<value_type<T>>& val)
-    {
-      if (auto* casted = std::any_cast<T>(&it->second); casted != nullptr) {
-        if (filter(*casted)) {
-          val.emplace(it->first, *casted);
-          return true;
-        }
-      }
-      return false;
-    }
-  };
-
  public:
-  template <typename T, typename IncrementalPolicy = NoPredicateIncrementPolicy<T>>
-  class Iterator
-  {
-   public:
-    using value_type = std::pair<std::reference_wrapper<const std::string>, std::reference_wrapper<const T>>;
-    using difference_type = std::ptrdiff_t;
-    using iterator_category = std::forward_iterator_tag;
-    using reference = const value_type&;
-    using pointer = const value_type*;
-
-   private:
-   public:
-    Iterator() = default;
-    Iterator(const InternalContainerConstIterator& it, const InternalContainerConstIterator& end, const IncrementalPolicy& policy = {})
-      : mIt{ it }, mEnd{ end }, mVal{ std::nullopt }
-    {
-      seek_next_valid(mIt);
-    }
-
-    reference operator*() const
-    {
-      return mVal.value();
-    }
-
-    pointer operator->() const
-    {
-      return &mVal.value();
-    }
-
-    Iterator& operator++()
-    {
-      // TODO: can this check be optimised out?
-      if (mIt != mEnd) {
-        seek_next_valid(++mIt);
-      }
-      return *this;
-    }
-
-    Iterator operator++(int)
-    {
-      auto tmp = *this;
-      ++*this;
-      return tmp;
-    }
-
-    bool operator==(const Iterator& other) const
-    {
-      return mIt == other.mIt;
-    }
-
-   private:
-    InternalContainerConstIterator mIt;
-    InternalContainerConstIterator mEnd;
-    IncrementalPolicy mPolicy;
-    std::optional<value_type> mVal;
-
-    void seek_next_valid(InternalContainerConstIterator& startingIt)
-    {
-      for (; startingIt != mEnd; ++startingIt) {
-        if (mPolicy.increment(startingIt, mVal)) {
-          break;
-        }
-      }
-    }
-  };
-
-  template <typename T, std::predicate<const T&> P>
-  using FilteringIterator = Iterator<T, PredicateIncrementPolicy<T, P>>;
-
-  static_assert(std::forward_iterator<Iterator<int>>);
-
   Data() = default;
-  Data(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
 
   template <typename Result>
   std::optional<Result> get(std::string_view key)
@@ -154,83 +49,71 @@ class Data
     return std::nullopt;
   }
 
-  template <typename StoreType>
-  void insert(std::string_view key, const StoreType& value)
+  template <typename T, typename... Args>
+  void emplace(std::string_view key, Args&&... args)
   {
-    mObjects.insert({ std::string{ key }, value });
+    mObjects.emplace(key, std::any{ std::in_place_type<T>, std::forward<Args>(args)... });
   }
 
   template <typename T>
-  struct Range {
-    Iterator<T> begin_it;
-    Iterator<T> end_it;
-    Iterator<T> begin() { return begin_it; }
-    Iterator<T> end() { return end_it; }
-  };
+  void insert(std::string_view key, const T& value)
+  {
+    mObjects.insert({ std::string{ key }, value });
+  }
 
   template <typename T>
-  Range<T> iterate() const noexcept
+  static const T* any_cast_try_shared_ptr(const std::any& value)
   {
-    return {
-      .begin_it = begin<T>(),
-      .end_it = end<T>()
-    };
+    if (auto* casted = std::any_cast<std::shared_ptr<T>>(&value); casted != nullptr) {
+      return casted->get();
+    } else {
+      return std::any_cast<T>(&value);
+    }
   }
 
-  template <typename T, std::predicate<const T&> P>
-  struct FilteredRange {
-    FilteringIterator<T, P> begin_it;
-    FilteringIterator<T, P> end_it;
-    FilteringIterator<T, P> begin() { return begin_it; }
-    FilteringIterator<T, P> end() { return end_it; }
-  };
+  template <typename T>
+  static constexpr auto any_to_specific = std::views::transform([](const auto& pair) -> std::pair<std::string_view, const T*> { return { pair.first, any_cast_try_shared_ptr<T>(pair.second) }; });
 
-  template <typename Type, std::predicate<const Type&> Pred>
-  FilteredRange<Type, Pred> iterateAndFilter(Pred&& filter) const noexcept
-  {
-    return FilteredRange<Type, Pred>{
-      .begin_it = begin<Type, Pred>(std::forward<Pred>(filter)),
-      .end_it = end<Type, Pred>(std::forward<Pred>(filter))
-    };
-  }
+  static constexpr auto filter_nullptr_in_pair = std::views::filter([](const auto& pair) { return pair.second != nullptr; });
 
-  size_t size();
+  static constexpr auto filter_nullptr = std::views::filter([](const auto* ptr) -> bool { return ptr != nullptr; });
 
-  template <typename T>
-  Iterator<T> begin() const noexcept
-  {
-    return { mObjects.begin(), mObjects.end() };
-  }
+  static constexpr auto pair_to_reference = std::views::transform([](const auto& pair) -> const auto& { return *pair.second; });
 
-  template <typename T, std::predicate<const T&> P>
-  FilteringIterator<T, P> begin(P&& filter) const noexcept
+  static constexpr auto pointer_to_reference = std::views::transform([](const auto* ptr) -> auto& { return *ptr; });
+
+  template <typename T>
+  auto iterateByType() const
   {
-    return { mObjects.begin(), mObjects.end(), PredicateIncrementPolicy<T, P>(filter) };
+    return mObjects | any_to_specific<T> | filter_nullptr_in_pair | pair_to_reference;
   }
 
-  template <typename T>
-  Iterator<T> end() const noexcept
+  template <typename T, std::predicate<const std::pair<std::string_view, const T*>&> Pred>
+  auto iterateByTypeAndFilter(Pred&& filter) const
   {
-    return { mObjects.end(), mObjects.end() };
+    return mObjects | any_to_specific<T> | filter_nullptr_in_pair | std::views::filter(filter) | pair_to_reference;
   }
 
-  template <typename T, std::predicate<const T&> P>
-  FilteringIterator<T, P> end(P&& filter) const noexcept
+  template <typename StoredType, typename ResultingType, std::predicate<const std::pair<std::string_view, const StoredType*>&> Pred, invocable_r<const ResultingType*, const StoredType*> Transform>
+  auto iterateByTypeFilterAndTransform(Pred&& filter, Transform&& transform) const
   {
-    return { mObjects.end(), mObjects.end(), PredicateIncrementPolicy<T, P>(filter) };
+    return mObjects |
+           any_to_specific<StoredType> |
+           filter_nullptr_in_pair |
+           std::views::filter(filter) |
+           std::views::transform([](const auto& pair) { return pair.second; }) |
+           std::views::transform(transform) |
+           filter_nullptr |
+           pointer_to_reference;
   }
 
-  template <typename Base, typename Derived>
-  static std::optional<Derived*> downcast(const Base* base)
+  size_t size() const noexcept
   {
-    if (const auto* casted = dynamic_cast<Derived*>(base); casted != nullptr) {
-      return { casted };
-    }
-    return std::nullopt;
+    return mObjects.size();
   }
 
  private:
-  InternalContainer mObjects;
+  std::map<std::string, std::any, std::less<>> mObjects;
 };
 
 } // namespace o2::quality_control::core

Framework/include/QualityControl/DataAdapters.h

@@ -0,0 +1,38 @@
+// Copyright 2025 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.
+
+///
+/// \file   DataAdapters.h
+/// \author Michal Tichak
+///
+
+#ifndef QC_CORE_DATA_ADAPTERS_H
+#define QC_CORE_DATA_ADAPTERS_H
+
+#include "Data.h"
+#include "QualityControl/MonitorObject.h"
+
+namespace o2::quality_control::core
+{
+
+Data createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
+
+template <typename Result>
+auto iterateMOsFilterByNameAndTransform(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/CheckInterface.cxx

@@ -18,6 +18,7 @@
 #include "QualityControl/ReferenceUtils.h"
 #include "QualityControl/MonitorObject.h"
 #include "QualityControl/Data.h"
+#include "QualityControl/DataAdapters.h"
 
 #include <TClass.h>
 
@@ -29,7 +30,7 @@ namespace o2::quality_control::checker
 
 core::Quality CheckInterface::check(std::map<std::string, std::shared_ptr<core::MonitorObject>>* moMap)
 {
-  Data data(*moMap);
+  auto data = createData(*moMap);
   return check(data);
 };
 

Framework/src/Data.cxx Framework/src/DataAdapters.cxxFramework/src/Data.cxx renamed to Framework/src/DataAdapters.cxx

@@ -10,24 +10,22 @@
 // or submit itself to any jurisdiction.
 
 ///
-/// \file   Data.h
+/// \file   DataAdapters.cxx
 /// \author Michal Tichak
 ///
 
-#include "QualityControl/Data.h"
+#include "QualityControl/DataAdapters.h"
 
 namespace o2::quality_control::core
 {
-Data::Data(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap)
+
+Data createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap)
 {
+  Data data;
   for (const auto& [key, mo] : moMap) {
-    insert(key, mo);
+    data.insert(key, mo);
   }
-}
-
-size_t Data::size()
-{
-  return mObjects.size();
+  return data;
 }
 
 } // namespace o2::quality_control::core