Backport the fix

Author: franzpoeschel

include/openPMD/ReadIterations.hpp

@@ -33,6 +33,7 @@ namespace openPMD
 {
 class SeriesIterator
 {
+    friend class Series;
     using iteration_index_t = IndexedIteration::index_t;
 
     using maybe_series_t = std::optional<Series>;

include/openPMD/WriteIterations.hpp

@@ -105,5 +105,6 @@ class WriteIterations
      * Return the iteration that is currently being written to, if it exists.
      */
     std::optional<IndexedIteration> currentIteration();
+    std::optional<Iteration::IterationIndex_t> currentIterationIndex() const;
 };
 } // namespace openPMD

src/Series.cpp

@@ -2568,7 +2568,8 @@ auto Series::openIterationIfDirty(IterationIndex_t index, Iteration iteration)
     {
         return IterationOpened::RemainsClosed;
     }
-    bool const dirtyRecursive = iteration.dirtyRecursive();
+    bool dirtyRecursive = iteration.dirtyRecursive();
+
     if (iteration.get().m_closed == internal::CloseStatus::ClosedInBackend)
     {
         // file corresponding with the iteration has previously been
@@ -2589,6 +2590,33 @@ auto Series::openIterationIfDirty(IterationIndex_t index, Iteration iteration)
         return IterationOpened::RemainsClosed;
     }
 
+    /*
+     * When using writeIterations(), the currently active Iteration should
+     * always be flushed (unless, as checked above, it is already closed).
+     * These two blocks checks if an Iteration is currently collectively opened.
+     */
+    auto &series = get();
+    [&]() {
+        if (!series.m_sharedStatefulIterator)
+        {
+            return;
+        }
+        auto const current_iteration =
+            series.m_sharedStatefulIterator->peekCurrentIteration();
+        dirtyRecursive |=
+            current_iteration.has_value() && *current_iteration == index;
+    }();
+    [&]() {
+        if (!series.m_writeIterations)
+        {
+            return;
+        }
+        auto const current_iteration =
+            series.m_writeIterations->currentIterationIndex();
+        dirtyRecursive |=
+            current_iteration.has_value() && *current_iteration == index;
+    }();
+
     switch (iterationEncoding())
     {
         using IE = IterationEncoding;

src/WriteIterations.cpp

@@ -104,21 +104,29 @@ WriteIterations::mapped_type &WriteIterations::operator[](key_type &&key)
 
 std::optional<IndexedIteration> WriteIterations::currentIteration()
 {
-    if (!shared || !shared->has_value())
+    auto current_index = currentIterationIndex();
+    if (!current_index.has_value())
     {
         return std::nullopt;
     }
     auto &s = shared->value();
-    if (!s.currentlyOpen.has_value())
-    {
-        return std::nullopt;
-    }
-    Iteration &currentIteration = s.iterations.at(s.currentlyOpen.value());
+    Iteration &currentIteration = s.iterations.at(current_index.value());
     if (currentIteration.closed())
     {
         return std::nullopt;
     }
     return std::make_optional<IndexedIteration>(
         IndexedIteration(currentIteration, s.currentlyOpen.value()));
 }
+
+std::optional<Iteration::IterationIndex_t>
+WriteIterations::currentIterationIndex() const
+{
+    if (!shared || !shared->has_value())
+    {
+        return std::nullopt;
+    }
+    auto &s = shared->value();
+    return s.currentlyOpen;
+}
 } // namespace openPMD