Compiles

Author: franzpoeschel

include/openPMD/Iteration.hpp

@@ -349,6 +349,8 @@ class Iteration
     void readMeshes(std::string const &meshesPath);
     void readParticles(std::string const &particlesPath);
 
+    void setDefaultAttributes();
+
     /**
      * Status after beginning an IO step. Currently includes:
      * * The advance status (OK, OVER, RANDOMACCESS)
@@ -444,7 +446,6 @@ class Iteration
 
 protected:
     void defaults_impl(bool write, OpenpmdStandard) override;
-    auto as_attributable() -> Attributable & override;
 }; // Iteration
 
 extern template float Iteration::time<float>() const;

include/openPMD/Mesh.hpp

@@ -332,6 +332,9 @@ class Mesh : public BaseRecord<MeshRecordComponent>
     flush_impl(std::string const &, internal::FlushParams const &) override;
     void read();
     auto retrieveDimensionality() const -> uint64_t;
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // Mesh
 
 static_assert(internal::IsContainer_v<Mesh>);

include/openPMD/ParticleSpecies.hpp

@@ -64,6 +64,9 @@ class ParticleSpecies
     {
         return m_containerData;
     }
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 };
 
 namespace traits

include/openPMD/Record.hpp

@@ -57,6 +57,9 @@ class Record : public BaseRecord<RecordComponent>
     flush_impl(std::string const &, internal::FlushParams const &) override;
 
     [[nodiscard]] internal::HomogenizeExtents read();
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // Record
 
 static_assert(internal::HasScientificDefaults_v<Record>);

include/openPMD/RecordComponent.hpp

@@ -550,6 +550,9 @@ OPENPMD_protected
     void verifyChunk(Offset const &, Extent const &) const;
 
     void verifyChunk(Datatype, Offset const &, Extent const &) const;
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // RecordComponent
 
 namespace internal

include/openPMD/backend/BaseRecord.hpp

@@ -382,6 +382,9 @@ class BaseRecord
     flush_impl(std::string const &, internal::FlushParams const &) = 0;
 
     void eraseScalar();
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // BaseRecord
 
 namespace detail

include/openPMD/backend/MeshRecordComponent.hpp

@@ -99,6 +99,9 @@ class MeshRecordComponent : public RecordComponent
     {
         v(*this);
     }
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 };
 
 template <typename T>

include/openPMD/backend/PatchRecordComponent.hpp

@@ -111,6 +111,9 @@ OPENPMD_protected
 
     PatchRecordComponent();
     PatchRecordComponent(NoInit);
+
+protected:
+    void defaults_impl(bool write, OpenpmdStandard) override;
 }; // PatchRecordComponent
 
 template <typename T>

include/openPMD/backend/ScientificDefaults.hpp

@@ -17,14 +17,13 @@ struct ConfigAttribute;
 class ScientificDefaults
 {
 protected:
-    [[nodiscard]] auto defaultAttribute(char const *attrName)
+    [[nodiscard]] auto defaultAttribute(Attributable &, char const *attrName)
         -> ConfigAttribute;
 
     // template <typename Parent, bool write>
     // void addParentDefaults(OpenpmdStandard);
 
-    virtual void defaults_impl(bool write, OpenpmdStandard);
-    virtual auto as_attributable() -> Attributable &;
+    virtual void defaults_impl(bool write, OpenpmdStandard) = 0;
 
 protected:
     // Called upon Iteration::close(), will fill in defaults below Iteration

src/Iteration.cpp

@@ -30,8 +30,10 @@
 #include "openPMD/auxiliary/DerefDynamicCast.hpp"
 #include "openPMD/auxiliary/Filesystem.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/BaseRecordComponent.hpp"
 #include "openPMD/backend/ScientificDefaults.hpp"
 #include "openPMD/backend/ScientificDefaults_impl.hpp"
 #include "openPMD/backend/Variant_internal.hpp"
@@ -44,6 +46,7 @@
 #include <optional>
 #include <stdexcept>
 #include <tuple>
+#include <type_traits>
 #include <variant>
 
 namespace openPMD
@@ -114,7 +117,7 @@ Iteration &Iteration::close(bool _flush)
 
     if (access::write(IOHandler()->m_frontendAccess))
     {
-        writeDefaultsRecursively(IOHandler()->m_standard);
+        setDefaultAttributes();
     }
 
     if (_flush)
@@ -148,6 +151,40 @@ Iteration &Iteration::close(bool _flush)
     return *this;
 }
 
+void Iteration::setDefaultAttributes()
+{
+    auto standard = IOHandler()->m_standard;
+    visitHierarchy([standard](auto &component) {
+        using ComponentType = std::remove_reference_t<decltype(component)>;
+        if constexpr (auxiliary::IsTemplateBaseOf_v<BaseRecord, ComponentType>)
+        {
+            if (component.empty() && !component.datasetDefined())
+            {
+                std::cerr
+                    << "Cannot flush Record without any contained components: '"
+                    << component.myPath().openPMDPath() << "'. Will ignore.";
+                if (component.written())
+                {
+                    std::cerr
+                        << "\n(Note: The Record seems to have been written "
+                           "previously?)";
+                }
+                std::cerr << std::endl;
+                return;
+            }
+        }
+
+        if constexpr (
+            !std::is_same_v<ComponentType, Container<Mesh>> &&
+            !std::is_same_v<ComponentType, Container<Record>> &&
+            !std::is_same_v<ComponentType, Container<PatchRecord>> &&
+            !std::is_same_v<ComponentType, Container<ParticleSpecies>>)
+        {
+            component.writeDefaults(standard);
+        }
+    });
+}
+
 Iteration &Iteration::open()
 {
     Series s = retrieveSeries();
@@ -941,22 +978,17 @@ void Iteration::defaults_impl(bool write, OpenpmdStandard)
     auto float_types = get_float_types();
     auto const wor = write ? WriteOrRead::Write : WriteOrRead::Read;
 
-    defaultAttribute("time")
+    defaultAttribute(*this, "time")
         .template withSetter<Iteration>(0., &Iteration::setTime)
         .withReader(float_types, require_scalar)(wor);
-    defaultAttribute("dt")
+    defaultAttribute(*this, "dt")
         .template withSetter<Iteration>(1., &Iteration::setDt)
         .withReader(float_types, require_scalar)(wor);
-    defaultAttribute("timeUnitSI")
+    defaultAttribute(*this, "timeUnitSI")
         .template withSetter<Iteration>(1.0, &Iteration::setTimeUnitSI)
         .withReader(float_types, require_type<double>())(wor);
 }
 
-auto Iteration::as_attributable() -> Attributable &
-{
-    return *this;
-}
-
 template float Iteration::time<float>() const;
 template double Iteration::time<double>() const;
 template long double Iteration::time<long double>() const;