Add more CustomHierarchyFlush operations

Author: franzpoeschel

include/openPMD/backend/ContainerImpl.tpp

@@ -359,7 +359,11 @@ auto Container<T, T_key, T_container>::flush(
         IOHandler()->enqueue(IOTask(this, pCreate));
     }
 
-    flushAttributes(flushParams);
+    customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+    if (access::write(IOHandler()->m_frontendAccess))
+    {
+        flushAttributes(flushParams);
+    }
 }
 
 template <typename T, typename T_key, typename T_container>

src/Mesh.cpp

@@ -451,9 +451,11 @@ void Mesh::flush_impl(
         }
         else
         {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
             for (auto &comp : *this)
                 comp.second.flush(comp.first, flushParams);
         }
+        // TODO why is there no unsetDirty operation here?
     }
     else
     {
@@ -469,6 +471,8 @@ void Mesh::flush_impl(
                 Parameter<Operation::CREATE_PATH> pCreate;
                 pCreate.path = name;
                 IOHandler()->enqueue(IOTask(this, pCreate));
+
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                 {
                     comp.second.parent() = &this->writable();
@@ -484,6 +488,7 @@ void Mesh::flush_impl(
             }
             else
             {
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                     comp.second.flush(comp.first, flushParams);
             }

src/ParticleSpecies.cpp

@@ -182,6 +182,7 @@ void ParticleSpecies::flush(
     }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
+        customHierarchyFlush(flushParams, /* unset_dirty = */ false);
         for (auto &record : *this)
             record.second.flush(record.first, flushParams);
         for (auto &patch : particlePatches)

src/Record.cpp

@@ -71,9 +71,11 @@ void Record::flush_impl(
         }
         else
         {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
             for (auto &comp : *this)
                 comp.second.flush(comp.first, flushParams);
         }
+        // TODO why is there no unsetDirty operation here?
     }
     else
     {
@@ -89,6 +91,8 @@ void Record::flush_impl(
                 Parameter<Operation::CREATE_PATH> pCreate;
                 pCreate.path = name;
                 IOHandler()->enqueue(IOTask(this, pCreate));
+
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                 {
                     comp.second.parent() = getWritable(this);
@@ -98,13 +102,13 @@ void Record::flush_impl(
         }
         else
         {
-
             if (scalar())
             {
                 T_RecordComponent::flush(name, flushParams);
             }
             else
             {
+                customHierarchyFlush(flushParams, /* unset_dirty = */ false);
                 for (auto &comp : *this)
                     comp.second.flush(comp.first, flushParams);
             }

src/RecordComponent.cpp

@@ -433,6 +433,9 @@ void RecordComponent::flush(
     }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
+        // TODO maybe guard against custom hierarchies on datasets?
+        // they can be created upon constant components however..
+        customHierarchyFlush(flushParams, /* unset_dirty = */ false);
         while (!rc.m_chunks.empty())
         {
             IOHandler()->enqueue(rc.m_chunks.front());
@@ -552,6 +555,10 @@ void RecordComponent::flush(
             rc.m_chunks.pop();
         }
 
+        // TODO maybe guard against custom hierarchies on datasets?
+        // they can be created upon constant components however..
+        customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+
         flushAttributes(flushParams);
     }
     determineUnsetDirty(flushParams.flushLevel);

src/Series.cpp

@@ -1667,6 +1667,11 @@ void Series::flushGorVBased(
             }
         }
 
+        if (begin == end)
+        {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+        }
+
         // Phase 3
         Parameter<Operation::TOUCH> touch;
         IOHandler()->enqueue(IOTask(&writable(), touch));
@@ -1757,6 +1762,11 @@ void Series::flushGorVBased(
             }
         }
 
+        if (begin == end)
+        {
+            customHierarchyFlush(flushParams, /* unset_dirty = */ false);
+        }
+
         flushAttributes(flushParams);
         Parameter<Operation::TOUCH> touch;
         IOHandler()->enqueue(IOTask(&writable(), touch));

src/backend/Attributable.cpp

@@ -22,6 +22,7 @@
 #include "openPMD/CustomHierarchy.hpp"
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/Access.hpp"
 #include "openPMD/Iteration.hpp"
 #include "openPMD/ParticleSpecies.hpp"
 #include "openPMD/RecordComponent.hpp"
@@ -197,6 +198,11 @@ void Attributable::customHierarchyFlush(
     // customHierarchies().printRecursively();
     if (!dirtyRecursive())
     {
+        if (!unset_dirty)
+        {
+            throw std::runtime_error(
+                "Control flow error: Should be called upon a dirty object.");
+        }
         return;
     }
 
@@ -431,6 +437,10 @@ template void Attributable::seriesFlush_impl<false>(
 
 void Attributable::flushAttributes(internal::FlushParams const &flushParams)
 {
+    if (access::readOnly(IOHandler()->m_frontendAccess))
+    {
+        throw std::runtime_error("Control flow error");
+    }
     if (!flush_level::write_attributes(flushParams.flushLevel))
     {
         return;

src/backend/PatchRecord.cpp

@@ -61,10 +61,10 @@ void PatchRecord::flush_impl(
     }
     if (!this->scalar())
     {
-        if (IOHandler()->m_frontendAccess != Access::READ_ONLY)
-            Container<PatchRecordComponent>::flush(
-                path, flushParams); // warning (clang-tidy-10):
-                                    // bugprone-parent-virtual-call
+        Container<PatchRecordComponent>::flush(
+            path, flushParams); // warning (clang-tidy-10):
+                                // bugprone-parent-virtual-call
+
         for (auto &comp : *this)
             comp.second.flush(comp.first, flushParams);
     }