Cleanup

Author: franzpoeschel

include/openPMD/backend/ScientificDefaults_internal.hpp

@@ -40,30 +40,8 @@ namespace openPMD::internal
 namespace
 {
     template <typename T>
-    auto write_val_to_stderr(T const &val) -> std::ostream &
-    {
-        if constexpr (auxiliary::IsVector_v<T> || auxiliary::IsArray_v<T>)
-        {
-            auxiliary::write_vec_to_stream(std::cerr, val);
-        }
-        else if constexpr (std::is_same_v<T, unit_representations::AsMap>)
-        {
-            std::cerr << "Unit_Map";
-        }
-        else
-        {
-            std::cerr << val;
-        }
-        return std::cerr;
-    }
-    auto write_to_stderr(Attribute const &a) -> std::ostream &
-    {
-        std::visit(
-            [](auto const &val) { write_val_to_stderr(val); },
-            a.getVariant<attribute_types>());
-        return std::cerr;
-    }
-
+    auto write_val_to_stderr(T const &val) -> std::ostream &;
+    auto write_to_stderr(Attribute const &a) -> std::ostream &;
 } // namespace
 
 namespace attribute_read_result
@@ -81,49 +59,24 @@ using AttributeReadResult = std::variant<
     attribute_read_result::TypeUnmatched,
     error::ReadError>;
 
-struct NewAttributeReader
+struct AttributeReader
 {
-    std::deque<Datatype> eligibleDatatypes;
     using process_attribute_type =
         std::function<std::optional<error::ReadError>(
             Attributable &, char const *, Attribute const &)>;
+
+    std::deque<Datatype> eligibleDatatypes;
     std::optional<process_attribute_type> processAttribute;
 
-    NewAttributeReader(
+    AttributeReader(
         std::deque<Datatype> eligibleDatatypes_in,
-        std::optional<process_attribute_type> processAttribute_in)
-        : eligibleDatatypes(std::move(eligibleDatatypes_in))
-        , processAttribute(std::move(processAttribute_in))
-    {}
+        std::optional<process_attribute_type> processAttribute_in);
 
     auto operator()(
         Attributable &record,
         char const *attrName,
         Attribute const &a,
-        std::deque<Datatype> unmatched_so_far) -> AttributeReadResult
-    {
-        if (std::find(
-                eligibleDatatypes.begin(), eligibleDatatypes.end(), a.dtype) ==
-            eligibleDatatypes.end())
-        {
-            auto res = attribute_read_result::TypeUnmatched{
-                std::move(unmatched_so_far)};
-            for (auto dt : this->eligibleDatatypes)
-            {
-                res.expectedDatatypes.push_back(dt);
-            }
-            return res;
-        }
-        if (processAttribute.has_value())
-        {
-            auto maybe_error = (*processAttribute)(record, attrName, a);
-            if (maybe_error.has_value())
-            {
-                return *maybe_error;
-            }
-        }
-        return attribute_read_result::Success{};
-    }
+        std::deque<Datatype> unmatched_so_far) -> AttributeReadResult;
 };
 
 enum class WriteOrRead : std::uint8_t
@@ -140,13 +93,13 @@ struct ConfigAttribute
 {
     Attributable &child;
     char const *attrName;
-    std::function<void(Attributable &)> initDefaultAttribute;
+    std::optional<std::function<void(Attributable &)>> initDefaultAttribute;
     // processed "from left to right"
-    std::deque<NewAttributeReader> attributeReaders;
+    std::deque<AttributeReader> attributeReaders;
+
+    using process_attribute_type = AttributeReader::process_attribute_type;
 
-    ConfigAttribute(Attributable &child_in, char const *attrName_in)
-        : child(child_in), attrName(attrName_in)
-    {}
+    ConfigAttribute(Attributable &child_in, char const *attrName_in);
 
     ConfigAttribute(ConfigAttribute const &) = delete;
     ConfigAttribute(ConfigAttribute &&) = delete;
@@ -161,141 +114,37 @@ struct ConfigAttribute
             std::conditional_t<
                 std::is_void_v<S>,
                 detail::CallResult_t<GetDefaultValue>,
-                S>)) -> ConfigAttribute &
-    {
-        initDefaultAttribute = [getDefaultVal_lambda = std::move(getDefaultVal),
-                                setDefaultVal](Attributable &attr) {
-            RecordType *record = dynamic_cast<RecordType *>(&attr);
-            if (!record)
-            {
-                throw error::Internal("dynamic cast failure");
-            }
-            if constexpr (detail::IsCallable_v<GetDefaultValue>)
-            {
-                ((*record).*setDefaultVal)(getDefaultVal_lambda());
-            }
-            else
-            {
-                ((*record).*setDefaultVal)(std::move(getDefaultVal_lambda));
-            }
-        };
-        return *this;
-    }
+                S>)) -> ConfigAttribute &;
 
     template <typename DefaultValue>
     [[nodiscard]] auto withGenericSetter(DefaultValue &&defaultVal)
