Use match_section if possible

Author: sebproell

src/core/fem/src/condition/4C_fem_condition_definition.cpp

@@ -64,30 +64,27 @@ void Core::Conditions::ConditionDefinition::read(Core::IO::InputFile& input,
       all_of(specs_),
   });
 
-  for (const auto& fragment : input.in_section(section_name()))
+  Core::IO::InputParameterContainer container;
+  try
   {
-    std::optional<Core::IO::InputParameterContainer> data;
-    try
-    {
-      data = fragment.match(condition_spec);
-    }
-    catch (const Core::Exception& e)
-    {
-      FOUR_C_THROW("Failed to match condition specification in section '{}'. The error was:\n{}.",
-          section_name().c_str(), e.what());
-    }
-    if (!data)
-    {
-      FOUR_C_THROW(
-          "Failed to match condition specification in section '{}'.", sectionname_.c_str());
-    }
+    input.match_section(section_name(), container);
+  }
+  catch (const Core::Exception& e)
+  {
+    FOUR_C_THROW("Failed to match condition specification in section '{}'. The error was:\n{}.",
+        section_name(), e.what());
+  }
 
+
+  for (const auto& condition_data :
+      container.get_or<std::vector<Core::IO::InputParameterContainer>>(section_name(), {}))
+  {
     // Read a one-based condition number but convert it to zero-based for internal use.
-    const int dobjid = data->get<int>("E") - 1;
+    const int dobjid = condition_data.get<int>("E") - 1;
 
     std::shared_ptr<Core::Conditions::Condition> condition =
         std::make_shared<Core::Conditions::Condition>(dobjid, condtype_, buildgeometry_, gtype_);
-    condition->parameters() = *std::move(data);
+    condition->parameters() = condition_data;
 
     //------------------------------- put condition in map of conditions
     cmap.insert(std::pair<int, std::shared_ptr<Core::Conditions::Condition>>(dobjid, condition));

src/core/io/src/4C_io_input_file.cpp

@@ -309,6 +309,12 @@ namespace Core::IO
                std::all_of(section_name.begin() + 5, section_name.end(),
                    [](const char c) { return std::isdigit(c); });
       }
+
+      bool is_legacy_section(const std::string& section_name) const
+      {
+        return std::ranges::any_of(
+            legacy_section_names_, [&](const auto& name) { return name == section_name; });
+      }
     };
 
   }  // namespace Internal
