Fix: Use explicit ::close() call in WriteIterations

include/openPMD/WriteIterations.hpp

@@ -44,9 +44,16 @@ class Series;
  * not possible once it has been closed.
  *
  */
+
+namespace internal
+{
+    class SeriesData;
+}
+
 class WriteIterations
 {
     friend class Series;
+    friend class internal::SeriesData;
 
 private:
     using IterationsContainer_t =
@@ -62,6 +69,7 @@ class WriteIterations
     struct SharedResources
     {
         IterationsContainer_t iterations;
+        //! Index of the last opened iteration
         std::optional<Iteration::IterationIndex_t> currentlyOpen;
 
         SharedResources(IterationsContainer_t);
@@ -70,8 +78,11 @@ class WriteIterations
 
     WriteIterations(IterationsContainer_t);
     explicit WriteIterations() = default;
-    //! Index of the last opened iteration
-    std::shared_ptr<SharedResources> shared;
+    // std::optional so that a single instance is able to close this without
+    // needing to wait for all instances to deallocate
+    std::shared_ptr<std::optional<SharedResources>> shared;
+
+    void close();
 
 public:
     mapped_type &operator[](key_type const &key);

src/Series.cpp

@@ -2235,7 +2235,10 @@ namespace internal
     void SeriesData::close()
     {
         // WriteIterations gets the first shot at flushing
-        this->m_writeIterations = std::optional<WriteIterations>();
+        if (this->m_writeIterations.has_value())
+        {
+            this->m_writeIterations.value().close();
+        }
         /*
          * Scenario: A user calls `Series::flush()` but does not check for
          * thrown exceptions. The exception will propagate further up,
@@ -2251,10 +2254,6 @@ namespace internal
             impl.flush();
             impl.flushStep(/* doFlush = */ true);
         }
-        if (m_writeIterations.has_value())
-        {
-            m_writeIterations = std::optional<WriteIterations>();
-        }
         // Not strictly necessary, but clear the map of iterations
         // This releases the openPMD hierarchy
         iterations.container().clear();

src/WriteIterations.cpp

@@ -20,6 +20,7 @@
  */
 
 #include "openPMD/WriteIterations.hpp"
+#include "openPMD/Error.hpp"
 
 #include "openPMD/Series.hpp"
 
@@ -45,9 +46,15 @@ WriteIterations::SharedResources::~SharedResources()
 }
 
 WriteIterations::WriteIterations(IterationsContainer_t iterations)
-    : shared{std::make_shared<SharedResources>(std::move(iterations))}
+    : shared{std::make_shared<std::optional<SharedResources>>(
+          std::move(iterations))}
 {}
 
+void WriteIterations::close()
+{
+    *shared = std::nullopt;
+}
+
 WriteIterations::mapped_type &WriteIterations::operator[](key_type const &key)
 {
     // make a copy
@@ -56,17 +63,23 @@ WriteIterations::mapped_type &WriteIterations::operator[](key_type const &key)
 }
 WriteIterations::mapped_type &WriteIterations::operator[](key_type &&key)
 {
-    if (shared->currentlyOpen.has_value())
+    if (!shared || !shared->has_value())
+    {
+        throw error::WrongAPIUsage(
+            "[WriteIterations] Trying to access after closing Series.");
+    }
+    auto &s = shared->value();
+    if (s.currentlyOpen.has_value())
     {
-        auto lastIterationIndex = shared->currentlyOpen.value();
-        auto &lastIteration = shared->iterations.at(lastIterationIndex);
+        auto lastIterationIndex = s.currentlyOpen.value();
+        auto &lastIteration = s.iterations.at(lastIterationIndex);
         if (lastIterationIndex != key && !lastIteration.closed())
         {
             lastIteration.close();
         }
     }
-    shared->currentlyOpen = key;
-    auto &res = shared->iterations[std::move(key)];
+    s.currentlyOpen = key;
+    auto &res = s.iterations[std::move(key)];
     if (res.getStepStatus() == StepStatus::NoStep)
     {
         res.beginStep(/* reread = */ false);