Remove InputFile::in_section from public interface

Author: sebproell

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

@@ -315,6 +315,20 @@ namespace Core::IO
         return std::ranges::any_of(
             legacy_section_names_, [&](const auto& name) { return name == section_name; });
       }
+
+      InputFile::FragmentIteratorRange in_section(const std::string& section_name) const
+      {
+        static const std::vector<InputFile::Fragment> empty;
+
+        if (!content_by_section_.contains(section_name))
+        {
+          return std::views::all(empty);
+        }
+
+        // Take a const reference to the section content to match the return type.
+        const auto& lines = content_by_section_.at(section_name).fragments;
+        return std::views::all(lines);
+      }
     };
 
   }  // namespace Internal
@@ -830,44 +844,6 @@ namespace Core::IO
     }
   }
 
-  InputFile::FragmentIteratorRange InputFile::in_section(const std::string& section_name) const
-  {
-    static const std::vector<Fragment> empty;
-
-    // Early return in case the section does not exist at all.
-    const bool known_somewhere = has_section(section_name);
-    if (!known_somewhere)
-    {
-      return std::views::all(empty);
-    }
-
-    const bool locally_known = pimpl_->content_by_section_.contains(section_name);
-    const bool known_everywhere = Core::Communication::all_reduce<bool>(
-        locally_known, [](const bool& r, const bool& in) { return r && in; }, pimpl_->comm_);
-
-    if (known_everywhere)
-    {
-      // Take a const reference to the section content to match the return type.
-      const auto& lines = pimpl_->content_by_section_.at(section_name).fragments;
-      return std::views::all(lines);
-    }
-    else
-    // Distribute the content of the section to all ranks.
-    {
-      FOUR_C_ASSERT((!locally_known && (Core::Communication::my_mpi_rank(pimpl_->comm_) > 0)) ||
-                        (locally_known && (Core::Communication::my_mpi_rank(pimpl_->comm_) == 0)),
-          "Implementation error: section should be known on rank 0 and unknown on others.");
-
-      auto& content = pimpl_->content_by_section_[section_name];
-      Core::Communication::broadcast(content, 0, pimpl_->comm_);
-      content.set_up_fragments();
-
-      const auto& lines = pimpl_->content_by_section_.at(section_name).fragments;
-      return std::views::all(lines);
-    }
-  }
-
-
 
   InputFile::FragmentIteratorRange InputFile::in_section_rank_0_only(
       const std::string& section_name) const
