WIP Make the default specification more flexible

prep for reading

Author: franzpoeschel

include/openPMD/backend/ScientificDefaults.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "openPMD/IO/Access.hpp"
+#include <iostream>
 #include <type_traits>
 
 namespace openPMD::detail
@@ -27,6 +28,95 @@ using CallResult_t = typename IsCallable<F>::type;
 
 namespace openPMD::internal
 {
+template <typename, typename, typename>
+struct ConfigAttributeWithSetter;
+
+template <typename Child, typename GetDefaultValue>
+struct ConfigAttribute
+{
+    using DefaultValue = detail::CallResult_t<GetDefaultValue>;
+    template <typename S>
+    using SetterType = Child &(
+        Child::
+            *)(std::conditional_t<
+               std::is_void_v<S>,
+               std::remove_reference_t<detail::CallResult_t<GetDefaultValue>>,
+               S>);
+
+    Child &child;
+    char const *attrName;
+    GetDefaultValue &&getDefaultValue;
+
+    ConfigAttribute(
+        Child &child_in,
+        char const *attrName_in,
+        GetDefaultValue &&getDefaultValue_in)
+        : child(child_in)
+        , attrName(attrName_in)
+        , getDefaultValue(std::forward<GetDefaultValue>(getDefaultValue_in))
+    {}
+
+    ConfigAttribute(ConfigAttribute const &) = delete;
+    ConfigAttribute(ConfigAttribute &&) = default;
+
+    ConfigAttribute &operator=(ConfigAttribute const &) = delete;
+    ConfigAttribute &operator=(ConfigAttribute &&) = default;
+
+    template <typename S = void>
+    auto withSetter(SetterType<S>)
+        && -> ConfigAttributeWithSetter<Child, GetDefaultValue, SetterType<S>>;
+
+    ~ConfigAttribute()
+    {
+        run();
+    }
+
+    void run()
+    {
+        if (child.containsAttribute(attrName))
+        {
+            return;
+        }
+        set(get());
+    }
+
+    virtual void set(DefaultValue &&val)
+    {
+        std::cout << "USING PARENT SETTER" << std::endl;
+        child.setAttribute(attrName, std::forward<DefaultValue>(val));
+    }
+
+    auto get() -> DefaultValue
+    {
+        if constexpr (detail::IsCallable_v<GetDefaultValue>)
+        {
+            return std::forward<GetDefaultValue>(getDefaultValue)();
+        }
+        else
+        {
+            return std::forward<GetDefaultValue>(getDefaultValue);
+        }
+    }
+};
+
+template <typename Child, typename GetDefaultValue, typename SetDefaultValue>
+struct ConfigAttributeWithSetter : ConfigAttribute<Child, GetDefaultValue>
+{
+    using parent_t = ConfigAttribute<Child, GetDefaultValue>;
+    using DefaultValue = typename parent_t::DefaultValue;
+
+    ConfigAttributeWithSetter(parent_t &&par, SetDefaultValue setter_in)
+        : parent_t(std::move(par)), setter(setter_in)
+    {}
+
+    SetDefaultValue setter;
+    void set(DefaultValue &&val) override
+    {
+        std::cout << "USING CUSTOM SETTER" << std::endl;
+        (this->child.*setter)(std::forward<DefaultValue>(val));
+    }
+};
+
 template <typename Child> // CRT
 class ScientificDefaults
 {
@@ -37,6 +127,17 @@ class ScientificDefaults
     template <typename F>
     using setter_t = Child &(Child::*)();
 
+    template <typename GetDefaultValue>
+    auto
+    defaultAttribute(char const *attrName, GetDefaultValue &&getDefaultValue)
+        -> ConfigAttribute<Child, GetDefaultValue>
+    {
+        return ConfigAttribute{
+            asChild(),
+            attrName,
+            std::forward<GetDefaultValue>(getDefaultValue)};
+    }
+
     template <typename Setter = void, typename V>
     void addDefaultFor_worker(char const *key, V &&value, Setter &&setter);
 

src/backend/ScientificDefaults.cpp

@@ -18,6 +18,15 @@
 
 namespace openPMD::internal
 {
+template <typename Child, typename GetDefaultValue>
+template <typename S>
+auto ConfigAttribute<Child, GetDefaultValue>::withSetter(SetterType<S> setter)
+    && -> ConfigAttributeWithSetter<Child, GetDefaultValue, SetterType<S>>
+{
+    return ConfigAttributeWithSetter<Child, GetDefaultValue, SetterType<S>>{
+        std::move(*this), setter};
+}
+
 template <typename Child>
 auto ScientificDefaults<Child>::asChild() -> Child &
 {
@@ -189,7 +198,7 @@ void ScientificDefaults<Child>::addDefaults()
 
     if constexpr (std::is_same_v<Child, Iteration>)
     {
-        addDefaultFor("time", 0., &Iteration::setTime);
+        defaultAttribute("time", 0.).withSetter(&Iteration::setTime);
         addDefaultFor("dt", 1., &Iteration::setDt);
         addDefaultFor("timeUnitSI", 1.0, &Iteration::setTimeUnitSI);
     }
@@ -248,7 +257,7 @@ void ScientificDefaults<Child>::addDefaults()
                 }
             },
             &Mesh::setGridSpacing);
-        addDefaultFor<std::vector<double> const &>(
+        defaultAttribute(
             "gridGlobalOffset",
             [&]() {
                 if (dimensionality < 100)
@@ -259,8 +268,9 @@ void ScientificDefaults<Child>::addDefaults()
                 {
                     return std::vector<double>{0.0};
                 }
-            },
-            &Mesh::setGridGlobalOffset);
+            })
+            .template withSetter<std::vector<double> const &>(
+                &Mesh::setGridGlobalOffset);
 
         addParentDefaults<BaseRecord<MeshRecordComponent>>();
     }