Refactoring

1. Remove recursion of operator++(), this leads to constant memory usage
   rather than filling the stack at some point
2. Extract subroutines from operator++()

3. Steal some refactoring that solved some bugs on topic-read-leniently, so it stands
to reason that we should apply it here already

Author: franzpoeschel

include/openPMD/Iteration.hpp

@@ -329,6 +329,14 @@ class Iteration : public Attributable
      */
     BeginStepStatus beginStep(bool reread);
 
+    /*
+     * Iteration-independent variant for beginStep().
+     * Useful in group-based iteration encoding where the Iteration will only
+     * be known after opening the step.
+     */
+    static BeginStepStatus
+    beginStep(std::optional<Iteration> thisObject, Series &series, bool reread);
+
     /**
      * @brief End an IO step on the IO file (or file-like object)
      *        containing this iteration. In case of group-based iteration

include/openPMD/ReadIterations.hpp

@@ -89,6 +89,24 @@ class SeriesIterator
         m_currentIteration = *m_iterationsInCurrentStep.begin();
         return true;
     }
+
+    inline std::optional<uint64_t> peekCurrentIteration()
+    {
+        if (m_iterationsInCurrentStep.empty())
+        {
+            return std::nullopt;
+        }
+        else
+        {
+            return {*m_iterationsInCurrentStep.begin()};
+        }
+    }
+
+    std::optional<SeriesIterator *> nextIterationInStep();
+
+    std::optional<SeriesIterator *> nextStep();
+
+    std::optional<SeriesIterator *> loopBody();
 };
 
 /**

include/openPMD/Series.hpp

@@ -640,13 +640,21 @@ OPENPMD_private
         iterations_iterator it,
         Iteration &iteration);
 
+    AdvanceStatus advance(AdvanceMode mode);
+
     /**
      * @brief Called at the end of an IO step to store the iterations defined
      *        in the IO step to the snapshot attribute.
      *
      * @param doFlush If true, flush the IO handler.
      */
     void flushStep(bool doFlush);
+
+    /*
+     * Returns the current content of the /data/snapshot attribute.
+     * (We could also add this to the public API some time)
+     */
+    std::optional<std::vector<uint64_t> > currentSnapshot() const;
 }; // Series
 } // namespace openPMD
 

src/Iteration.cpp

@@ -569,24 +569,53 @@ void Iteration::read_impl(std::string const &groupPath)
 auto Iteration::beginStep(bool reread) -> BeginStepStatus
 {
     BeginStepStatus res;
-    using IE = IterationEncoding;
     auto series = retrieveSeries();
+    return beginStep({*this}, series, reread);
+}
+
+auto Iteration::beginStep(
+    std::optional<Iteration> thisObject, Series &series, bool reread)
+    -> BeginStepStatus
+{
+    BeginStepStatus res;
+    using IE = IterationEncoding;
     // Initialize file with this to quiet warnings
     // The following switch is comprehensive
     internal::AttributableData *file = nullptr;
     switch (series.iterationEncoding())
     {
     case IE::fileBased:
-        file = &Attributable::get();
+        if (thisObject.has_value())
+        {
+            file = &static_cast<Attributable &>(*thisObject).get();
+        }
+        else
+        {
+            throw error::Internal(
+                "Advancing a step in file-based iteration encoding is "
+                "iteration-specific.");
+        }
         break;
     case IE::groupBased:
     case IE::variableBased:
         file = &series.get();
         break;
     }
 
-    AdvanceStatus status = series.advance(
-        AdvanceMode::BEGINSTEP, *file, series.indexOf(*this), *this);
+    AdvanceStatus status;
+    if (thisObject.has_value())
+    {
+        status = series.advance(
+            AdvanceMode::BEGINSTEP,
+            *file,
+            series.indexOf(*thisObject),
+            *thisObject);
+    }
+    else
+    {
+        status = series.advance(AdvanceMode::BEGINSTEP);
+    }
+
     switch (status)
     {
     case AdvanceStatus::OVER:
@@ -598,22 +627,31 @@ auto Iteration::beginStep(bool reread) -> BeginStepStatus
     }
 
     // re-read -> new datasets might be available
-    if (reread &&
+    auto IOHandl = series.IOHandler();
+    if (reread && status != AdvanceStatus::RANDOMACCESS &&
         (series.iterationEncoding() == IE::groupBased ||
          series.iterationEncoding() == IE::variableBased) &&
-        (this->IOHandler()->m_frontendAccess == Access::READ_ONLY ||
-         this->IOHandler()->m_frontendAccess == Access::READ_WRITE))
+        (IOHandl->m_frontendAccess == Access::READ_ONLY ||
+         IOHandl->m_frontendAccess == Access::READ_WRITE))
     {
-        switch (IOHandler()->m_frontendAccess)
+        switch (IOHandl->m_frontendAccess)
         {
         case Access::READ_ONLY:
         case Access::READ_WRITE: {
             bool previous = series.iterations.written();
             series.iterations.written() = false;
-            auto oldStatus = IOHandler()->m_seriesStatus;
-            IOHandler()->m_seriesStatus = internal::SeriesStatus::Parsing;
-            res.iterationsInOpenedStep = series.readGorVBased(false);
-            IOHandler()->m_seriesStatus = oldStatus;
+            auto oldStatus = IOHandl->m_seriesStatus;
+            IOHandl->m_seriesStatus = internal::SeriesStatus::Parsing;
+            try
+            {
+                res.iterationsInOpenedStep = series.readGorVBased(false);
+            }
+            catch (...)
+            {
+                IOHandl->m_seriesStatus = oldStatus;
+                throw;
+            }
+            IOHandl->m_seriesStatus = oldStatus;
             series.iterations.written() = previous;
             break;
         }