Avoid using lambdas for require_type

Author: franzpoeschel

include/openPMD/backend/ScientificDefaults_internal.hpp

@@ -68,45 +68,34 @@ struct constructor_tag
 {};
 static constexpr constructor_tag constructor_tag_v = {};
 
-template <typename T, typename Functor>
+template <typename T, typename RecordType>
 struct PostProcessConvertedAttributeImpl : PostProcessConvertedAttribute<T>
 {
-    template <typename T_, typename Functor_>
-    friend auto makePostProcessConvertedAttribute(Functor_ &&fun)
-        -> std::shared_ptr<PostProcessConvertedAttribute<T_>>;
+    RecordType record;
+    using handler_t = std::optional<error::ReadError> (*)(RecordType &, T);
+    handler_t reader;
 
-    template <typename Fun>
-    PostProcessConvertedAttributeImpl(constructor_tag, Fun &&f)
-        : fun{std::forward<Fun>(f)}
+    PostProcessConvertedAttributeImpl(RecordType record_in, handler_t reader_in)
+        : record(std::move(record_in)), reader(reader_in)
     {}
 
-    Functor fun;
     auto operator()(T val) -> std::optional<error::ReadError> override
     {
-        return fun(std::move(val));
+        return (*reader)(record, std::move(val));
     }
 };
 
-// 4, 0.152344
-template <typename T, typename Fun>
-auto makePostProcessConvertedAttribute(Fun &&fun)
+template <typename T, typename RecordType>
+auto makePostProcessConvertedAttribute(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
     -> std::shared_ptr<PostProcessConvertedAttribute<T>>
 {
-    auto functor = [fun_lambda = std::forward<Fun>(fun)](
-                       T val) -> std::optional<error::ReadError> {
-        if constexpr (!std::is_void_v<std::invoke_result<Fun &&, T>>)
-        {
-            std::move(fun_lambda)(std::move(val));
-            return std::nullopt;
-        }
-        else
-        {
-            return std::move(fun_lambda)(std::move(val));
-        }
-    };
-    return std::make_shared<
-        PostProcessConvertedAttributeImpl<T, decltype(functor)>>(
-        constructor_tag_v, std::move(functor));
+    return std::make_shared<PostProcessConvertedAttributeImpl<
+        T,
+        std::remove_reference_t<RecordType>>>(
+        std::forward<RecordType>(record), handler);
 }
 
 template <typename T>
@@ -117,10 +106,13 @@ struct RequireType : ProcessAttribute
 
     explicit RequireType() = default;
 
-    template <typename Functor>
-    RequireType(constructor_tag, Functor &&fun)
-        : postProcess(
-              makePostProcessConvertedAttribute<T>(std::forward<Functor>(fun)))
+    template <typename RecordType>
+    RequireType(
+        RecordType &&record,
+        std::optional<error::ReadError> (*handler)(
+            std::remove_reference_t<RecordType> &, T))
+        : postProcess(makePostProcessConvertedAttribute(
+              std::forward<RecordType>(record), handler))
     {}
 
     auto operator()(Attributable &, char const *, Attribute const &)
@@ -220,8 +212,11 @@ namespace
     extern std::shared_ptr<ProcessAttribute> require_scalar;
     // try converting to vectors (e.g. when a scalar or an array is given)
     extern std::shared_ptr<ProcessAttribute> require_vector;
-    template <typename T, typename Fun>
-    auto require_type(Fun &&) -> std::shared_ptr<ProcessAttribute>;
+    template <typename T, typename RecordType>
+    auto require_type(
+        std::optional<error::ReadError> (*)(
+            std::remove_reference_t<RecordType> &, T))
+        -> std::shared_ptr<ProcessAttribute>;
     // common case: directly use setAttribute
     template <typename T>
     auto require_type() -> std::shared_ptr<ProcessAttribute>;

src/backend/ScientificDefaults.cpp

@@ -61,7 +61,8 @@ namespace
     }
 
     // Helper function to set geometry based on string value
-    inline void setMeshGeometryFromString(Mesh &mesh, std::string val)
+    inline auto setMeshGeometryFromString(Mesh &mesh, std::string val)
+        -> std::optional<error::ReadError>
     {
         if ("cartesian" == val)
             mesh.setGeometry(Mesh::Geometry::cartesian);
@@ -73,6 +74,7 @@ namespace
             mesh.setGeometry(Mesh::Geometry::spherical);
         else
             mesh.setGeometry(std::move(val));
+        return std::nullopt;
     }
 
     // Helper function to set data order based on char value
@@ -506,11 +508,15 @@ namespace
     std::shared_ptr<ProcessAttribute> require_vector =
         std::make_shared<RequireVector>();
 
-    template <typename T, typename Fun>
-    auto require_type(Fun &&fun) -> std::shared_ptr<ProcessAttribute>
+    template <typename T, typename RecordType>
+    auto require_type(
+        RecordType &&record,
+        std::optional<error::ReadError> (*handler)(
+            std::remove_reference_t<RecordType> &, T))
+        -> std::shared_ptr<ProcessAttribute>
     {
         return std::make_shared<RequireType<T>>(
-            constructor_tag_v, std::forward<Fun>(fun));
+            std::forward<RecordType>(record), handler);
     }
 
     template <typename T>
@@ -551,8 +557,6 @@ template <typename Child>
 template <bool write>
 void ScientificDefaults<Child>::defaults_impl(OpenpmdStandard standard)
 {
-    using maybe_read_error = std::optional<error::ReadError>;
-
     auto float_types = get_float_types();
     auto string_types = get_string_types();
 
@@ -597,17 +601,13 @@ void ScientificDefaults<Child>::defaults_impl(OpenpmdStandard standard)
                 Mesh::Geometry::cartesian, &Mesh::setGeometry)
             .withReader(
                 string_types,
-                require_type<std::string>([this](std::string val) {
-                    setMeshGeometryFromString(asChild(), std::move(val));
-                }))(wor);
+                require_type(asChild(), &setMeshGeometryFromString))(wor);
 
         defaultAttribute("dataOrder")
             .template withSetter<Mesh>(Mesh::DataOrder::C, &Mesh::setDataOrder)
             .withReader(
                 string_types,
-                require_type<char>([this](char val) -> maybe_read_error {
-                    return setMeshDataOrderFromChar(asChild(), val);
-                }))(wor);
+                require_type(asChild(), &setMeshDataOrderFromChar))(wor);
 
         defaultAttribute("axisLabels")
             .template withSetter<Mesh, std::vector<std::string> const &>(