add remove_whitespace when serializing trees

Co-authored-by: Copilot <copilot@github.com>

Author: robin-mueller

auto_apms_behavior_tree_core/include/auto_apms_behavior_tree_core/tree/tree_document.hpp

@@ -983,9 +983,12 @@ class TreeDocument : private tinyxml2::XMLDocument
      *
      * In contrast to TreeDocument::writeToString, the resulting XML contains the tree element as its root element,
      * emphasizing the fact that this function returns an XML for a single behavior tree only.
+     * @param remove_whitespace If `true`, insignificant whitespace (indentation and newlines between elements) is
+     * omitted from the output, producing a compact single-line representation. If `false` (default), the output is
+     * pretty-printed with standard indentation.
      * @return String representing the behavior tree in XML format.
      */
-    std::string writeToString() const;
+    std::string writeToString(bool remove_whitespace = false) const;
 
     /**
      * This function is an exact reimplementation of NodeElement::removeFirstChild(const std::string &, const
@@ -1482,15 +1485,22 @@ class TreeDocument : private tinyxml2::XMLDocument
 
   /**
    * @brief Write the XML of this tree document to a string.
+   *
+   * @param remove_whitespace If `true`, insignificant whitespace (indentation and newlines between elements) is
+   * omitted from the output, producing a compact single-line representation.
    * @return String representing this document in XML format.
    */
-  std::string writeToString() const;
+  std::string writeToString(bool remove_whitespace = false) const;
 
   /**
    * @brief Write the XML of this tree document to a file.
+   *
    * @param path Path to the output file.
+   * @param remove_whitespace If `true`, insignificant whitespace (indentation and newlines between elements) is
+   * omitted from the output, producing a compact single-line file. If `false` (default), the file is
+   * pretty-printed with standard indentation.
    */
