iterators in the middle of work

Author: Michal Tichák

Framework/include/QualityControl/Data.h

@@ -14,9 +14,14 @@
 /// \author Michal Tichak
 ///
 
+#ifndef QC_CORE_DATA_H
+#define QC_CORE_DATA_H
+
 #include <any>
 #include <concepts>
+#include <functional>
 #include <iostream>
+#include <iterator>
 #include <map>
 #include <memory>
 #include <optional>
@@ -31,7 +36,77 @@ class MonitorObject;
 
 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;
+
  public:
+  template <typename 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*;
+
+    Iterator() = default;
+    Iterator(InternalContainerConstIterator it, InternalContainerConstIterator end)
+      : mIt{ it }, mEnd{ end }, val{ std::nullopt }
+    {
+      seek_next_valid(mIt);
+    }
+
+    reference operator*() const
+    {
+      return val.value();
+    }
+
+    pointer operator->() const
+    {
+      return &val.value();
+    }
+
+    Iterator& operator++()
+    {
+      // can this 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;
+    std::optional<value_type> val;
+
+    void seek_next_valid(InternalContainerConstIterator startingIt)
+    {
+      for (auto it = startingIt; it != mEnd; ++it) {
+        if (auto* casted = std::any_cast<T>(&it->second); casted != nullptr) {
+          val.emplace(it->first, *casted);
+          break;
+        }
+      }
+    }
+  };
+
+  static_assert(std::forward_iterator<Iterator<int>>);
+
   Data() = default;
   Data(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
 
@@ -49,7 +124,6 @@ class Data
   template <typename StoreType>
   void insert(std::string_view key, const StoreType& value)
   {
-    // std::cout << "inserting value: " << value << ", of type: " << typeid(StoreType).name() << "\n";
     mObjects.insert({ std::string{ key }, value });
   }
 
@@ -79,8 +153,22 @@ class Data
     return result;
   }
 
+  template <typename T>
+  Iterator<T> begin()
+  {
+    return { mObjects.begin(), mObjects.end() };
+  }
+
+  template <typename T>
+  Iterator<T> end()
+  {
+    return { mObjects.end(), mObjects.end() };
+  }
+
  private:
-  std::map<std::string, std::any, std::less<>> mObjects;
+  InternalContainer mObjects;
 };
 
 } // namespace o2::quality_control::core
+
+#endif

Framework/test/testData.cxx

@@ -77,3 +77,28 @@ TEST_CASE("Data getAllOfTypeIf", "[Data]")
   auto filtered = data.getAllOfTypeIf<named<int>>([](const auto& val) { return val.name == "1"; });
   REQUIRE(filtered.size() == 1);
 }
+
+TEST_CASE("Data iterator", "[Data]")
+{
+  Data data;
+  data.insert("testint1", 1);
+  data.insert("teststr1", std::string{ "1" });
+  data.insert("testint2", 2);
+  data.insert("teststr2", std::string{ "2" });
+
+  auto intIt = data.begin<int>();
+  REQUIRE(intIt != data.end<int>());
+  REQUIRE(intIt->first.get() == "testint1");
+  REQUIRE(intIt->second.get() == 1);
+  intIt++;
+  REQUIRE(intIt->first.get() == "testint2");
+  REQUIRE(intIt->second.get() == 2);
+
+  auto strIt = data.begin<std::string>();
+  REQUIRE(strIt != data.end<std::string>());
+  REQUIRE(strIt->first.get() == "teststr1");
+  REQUIRE(strIt->second.get() == "1");
+  ++strIt;
+  REQUIRE(strIt->first.get() == "teststr2");
+  REQUIRE(strIt->second.get() == "2");
+}