Fix flushStep() logic

Author: franzpoeschel

include/openPMD/Iteration.hpp

@@ -311,7 +311,7 @@ class Iteration : public Attributable
     void flushFileBased(
         std::string const &, IterationIndex_t, internal::FlushParams const &);
     void flushGroupBased(IterationIndex_t, internal::FlushParams const &);
-    void flushVariableBased(IterationIndex_t, internal::FlushParams const &);
+    void flushVariableBased(internal::FlushParams const &);
     void flush(internal::FlushParams const &);
     void deferParseAccess(internal::DeferredParseAccess);
     /*

src/IO/AbstractIOHandlerImpl.cpp

@@ -25,6 +25,7 @@
 #include "openPMD/Streaming.hpp"
 #include "openPMD/auxiliary/Environment.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Writable.hpp"
 
@@ -283,7 +284,28 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     "] WRITE_ATT: (",
                     parameter.dtype,
                     ") ",
-                    parameter.name);
+                    parameter.name,
+                    "=",
+                    [&]() {
+                        return std::visit(
+                            [&](auto const &val) {
+                                using dtype = std::remove_cv_t<
+                                    std::remove_reference_t<decltype(val)>>;
+                                if constexpr (
+                                    auxiliary::IsArray_v<dtype> ||
+                                    auxiliary::IsVector_v<dtype>)
+                                {
+                                    return vec_as_string(val);
+                                }
+                                else
+                                {
+                                    std::stringstream res;
+                                    res << val;
+                                    return res.str();
+                                }
+                            },
+                            parameter.resource);
+                    });
                 writeAttribute(i.writable, parameter);
                 break;
             }

src/Iteration.cpp

@@ -292,8 +292,7 @@ void Iteration::flushGroupBased(
     }
 }
 
-void Iteration::flushVariableBased(
-    IterationIndex_t i, internal::FlushParams const &flushParams)
+void Iteration::flushVariableBased(internal::FlushParams const &flushParams)
 {
     setDirty(true);
 
@@ -307,23 +306,6 @@ void Iteration::flushVariableBased(
         flush(flushParams);
         break;
     }
-
-    // @todo maybe dont repeat this upon each invocation
-    {
-        /*
-         * In v-based encoding, the snapshot attribute must always be written.
-         * Reason: Even in backends that don't support changing attributes,
-         * variable-based iteration encoding can be used to write one single
-         * iteration. Then, this attribute determines which iteration it is.
-         */
-        Parameter<Operation::WRITE_ATT> wAttr;
-        wAttr.changesOverSteps =
-            Parameter<Operation::WRITE_ATT>::ChangesOverSteps::IfPossible;
-        wAttr.name = "snapshot";
-        wAttr.resource = (unsigned long long)i;
-        wAttr.dtype = Datatype::ULONGLONG;
-        IOHandler()->enqueue(IOTask(this, wAttr));
-    }
 }
 
 void Iteration::flush(internal::FlushParams const &flushParams)

src/Series.cpp

@@ -1501,16 +1501,16 @@ void Series::flushGorVBased(
                             "Iterations must be the same backend object as the "
                             "Iterations themselves.");
                     }
-                    series.m_currentlyActiveIterations.emplace(it->first);
                 }
+                series.m_currentlyActiveIterations.emplace(it->first);
                 switch (iterationEncoding())
                 {
                     using IE = IterationEncoding;
                 case IE::groupBased:
                     it->second.flushGroupBased(it->first, flushParams);
                     break;
                 case IE::variableBased:
-                    it->second.flushVariableBased(it->first, flushParams);
+                    it->second.flushVariableBased(flushParams);
                     break;
                 default:
                     throw std::runtime_error(
@@ -2640,8 +2640,16 @@ void Series::flushStep(bool doFlush)
          * one IO step.
          */
         Parameter<Operation::WRITE_ATT> wAttr;
+        /*
+         * In v-based encoding, the snapshot attribute must always be written.
+         * Reason: Even in backends that don't support changing attributes,
+         * variable-based iteration encoding can be used to write one single
+         * iteration. Then, this attribute determines which iteration it is.
+         */
         wAttr.changesOverSteps =
-            Parameter<Operation::WRITE_ATT>::ChangesOverSteps::Yes;
+            iterationEncoding() == IterationEncoding::variableBased
+            ? Parameter<Operation::WRITE_ATT>::ChangesOverSteps::IfPossible
+            : Parameter<Operation::WRITE_ATT>::ChangesOverSteps::Yes;
         wAttr.name = "snapshot";
         wAttr.resource = std::vector<unsigned long long>{
             series.m_currentlyActiveIterations.begin(),