-  void writeToFile(const std::string & path) const;
+  void writeToFile(const std::string & path, bool remove_whitespace = false) const;
 
   /**
    * @brief Clear this document and reset it to its initial state.

auto_apms_behavior_tree_core/src/tree/tree_document.cpp

@@ -15,6 +15,7 @@
 #include "auto_apms_behavior_tree_core/tree/tree_document.hpp"
 
 #include <algorithm>
+#include <cstdio>
 #include <filesystem>
 
 #include "ament_index_cpp/get_package_share_directory.hpp"
@@ -645,11 +646,11 @@ BT::Result TreeDocument::TreeElement::verify() const
   return doc.mergeTree(*this, true).verify();
 }
 
-std::string TreeDocument::TreeElement::writeToString() const
+std::string TreeDocument::TreeElement::writeToString(bool remove_whitespace) const
 {
   XMLDocument tree_doc;
   tree_doc.InsertEndChild(ele_ptr_->DeepClone(&tree_doc));
-  tinyxml2::XMLPrinter printer;
+  tinyxml2::XMLPrinter printer(nullptr, remove_whitespace);
   tree_doc.Print(&printer);
   return printer.CStr();
 }
@@ -1422,21 +1423,24 @@ BT::Result TreeDocument::verify() const
   return {};
 }
 
-std::string TreeDocument::writeToString() const
+std::string TreeDocument::writeToString(bool remove_whitespace) const
 {
-  tinyxml2::XMLPrinter printer;
+  tinyxml2::XMLPrinter printer(nullptr, remove_whitespace);
   Print(&printer);
   return printer.CStr();
 }
 
-void TreeDocument::writeToFile(const std::string & path) const
+void TreeDocument::writeToFile(const std::string & path, bool remove_whitespace) const
 {
-  XMLDocument doc;
-  DeepCopy(&doc);
-  tinyxml2::XMLError result = doc.SaveFile(path.c_str());
-  if (result != tinyxml2::XML_SUCCESS) {
-    throw exceptions::TreeDocumentError(
-      "Failed to write tree document to file. Error ID: " + std::string(doc.ErrorIDToName(result)));
+  const std::string xml = writeToString(remove_whitespace);
+  FILE * f = std::fopen(path.c_str(), "w");
+  if (!f) {
+    throw exceptions::TreeDocumentError("Failed to open file for writing: " + path);
+  }
+  const std::size_t written = std::fwrite(xml.data(), 1, xml.size(), f);
+  const int close_err = std::fclose(f);
+  if (written != xml.size() || close_err != 0) {
+    throw exceptions::TreeDocumentError("Failed to write tree document to file: " + path);
   }
 }
 

auto_apms_behavior_tree_core/test/unit/tree_document_tree_generation.cpp

@@ -14,6 +14,9 @@
 
 #include <gtest/gtest.h>
 
+#include <cstdlib>
+#include <fstream>
+
 #include "auto_apms_behavior_tree_core/exceptions.hpp"
 #include "auto_apms_behavior_tree_core/node/node_model_type.hpp"
 #include "testable_tree_document.hpp"
@@ -572,6 +575,83 @@ TEST_F(TreeDocumentTreeGenerationTest, WriteToStringWithTrees)
   EXPECT_TRUE(xml.find("BehaviorTree") != std::string::npos);
 }
 
+TEST_F(TreeDocumentTreeGenerationTest, WriteToStringRemoveWhitespaceContainsNoNewlines)
+{
+  doc_->newTree("TestTree");
+
+  std::string xml = doc_->writeToString(true);
+
+  EXPECT_TRUE(xml.find('\n') == std::string::npos);
+  EXPECT_TRUE(xml.find("TestTree") != std::string::npos);
+}
+
+TEST_F(TreeDocumentTreeGenerationTest, WriteToStringRemoveWhitespaceShorterThanPrettyPrinted)
+{
+  doc_->newTree("TestTree");
+
+  EXPECT_LT(doc_->writeToString(true).size(), doc_->writeToString(false).size());
+}
+
+TEST_F(TreeDocumentTreeGenerationTest, WriteToStringRemoveWhitespaceRoundTrips)
+{
+  // A document serialized without whitespace must still be parseable.
+  doc_->newTree("TestTree").makeRoot().insertNode("Sequence");
+
+  const std::string compact = doc_->writeToString(true);
+
+  TreeDocument round_trip;
+  EXPECT_NO_THROW(round_trip.mergeString(compact));
+  EXPECT_TRUE(round_trip.hasTreeName("TestTree"));
+}
+
+TEST_F(TreeDocumentTreeGenerationTest, TreeElementWriteToStringRemoveWhitespaceContainsNoNewlines)
+{
+  auto tree = doc_->newTree("TestTree");
+
+  std::string xml = tree.writeToString(true);
+
+  EXPECT_TRUE(xml.find('\n') == std::string::npos);
+  EXPECT_TRUE(xml.find("TestTree") != std::string::npos);
+}
+
+TEST_F(TreeDocumentTreeGenerationTest, TreeElementWriteToStringRemoveWhitespaceShorterThanPrettyPrinted)
+{
+  auto tree = doc_->newTree("TestTree");
+
+  EXPECT_LT(tree.writeToString(true).size(), tree.writeToString(false).size());
+}
+
+TEST_F(TreeDocumentTreeGenerationTest, WriteToFileRemoveWhitespaceParseable)
+{
+  doc_->newTree("TestTree").makeRoot().insertNode("Sequence");
+
+  const std::string path =
+    std::string(std::getenv("TEST_TMPDIR") ? std::getenv("TEST_TMPDIR") : "/tmp") + "/tree_doc_compact.xml";
+  ASSERT_NO_THROW(doc_->writeToFile(path, true));
+
+  TreeDocument loaded;
+  ASSERT_NO_THROW(loaded.mergeFile(path));
+  EXPECT_TRUE(loaded.hasTreeName("TestTree"));
+
+  // File must contain no newlines (compact format).
+  std::ifstream f(path);
+  std::string content((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+  EXPECT_TRUE(content.find('\n') == std::string::npos);
+}
+
+TEST_F(TreeDocumentTreeGenerationTest, WriteToFilePrettyPrintedContainsNewlines)
+{
+  doc_->newTree("TestTree").makeRoot().insertNode("Sequence");
+
+  const std::string path =
+    std::string(std::getenv("TEST_TMPDIR") ? std::getenv("TEST_TMPDIR") : "/tmp") + "/tree_doc_pretty.xml";
+  ASSERT_NO_THROW(doc_->writeToFile(path, false));
+
+  std::ifstream f(path);
+  std::string content((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+  EXPECT_TRUE(content.find('\n') != std::string::npos);
+}
+
 // =============================================================================
 // verify Tests
 // =============================================================================