Implement lambda visitor in terms of explicit visitor

Author: franzpoeschel

include/openPMD/backend/Attributable.hpp

@@ -404,6 +404,10 @@ class Attributable
 
     virtual void visitHierarchy(HierarchyVisitor &);
 
+    // definition inside include/openPMD/backend/HierarchyVisitorImpl.hpp
+    template <typename Lambda>
+    void visitHierarchyFromLambda(Lambda &&lambda);
+
     [[nodiscard]] OpenpmdStandard openPMDStandard() const;
 
     // clang-format off

include/openPMD/backend/HierarchyVisitorImpl.hpp

@@ -5,3 +5,81 @@
 #include "openPMD/Iteration.hpp"
 #include "openPMD/ParticleSpecies.hpp"
 #include "openPMD/Series.hpp"
+#include <type_traits>
+
+namespace openPMD
+{
+template <typename Lambda>
+class HierarchyVisitorFromLambda : public HierarchyVisitor
+{
+    Lambda lambda;
+
+public:
+    template <typename Arg>
+    HierarchyVisitorFromLambda(uint8_t /* constructor_tag */, Arg &&arg)
+        : lambda(std::forward<Arg>(arg))
+    {}
+    void operator()(Iteration &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Iterations &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Mesh &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(MeshRecordComponent &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Meshes &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(ParticlePatches &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(ParticleSpecies &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Particles &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(PatchRecordComponent &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Record &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(RecordComponent &obj) override
+    {
+        lambda(obj);
+    }
+    void operator()(Series &obj) override
+    {
+        lambda(obj);
+    }
+};
+
+template <typename Lambda>
+auto makeHierarchyVisitorFromLambda(Lambda &&lambda)
+{
+    using res_t = HierarchyVisitorFromLambda<std::remove_reference_t<Lambda>>;
+    return res_t{0, std::forward<Lambda>(lambda)};
+}
+
+template <typename Lambda>
+void Attributable::visitHierarchyFromLambda(Lambda &&lambda)
+{
+    auto visitor = makeHierarchyVisitorFromLambda(std::forward<Lambda>(lambda));
+    this->visitHierarchy(visitor);
+}
+} // namespace openPMD

src/Iteration.cpp

@@ -34,6 +34,7 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
+#include "openPMD/backend/HierarchyVisitorImpl.hpp"
 #include "openPMD/backend/Variant_internal.hpp"
 #include "openPMD/backend/Writable.hpp"
 #include "openPMD/backend/scientific_defaults/ConfigAttribute.hpp"
@@ -247,37 +248,36 @@ bool Iteration::closedByWriter() const
 void Iteration::populateDefaultMetadata()
 {
     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);
-    //     }
-    // });
+    visitHierarchyFromLambda([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, Iterations> &&
+            !std::is_same_v<ComponentType, Meshes> &&
+            !std::is_same_v<ComponentType, ParticlePatches> &&
+            !std::is_same_v<ComponentType, Particles> &&
+            !std::is_same_v<ComponentType, Series>)
+        {
+            component.writeDefaults(standard);
+        }
+    });
 }
 
 void Iteration::flushFileBased(