-        -> ConfigAttribute &
-    {
-        initDefaultAttribute = [this,
-                                defaultVal_lambda =
-                                    std::forward<DefaultValue &&>(defaultVal)](
-                                   Attributable &attr) {
-            attr.setAttribute(this->attrName, std::move(defaultVal_lambda));
-        };
-        return *this;
-    }
+        -> ConfigAttribute &;
 
     [[nodiscard]] auto withReader(
         std::deque<Datatype> eligibleDatatypes,
-        std::optional<NewAttributeReader::process_attribute_type>
-            processAttribute = std::nullopt) -> ConfigAttribute &
-    {
-        this->attributeReaders.emplace_back(
-            std::move(eligibleDatatypes), std::move(processAttribute));
-        return *this;
-    }
+        std::optional<process_attribute_type> processAttribute = std::nullopt)
+        -> ConfigAttribute &;
 
-    void write()
-    {
-        if (this->child.containsAttribute(this->attrName))
-        {
-            return;
-        }
-        this->initDefaultAttribute(this->child);
-    }
-
-    void read()
-    {
-        if (attributeReaders.empty())
-        {
-            // No readers emplaced for this attribute
-            return;
-        }
-        AttributeReadResult res = attribute_read_result::TypeUnmatched{};
-        Parameter<Operation::READ_ATT> aRead;
-        aRead.name = this->attrName;
-        auto IOHandler = this->child.IOHandler();
-        IOHandler->enqueue(IOTask(&this->child, aRead));
-        try
-        {
-            IOHandler->flush(defaultFlushParams);
-        }
-        catch (error::ReadError const &e)
-        {
-            std::cerr << "Could not read expected attribute '" << this->attrName
-                      << "' in '" << this->child.myPath().openPMDPath()
-                      << ". Will initialize it with a default value. "
-                         "Original error: "
-                      << e.what() << std::endl;
-            this->initDefaultAttribute(this->child);
-            return;
-        }
-
-        Attribute attribute(Attribute::from_any, std::move(*aRead.m_resource));
-        for (auto &attributeReader : attributeReaders)
-        {
+    void write();
+    void read();
+    void operator()(WriteOrRead wor);
+};
 
-            if (auto *not_matched =
-                    std::get_if<attribute_read_result::TypeUnmatched>(&res))
-            {
-                res = attributeReader(
-                    this->child,
-                    this->attrName,
-                    attribute,
-                    std::move(not_matched->expectedDatatypes));
-            }
-            else
-            {
-                break;
-            }
-        }
-        auto dt = attribute.dtype;
-        std::visit(
-            auxiliary::overloaded{
-                [&](attribute_read_result::TypeUnmatched &&type_unmatched) {
-                    std::cerr << "Unexpected type '" << dt
-                              << "' for attribute '" << this->attrName
-                              << "' in '" << this->child.myPath().openPMDPath()
-                              << "' with value '";
-                    write_to_stderr(attribute) << "'. Expected one of ";
-                    auxiliary::write_vec_to_stream(
-                        std::cerr, type_unmatched.expectedDatatypes)
-                        << " or convertible to such a type." << std::endl;
-                },
-                [&](error::ReadError const &err) {
-                    std::cerr << "Unexpected error while trying to read "
-                                 "attribute '"
-                              << this->attrName << "' in '"
-                              << this->child.myPath().openPMDPath()
-                              << "'' with value '";
-                    write_to_stderr(attribute)
-                        << "': " << err.what() << std::endl;
-                },
-                [](attribute_read_result::Success) { /* no-op */ }},
-            std::move(res));
-    }
+// below are some helpers that may be used as processing functions for
+// attributes in withReader()
+namespace
+{ // try converting to scalar values (e.g. when a vector of length 1 is given)
+    extern ConfigAttribute::process_attribute_type require_scalar;
+    // try converting to vectors (e.g. when a scalar or an array is given)
+    extern ConfigAttribute::process_attribute_type require_vector;
+    // F: T -> void
+    template <typename T, typename F>
+    auto require_type(F &&) -> ConfigAttribute::process_attribute_type;
+    // common case: directly use setAttribute
+    template <typename T>
+    auto require_type() -> ConfigAttribute::process_attribute_type;
 
-    void operator()(WriteOrRead wor)
-    {
-        switch (wor)
-        {
-        case WriteOrRead::Write:
-            write();
-            break;
-        case WriteOrRead::Read:
-            read();
-            break;
-        }
-    }
-};
+    auto get_float_types() -> std::deque<Datatype>;
+    auto get_string_types() -> std::deque<Datatype>;
+} // namespace
 } // namespace openPMD::internal