@@ -951,7 +927,7 @@ namespace Core::IO
       if (list_spec)
       {
         std::vector<InputParameterContainer> list_entries;
-        for (const auto& line : in_section(section_name))
+        for (const auto& line : pimpl_->in_section(section_name))
         {
           Core::IO::ValueParser parser{line.get_as_dat_style_string(),
               {.user_scope_message =
@@ -976,7 +952,7 @@ namespace Core::IO
         // Create a group in the dat file format by starting with the section name.
         std::stringstream flattened_dat;
         flattened_dat << std::quoted(section_name) << " ";
-        for (const auto& line : in_section(section_name))
+        for (const auto& line : pimpl_->in_section(section_name))
         {
           std::string line_str(line.get_as_dat_style_string());
           // Split the line into key-value according to the dat file format. Quote keys and values
@@ -1083,7 +1059,7 @@ namespace Core::IO
         auto section = tree.rootref().append_child();
         section << ryml::key(section_name);
         section |= ryml::SEQ;
-        for (const auto& line : in_section(section_name))
+        for (const auto& line : pimpl_->in_section(section_name))
         {
           section.append_child() = ryml::csubstr(
               line.get_as_dat_style_string().data(), line.get_as_dat_style_string().size());

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

@@ -40,19 +40,16 @@ namespace Core::IO
    * This class encapsulates input files independent of their format.
    *
    * Objects of this class read the content of a file and grant access to it. The input is not
-   * yet interpreted in any way. Input files contain different sections. A section either contains
-   * key-value pairs or a list of arbitrary lines of text. The content is accessed via the
-   * in_section() function which return InputFile::Fragment objects. These hide what exactly is
-   * contained and in which format. The content can be matched against an expected InputSpec to
-   * extract meaningful data.
+   * yet interpreted in any way. Input files contain different sections. The content can be matched
+   * against an expected InputSpec via match_section() to extract meaningful data.
    *
    * Sections may appear in an arbitrary order and each section name must be unique. An exception is
    * the special section named "INCLUDES" which can contain a list of other files that should be
    * read in addition to the current file.
    *
    * Three file formats are supported: the custom .dat file format and the standard .yaml (or .yml)
    * and .json formats. The format of a file is detected based on its ending. If the ending is not
-   * one of the above mentioned, the file is assumed to be in the .dat format.
+   * one of the above-mentioned, the file is assumed to be in the .dat format.
    * Included files do not have to use the same format as the including file.
    *
    * The following example shows the structure of a .dat file:
@@ -86,6 +83,7 @@ namespace Core::IO
    * SECTION2:
    *   - A line with content that is not a key-value pair.
    *   - It can contain anything.
+   *   - We call these unstructured sections "legacy sections".
    * @endcode
    *
    *
@@ -213,31 +211,10 @@ namespace Core::IO
      */
     [[nodiscard]] std::filesystem::path file_for_section(const std::string& section_name) const;
 
-    /**
-     * Get a range of Fragments inside a section. A Fragment always contains meaningful content,
-     * i.e., something other than whitespace or comments. The usual way to interact with the
-     * Fragments is as follows:
-     *
-     * @code
-     *   for (const auto& input_fragment : input.in_section("section_name"))
-     *   {
-     *      auto parameters = fragment.match(spec);
-     *   }
-     * @endcode
-     *
-     * @return A range of Fragments which encapsulate the content of the section. Use the
-     * Fragment::match() function to extract the content.
-     *
-     * @note This is a collective call that needs to be called on all MPI ranks in the
-     * communicator associated with this object. Depending on the section size, the content
-     * might need to be distributed from rank 0 to all other ranks. This happens automatically.
-     */
-    FragmentIteratorRange in_section(const std::string& section_name) const;
 
     /**
-     * This function is similar to in_section(), but it only returns the lines on rank 0 and
-     * returns an empty range on all other ranks. This is useful for sections that might be huge
-     * and are not processed on all ranks.
+     * Returns the lines in a section on rank 0 and returns an empty range on all other ranks. This
+     * only works for legacy sections.
      */
     FragmentIteratorRange in_section_rank_0_only(const std::string& section_name) const;
 
@@ -247,7 +224,7 @@ namespace Core::IO
      * that you do not need to pass an InputSpec to this function, since the InputFile object
      * already knows about the expected format of the section. Nevertheless, this function only
      * makes sense for sections with a known InputSpec. Legacy string sections cannot use this
-     * function and must be processed with in_section() or in_section_rank_0_only().
+     * function and must be processed with in_section_rank_0_only().
      */
     void match_section(const std::string& section_name, InputParameterContainer& container) const;
 

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

@@ -21,12 +21,12 @@ namespace
 {
   using namespace FourC;
 
-  void check_section(
+  void check_section_rank_0_only(
       Core::IO::InputFile& input, const std::string& section, const std::vector<std::string>& lines)
   {
     SCOPED_TRACE("Checking section " + section);
     ASSERT_TRUE(input.has_section(section));
-    auto section_lines = input.in_section(section);
+    auto section_lines = input.in_section_rank_0_only(section);
     std::vector<std::string> section_lines_str;
     std::ranges::copy(section_lines | std::views::transform([](const auto& line)
                                           { return std::string{line.get_as_dat_style_string()}; }),
@@ -57,10 +57,12 @@ namespace
     EXPECT_TRUE(input.has_section("EMPTY"));
     EXPECT_FALSE(input.has_section("NONEXISTENT SECTION"));
 
-    check_section(input, "SECTION WITH SPACES", {"line in section with spaces"});
-    check_section(input, "SECTION/WITH/SLASHES", {"line in section with slashes"});
-    check_section(input, "SHORT SECTION", std::vector<std::string>(3, "line in short section"));
-    check_section(input, "PARTICLES", std::vector<std::string>(30, "line in long section"));
+    check_section_rank_0_only(input, "SECTION WITH SPACES", {"line in section with spaces"});
+    check_section_rank_0_only(input, "SECTION/WITH/SLASHES", {"line in section with slashes"});
+    check_section_rank_0_only(
+        input, "SHORT SECTION", std::vector<std::string>(3, "line in short section"));
+    check_section_rank_0_only(
+        input, "PARTICLES", std::vector<std::string>(30, "line in long section"));
   }
 
   TEST(InputFile, HasIncludes)
@@ -86,11 +88,11 @@ namespace
     EXPECT_EQ(input.file_for_section("INCLUDED SECTION 1a").filename(), "include1a.dat");
     EXPECT_EQ(input.file_for_section("SECTION 1").filename(), "main.dat");
 
-    check_section(input, "INCLUDED SECTION 1a", std::vector<std::string>(2, "line"));
-    check_section(input, "INCLUDED SECTION 1b", std::vector<std::string>(2, "line"));
-    check_section(input, "INCLUDED SECTION 2", std::vector<std::string>(2, "line"));
-    check_section(input, "INCLUDED SECTION 3", std::vector<std::string>(2, "line"));
-    check_section(input, "PARTICLES", std::vector<std::string>(5, "line"));
+    check_section_rank_0_only(input, "INCLUDED SECTION 1a", std::vector<std::string>(2, "line"));
+    check_section_rank_0_only(input, "INCLUDED SECTION 1b", std::vector<std::string>(2, "line"));
+    check_section_rank_0_only(input, "INCLUDED SECTION 2", std::vector<std::string>(2, "line"));
+    check_section_rank_0_only(input, "INCLUDED SECTION 3", std::vector<std::string>(2, "line"));
+    check_section_rank_0_only(input, "PARTICLES", std::vector<std::string>(5, "line"));
   }
 
   TEST(InputFile, CyclicIncludes)
@@ -122,7 +124,8 @@ namespace
     EXPECT_FALSE(input.has_section("EMPTY"));
     EXPECT_FALSE(input.has_section("NONEXISTENT SECTION"));
 
-    check_section(input, "SECTION WITH LINES", {"first line", "second line", "third line"});
+    check_section_rank_0_only(
+        input, "SECTION WITH LINES", {"first line", "second line", "third line"});
   }
 
   TEST(InputFile, YamlIncludes)
@@ -146,8 +149,9 @@ namespace
         comm};
     input.read(input_file_name);
 
-    check_section(input, "INCLUDED SECTION 1", std::vector<std::string>(2, "line"));
-    check_section(input, "SECTION WITH SUBSTRUCTURE", {"MAT 1 THERMO COND 1 2 3 CAPA 2"});
+    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");