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++()

Author: franzpoeschel

include/openPMD/ReadIterations.hpp

@@ -20,6 +20,7 @@
  */
 #pragma once
 
+#include "openPMD/auxiliary/Option.hpp"
 #include "openPMD/Iteration.hpp"
 #include "openPMD/Series.hpp"
 
@@ -90,6 +91,12 @@ class SeriesIterator
         m_currentIteration = *m_iterationsInCurrentStep.begin();
         return true;
     }
+
+    auxiliary::Option< SeriesIterator * > nextIterationInStep( Iteration & );
+
+    auxiliary::Option< SeriesIterator * > nextStep( Iteration & );
+
+    auxiliary::Option< SeriesIterator * > loopBody();
 };
 
 /**

src/ReadIterations.cpp

@@ -140,70 +140,59 @@ SeriesIterator::SeriesIterator( Series series )
     }
 }
 
-SeriesIterator & SeriesIterator::operator++()
+auxiliary::Option< SeriesIterator * >
+SeriesIterator::nextIterationInStep( Iteration & currentIteration )
 {
-    if( !m_series.has_value() )
+    using ret_t = auxiliary::Option< SeriesIterator * >;
+
+    m_iterationsInCurrentStep.pop_front();
+    if( m_iterationsInCurrentStep.empty() )
     {
-        *this = end();
-        return *this;
+        return ret_t{};
     }
-    Series & series = m_series.get();
-    auto & iterations = series.iterations;
-    auto & currentIteration = iterations[ m_currentIteration ];
+
     auto oldIterationIndex = m_currentIteration;
+    m_currentIteration = *m_iterationsInCurrentStep.begin();
+    auto & series = m_series.get();
 
-    m_iterationsInCurrentStep.pop_front();
-    if( !m_iterationsInCurrentStep.empty() )
+    switch( series.iterationEncoding() )
     {
-        m_currentIteration = *m_iterationsInCurrentStep.begin();
-        switch( series.iterationEncoding() )
-        {
-        case IterationEncoding::groupBased:
-        case IterationEncoding::variableBased:
+    case IterationEncoding::groupBased:
+    case IterationEncoding::variableBased:
+    {
+        if( !currentIteration.closed() )
         {
-            if( !currentIteration.closed() )
-            {
-                currentIteration.get().m_closed =
-                    internal::CloseStatus::ClosedInFrontend;
-            }
-            auto begin = series.iterations.find( oldIterationIndex );
-            auto end = begin;
-            ++end;
-            series.flush_impl(
-                begin,
-                end,
-                FlushLevel::UserFlush,
-                /* flushIOHandler = */ true );
-
-            series.iterations[ m_currentIteration ].open();
-            return *this;
+            currentIteration.get().m_closed =
+                internal::CloseStatus::ClosedInFrontend;
         }
-        case IterationEncoding::fileBased:
-            if( !currentIteration.closed() )
-            {
-                currentIteration.close();
-            }
-            series.iterations[ m_currentIteration ].open();
-            series.iterations[ m_currentIteration ].beginStep();
-            return *this;
-        }
-        throw std::runtime_error( "Unreachable!" );
-    }
+        auto begin = series.iterations.find( oldIterationIndex );
+        auto end = begin;
+        ++end;
+        series.flush_impl(
+            begin,
+            end,
+            FlushLevel::UserFlush,
+            /* flushIOHandler = */ true );
 
-    // The currently active iterations have been exhausted.
-    // Now see if there are further iterations to be found.
-
-    if( series.iterationEncoding() == IterationEncoding::fileBased )
-    {
-        // this one is handled above, stream is over once it proceeds to here
-        *this = end();
-        return *this;
+        series.iterations[ m_currentIteration ].open();
+        return { this };
     }
-
-    if( !currentIteration.closed() )
-    {
-        currentIteration.close();
+    case IterationEncoding::fileBased:
+        if( !currentIteration.closed() )
+        {
+            currentIteration.close();
+        }
+        series.iterations[ m_currentIteration ].open();
+        series.iterations[ m_currentIteration ].beginStep();
+        return { this };
     }
+    throw std::runtime_error( "Unreachable!" );
+}
+
+auxiliary::Option< SeriesIterator * > SeriesIterator::nextStep(
+    Iteration & currentIteration )
+{
+    using ret_t = auxiliary::Option< SeriesIterator * >;
 
     // since we are in group-based iteration layout, it does not
     // matter which iteration we begin a step upon
@@ -222,18 +211,19 @@ SeriesIterator & SeriesIterator::operator++()
          * Fallback implementation: Assume that each step corresponds
          * with an iteration in ascending order.
          */
-        auto it = iterations.find( m_currentIteration );
-        auto itEnd = iterations.end();
+        auto & series = m_series.get();
+        auto it = series.iterations.find( m_currentIteration );
+        auto itEnd = series.iterations.end();
         if( it == itEnd )
         {
             *this = end();
-            return *this;
+            return { this };
         }
         ++it;
         if( it == itEnd )
         {
             *this = end();
-            return *this;
+            return { this };
         }
         m_iterationsInCurrentStep = { it->first };
     }
@@ -242,8 +232,52 @@ SeriesIterator & SeriesIterator::operator++()
     if( status == AdvanceStatus::OVER )
     {
         *this = end();
-        return *this;
+        return { this };
     }
+
+    return ret_t{};
+}
+
+auxiliary::Option< SeriesIterator * > SeriesIterator::loopBody()
+{
+    using ret_t = auxiliary::Option< SeriesIterator * >;
+
+    Series & series = m_series.get();
+    auto & iterations = series.iterations;
+    auto & currentIteration = iterations[ m_currentIteration ];
+
+
+    {
+        auto option = nextIterationInStep( currentIteration );
+        if( option.has_value() )
+        {
+            return option;
+        }
+    }
+
+    // The currently active iterations have been exhausted.
+    // Now see if there are further iterations to be found.
+
+    if( series.iterationEncoding() == IterationEncoding::fileBased )
+    {
+        // this one is handled above, stream is over once it proceeds to here
+        *this = end();
+        return { this };
+    }
+
+    if( !currentIteration.closed() )
+    {
+        currentIteration.close();
+    }
+
+    {
+        auto option = nextStep( currentIteration );
+        if( option.has_value() )
+        {
+            return option;
+        }
+    }
+
     currentIteration.setStepStatus( StepStatus::DuringStep );
 
     auto iteration = iterations.at( m_currentIteration );
@@ -253,12 +287,31 @@ SeriesIterator & SeriesIterator::operator++()
     }
     else
     {
-        // we had this one already, skip it
-        // @todo remove recursive call
+        // we had this iteration already, skip it
         iteration.endStep();
-        return operator++();
+        return ret_t{}; // empty, go into next iteration
     }
-    return *this;
+    return { this };
+}
+
+SeriesIterator & SeriesIterator::operator++()
+{
+    if( !m_series.has_value() )
+    {
+        *this = end();
+        return *this;
+    }
+    auxiliary::Option< SeriesIterator * > res;
+    /*
+     * loopBody() might return an empty option to indicate a skipped iteration.
+     * Loop until it returns something real for us.
+     */
+    do
+    {
+        res = loopBody();
+    } while( !res.has_value() );
+
+    return *res.get();
 }
 
 IndexedIteration SeriesIterator::operator*()