@@ -878,6 +884,11 @@ namespace Core::IO
   InputFile::FragmentIteratorRange InputFile::in_section_rank_0_only(
       const std::string& section_name) const
   {
+    FOUR_C_ASSERT_ALWAYS(pimpl_->is_legacy_section(section_name),
+        "You tried to process section '{}' on rank 0 only, but this feature is meant for special "
+        "legacy sections. Please use match_section() instead.",
+        section_name);
+
     if (Core::Communication::my_mpi_rank(pimpl_->comm_) == 0 &&
         pimpl_->content_by_section_.contains(section_name))
     {

src/core/io/src/4C_io_input_parameter_container.hpp

@@ -21,6 +21,7 @@
 #include <map>
 #include <optional>
 #include <ostream>
+#include <ranges>
 #include <string>
 #include <typeindex>
 #include <vector>
@@ -50,6 +51,8 @@ namespace Core::IO
      */
     using List = std::vector<InputParameterContainer>;
 
+    using GroupStorage = std::map<std::string, InputParameterContainer>;
+
     /**
      * \brief Add @data to the container at the given key @name.
      *
@@ -68,6 +71,11 @@ namespace Core::IO
      */
     [[nodiscard]] const InputParameterContainer& group(const std::string& name) const;
 
+    /**
+     * Get a range view of all groups in the container.
+     */
+    [[nodiscard]] auto groups() const;
+
     /**
      * Check if a group with the name @p name exists.
      */
@@ -266,6 +274,11 @@ namespace Core::IO::Internal::InputParameterContainerImplementation
 }  // namespace Core::IO::Internal::InputParameterContainerImplementation
 
 
+inline auto Core::IO::InputParameterContainer::groups() const
+{
+  return std::ranges::subrange(groups_);
+}
+
 
 template <typename T>
 const T& Core::IO::InputParameterContainer::get(const std::string& name) const

src/global_data/4C_global_data_read.cpp

@@ -62,17 +62,20 @@ namespace
 
     {
       std::vector<Core::IO::InputSpec> possible_materials;
+      std::vector<Core::Materials::MaterialType> material_type;
       {
         auto materials = global_legacy_module_callbacks().materials();
         for (auto&& [type, spec] : materials)
         {
           possible_materials.emplace_back(std::move(spec));
+          material_type.push_back(type);
         }
       }
 
       auto all_materials = all_of({
           parameter<int>("MAT"),
-          one_of(possible_materials),
+          one_of(possible_materials,
+              store_index_as<Core::Materials::MaterialType>("_material_type", material_type)),
       });
       section_specs["MATERIALS"] = all_materials;
     }
@@ -1933,57 +1936,37 @@ void Global::read_parameter(Global::Problem& problem, Core::IO::InputFile& input
 /*----------------------------------------------------------------------*/
 void Global::read_materials(Global::Problem& problem, Core::IO::InputFile& input)
 {
-  std::vector<Core::IO::InputSpec> all_specs;
-  std::vector<Core::Materials::MaterialType> all_types;
+  Core::IO::InputParameterContainer container;
+  try
   {
-    auto materials = global_legacy_module_callbacks().materials();
-    for (auto&& [type, spec] : materials)
-    {
-      all_specs.emplace_back(std::move(spec));
-      all_types.push_back(type);
-    }
+    input.match_section("MATERIALS", container);
   }
-
-  // Whenever one of the materials is read, the lambda function will update this index to the
-  // current material index. This lets us access the correct subcontainer for the current material
-  // without searching through all of them.
-  std::size_t current_index = 0;
-
-  using namespace Core::IO::InputSpecBuilders;
-
-  auto all_materials = all_of({
-      parameter<int>(
-          "MAT", {.description = "Material ID that may be used to refer to this material."}),
-      one_of(all_specs, [&current_index](Core::IO::InputParameterContainer& container,
-                            std::size_t index) { current_index = index; }),
-  });
-
-  for (const auto& fragment : input.in_section("MATERIALS"))
+  catch (const Core::Exception& e)
   {
-    auto container = fragment.match(all_materials);
-
-    if (!container.has_value())
-    {
-      std::string l(fragment.get_as_dat_style_string());
-      FOUR_C_THROW("Invalid material specification. Could not parse line:\n  {}", l.c_str());
-    }
+    FOUR_C_THROW(
+        "Failed to match specification in section 'MATERIALS'. The error was:\n{}.", e.what());
+  }
 
-    const int mat_id = container->get<int>("MAT");
+  for (const auto& material_entry :
+      container.get_or<std::vector<Core::IO::InputParameterContainer>>("MATERIALS", {}))
+  {
+    const int mat_id = material_entry.get<int>("MAT");
 
     FOUR_C_ASSERT_ALWAYS(mat_id >= 0, "Material ID must be non-negative. Found: {}", mat_id);
 
     if (problem.materials()->id_exists(mat_id))
       FOUR_C_THROW("More than one material with 'MAT {}'", mat_id);
 
-    const std::string material_name = all_specs[current_index].impl().name();
-    FOUR_C_ASSERT_ALWAYS(container->has_group(material_name),
-        "Material type '{}' does not have a corresponding group in the input file.",
-        material_name.c_str());
+    const auto mat_type = material_entry.get<Core::Materials::MaterialType>("_material_type");
+
+    const auto& group = material_entry.groups();
+    FOUR_C_ASSERT_ALWAYS(
+        group.size() == 1, "Internal error: material must have exactly one group.");
+    const auto& [material_name, material_container] = group.front();
 
     problem.materials()->insert(
         mat_id, Core::Utils::LazyPtr<Core::Mat::PAR::Parameter>(
-                    [mat_id, mat_type = all_types[current_index],
-                        container = container->group(material_name)]()
+                    [mat_id, mat_type, container = material_entry.group(material_name)]()
                     { return Mat::make_parameter(mat_id, mat_type, container); }));
   }
 
@@ -1994,8 +1977,8 @@ void Global::read_materials(Global::Problem& problem, Core::IO::InputFile& input
   // such operations happen in the code base, thus we construct the materials here.
   for (const auto& [id, mat] : problem.materials()->map())
   {
-    // This is the point where the material is actually constructed via the side effect that we try
-    // to access the material.
+    // This is the point where the material is actually constructed via the side effect that we
+    // try to access the material.
     (void)mat.get();
   }
 }