Remove unnecessary code paths in InputFile

Author: sebproell

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

@@ -95,11 +95,6 @@ namespace Core::IO
       {
         //! Node in the tree of the associated InputFileImpl.
         ryml::NodeRef node;
-
-        //! String representation of the section in the .dat format. This is intended as a buffer
-        //! to store the content if it should be requested via `get_as_dat_style_string()`. Do not
-        //! assume this to contain a particular content.
-        std::string dat_style_string{};
       };
 
       //! Content of the section is either in the .dat format or in the yaml format.
@@ -573,55 +568,8 @@ namespace Core::IO
       }
       else
       {
-        // flatten the yaml node into a string
-        std::ostringstream ss;
-        ss << node;
-        // replace all the yaml markup characters with spaces to receive a dat-style string
-        auto& str = pimpl_->section->as_yaml().dat_style_string;
-        str = ss.str();
-        std::replace(str.begin(), str.end(), '\n', ' ');
-        std::replace(str.begin(), str.end(), ':', ' ');
-        std::replace(str.begin(), str.end(), ',', ' ');
-        std::replace(str.begin(), str.end(), '[', ' ');
-        std::replace(str.begin(), str.end(), ']', ' ');
-        str = Core::Utils::trim(str);
-
-        return std::string_view(str);
-      }
-    }
-  }
-
-
-  std::optional<InputParameterContainer> InputFile::Fragment::match(const InputSpec& spec) const
-  {
-    FOUR_C_ASSERT(pimpl_, "Implementation error: fragment is not initialized.");
-
-    if (std::holds_alternative<std::string_view>(pimpl_->fragment))
-    {
-      Core::IO::ValueParser parser{get_as_dat_style_string(),
-          {.base_path = std::filesystem::path(pimpl_->section->file).parent_path()}};
-      InputParameterContainer container;
-      spec.fully_parse(parser, container);
-      return container;
-    }
-    else
-    {
-      const auto node = std::get<ryml::ConstNodeRef>(pimpl_->fragment);
-      // We need to check whether the node contains structured yaml or just a dat-style string.
-      if (node.is_val())
-      {
-        std::string_view dat_style_string{node.val().data(), node.val().size()};
-        Core::IO::ValueParser parser{dat_style_string,
-            {.base_path = std::filesystem::path(pimpl_->section->file).parent_path()}};
-        InputParameterContainer container;
-        spec.fully_parse(parser, container);
-        return container;
-      }
-      else
-      {
-        InputParameterContainer container;
-        spec.match(ConstYamlNodeRef(node, pimpl_->section->file), container);
-        return container;
+        FOUR_C_THROW(
+            "Yaml node does not contain a string. This legacy function is only meant for strings.");
       }
     }
   }

src/core/io/src/4C_io_input_file.hpp

@@ -115,13 +115,6 @@ namespace Core::IO
        */
       [[nodiscard]] std::string_view get_as_dat_style_string() const;
 
-      /**
-       * Match the fragment against a given InputSpec @p spec. If the fragment does not match the
-       * spec, an empty optional is returned. If the fragment matches the spec, an
-       * InputParameterContainer with the parsed content is returned.
-       */
-      [[nodiscard]] std::optional<InputParameterContainer> match(const InputSpec& spec) const;
-
       /**
        * A raw pointer to implementation details. This pointer will be valid as long as the
        * associated InputFile object is alive.

src/core/io/tests/4C_io_input_file_test.cpp

@@ -135,37 +135,42 @@ namespace
         TESTING::get_support_file_path("test_files/yaml_includes/main.yaml");
 
     MPI_Comm comm(MPI_COMM_WORLD);
-    Core::IO::InputFile input{{{"INCLUDED SECTION 2", all_of({
-                                                          parameter<int>("a"),
-                                                          parameter<double>("b"),
-                                                          parameter<bool>("c"),
-                                                      })}},
+    Core::IO::InputFile input(
+        {{"INCLUDED SECTION 2", all_of({
+                                    parameter<int>("a"),
+                                    parameter<double>("b"),
+                                    parameter<bool>("c"),
+                                })},
+            {"SECTION WITH SUBSTRUCTURE", list("SECTION WITH SUBSTRUCTURE",
+                                              all_of({
+                                                  parameter<int>("MAT"),
+                                                  group("THERMO",
+                                                      {
+                                                          parameter<std::vector<double>>("COND"),
+                                                          parameter<double>("CAPA"),
+                                                      }),
+                                              }))}},
         {
             "MAIN SECTION",
             "INCLUDED SECTION 1",
             "INCLUDED SECTION 3",
-            "SECTION WITH SUBSTRUCTURE",
         },
-        comm};
+        comm);
     input.read(input_file_name);
 
     check_section_rank_0_only(input, "INCLUDED SECTION 1", std::vector<std::string>(2, "line"));
-    check_section_rank_0_only(
-        input, "SECTION WITH SUBSTRUCTURE", {"MAT 1 THERMO COND 1 2 3 CAPA 2"});
 
     EXPECT_EQ(input.file_for_section("INCLUDED SECTION 2").filename(), "included.yaml");
 
-    auto spec = Core::IO::InputSpecBuilders::all_of({
-        Core::IO::InputSpecBuilders::parameter<int>("a"),
-        Core::IO::InputSpecBuilders::parameter<double>("b"),
-        Core::IO::InputSpecBuilders::parameter<bool>("c"),
-    });
-
     Core::IO::InputParameterContainer container;
     input.match_section("INCLUDED SECTION 2", container);
     EXPECT_EQ(container.get<int>("a"), 1);
     EXPECT_EQ(container.get<double>("b"), 2.0);
     EXPECT_EQ(container.get<bool>("c"), true);
+
+    container.clear();
+    input.match_section("SECTION WITH SUBSTRUCTURE", container);
+    EXPECT_EQ(container.get_list("SECTION WITH SUBSTRUCTURE")[0].get<int>("MAT"), 1);
   }
 
 }  // namespace