Return the tree ID when registering a file

Return the attribute "main_tree_to_execute" or the ID of the single
behavior-tree.

Signed-off-by: Gaël Écorchard <[email protected]>

Author: Gaël Écorchard

include/behaviortree_cpp/bt_factory.h

@@ -19,6 +19,7 @@
 #include <memory>
 #include <unordered_map>
 #include <set>
+#include <string>
 #include <vector>
 
 #include "behaviortree_cpp/contrib/magic_enum.hpp"
@@ -154,6 +155,9 @@ class Tree
   //Call the visitor for each node of the tree.
   void applyVisitor(const std::function<void(TreeNode*)>& visitor);
 
+  /**
+   * @brief Return the next node UID.
+   */
   [[nodiscard]] uint16_t getUID();
 
   /// Get a list of nodes which fullPath() match a wildcard filter and
@@ -290,14 +294,17 @@ class BehaviorTreeFactory
      *
      *    BehaviorTreeFactory::createTree(tree_id)
      *
-     * where "tree_id" come from the XML attribute <BehaviorTree ID="tree_id">
+     * where "tree_id" come from the XML attribute <BehaviorTree ID="tree_id">.
+     *
+     * Return the attribute `main_tree_to_execute` if specified or if the file
+     * defines a single SubTree, or an empty string otherwise.
      *
      */
-  void registerBehaviorTreeFromFile(const std::filesystem::path& filename);
+  std::string registerBehaviorTreeFromFile(const std::filesystem::path& filename);
 
   /// Same of registerBehaviorTreeFromFile, but passing the XML text,
   /// instead of the filename.
-  void registerBehaviorTreeFromText(const std::string& xml_text);
+  std::string registerBehaviorTreeFromText(const std::string& xml_text);
 
   /// Returns the ID of the trees registered either with
   /// registerBehaviorTreeFromFile or registerBehaviorTreeFromText.

include/behaviortree_cpp/bt_parser.h

@@ -13,6 +13,8 @@
 #pragma once
 
 #include <filesystem>
+#include <string>
+
 #include "behaviortree_cpp/bt_factory.h"
 #include "behaviortree_cpp/blackboard.h"
 
@@ -36,10 +38,10 @@ class Parser
   Parser(Parser&& other) = default;
   Parser& operator=(Parser&& other) = default;
 
-  virtual void loadFromFile(const std::filesystem::path& filename,
+  virtual std::string loadFromFile(const std::filesystem::path& filename,
                             bool add_includes = true) = 0;
 
-  virtual void loadFromText(const std::string& xml_text, bool add_includes = true) = 0;
+  virtual std::string loadFromText(const std::string& xml_text, bool add_includes = true) = 0;
 
   virtual std::vector<std::string> registeredBehaviorTrees() const = 0;
 

include/behaviortree_cpp/xml_parsing.h

@@ -4,6 +4,7 @@
 #include "behaviortree_cpp/bt_parser.h"
 
 #include <filesystem>
+#include <string>
 #include <unordered_map>
 
 namespace BT
@@ -26,10 +27,10 @@ class XMLParser : public Parser
   XMLParser(XMLParser&& other) noexcept;
   XMLParser& operator=(XMLParser&& other) noexcept;
 
-  void loadFromFile(const std::filesystem::path& filename,
+  std::string loadFromFile(const std::filesystem::path& filename,
                     bool add_includes = true) override;
 
-  void loadFromText(const std::string& xml_text, bool add_includes = true) override;
+  std::string loadFromText(const std::string& xml_text, bool add_includes = true) override;
 
   [[nodiscard]] std::vector<std::string> registeredBehaviorTrees() const override;
 

src/bt_factory.cpp

@@ -257,15 +257,15 @@ void BehaviorTreeFactory::registerFromROSPlugins()
 }
 #endif
 
-void BehaviorTreeFactory::registerBehaviorTreeFromFile(
+std::string BehaviorTreeFactory::registerBehaviorTreeFromFile(
     const std::filesystem::path& filename)
 {
-  _p->parser->loadFromFile(filename);
+  return _p->parser->loadFromFile(filename);
 }
 
-void BehaviorTreeFactory::registerBehaviorTreeFromText(const std::string& xml_text)
+std::string BehaviorTreeFactory::registerBehaviorTreeFromText(const std::string& xml_text)
 {
-  _p->parser->loadFromText(xml_text);
+  return _p->parser->loadFromText(xml_text);
 }
 
 std::vector<std::string> BehaviorTreeFactory::registeredBehaviorTrees() const

src/xml_parsing.cpp

@@ -107,7 +107,7 @@ struct XMLParser::PImpl
   void getPortsRecursively(const XMLElement* element,
                            std::vector<std::string>& output_ports);
 
-  void loadDocImpl(XMLDocument* doc, bool add_includes);
+  std::string loadDocImpl(XMLDocument* doc, bool add_includes);
 
   std::list<std::unique_ptr<XMLDocument> > opened_documents;
   std::map<std::string, const XMLElement*> tree_roots;
@@ -156,7 +156,7 @@ XMLParser& XMLParser::operator=(XMLParser&& other) noexcept
 XMLParser::~XMLParser()
 {}
 
-void XMLParser::loadFromFile(const std::filesystem::path& filepath, bool add_includes)
+std::string XMLParser::loadFromFile(const std::filesystem::path& filepath, bool add_includes)
 {
   _p->opened_documents.emplace_back(new XMLDocument());
 
@@ -165,17 +165,17 @@ void XMLParser::loadFromFile(const std::filesystem::path& filepath, bool add_inc
 
   _p->current_path = std::filesystem::absolute(filepath.parent_path());
 
-  _p->loadDocImpl(doc, add_includes);
+  return _p->loadDocImpl(doc, add_includes);
 }
 
-void XMLParser::loadFromText(const std::string& xml_text, bool add_includes)
+std::string XMLParser::loadFromText(const std::string& xml_text, bool add_includes)
 {
   _p->opened_documents.emplace_back(new XMLDocument());
 
   XMLDocument* doc = _p->opened_documents.back().get();
   doc->Parse(xml_text.c_str(), xml_text.size());
 
-  _p->loadDocImpl(doc, add_includes);
+  return _p->loadDocImpl(doc, add_includes);
 }
 
 std::vector<std::string> XMLParser::registeredBehaviorTrees() const
@@ -232,7 +232,7 @@ void BT::XMLParser::PImpl::loadSubtreeModel(const XMLElement* xml_root)
   }
 }
 
-void XMLParser::PImpl::loadDocImpl(XMLDocument* doc, bool add_includes)
+std::string XMLParser::PImpl::loadDocImpl(XMLDocument* doc, bool add_includes)
 {
   if(doc->Error())
   {
@@ -348,6 +348,19 @@ void XMLParser::PImpl::loadDocImpl(XMLDocument* doc, bool add_includes)
 
     tree_roots[tree_name] = bt_node;
   }
+
+  // Get the name of the tree to run (either explicit or single tree).
+  std::string main_tree_to_execute;
+  if (const auto main_tree_attribute = xml_root->Attribute("main_tree_to_execute"))
+  {
+    main_tree_to_execute = main_tree_attribute;
+  }
+  else if(xml_root->FirstChild() == xml_root->LastChild())
+  {
+    // special case: there is only one registered BT.
+    main_tree_to_execute = xml_root->FirstChild()->ToElement()->Attribute("ID");
+  }
+  return main_tree_to_execute;
 }
 
 void VerifyXML(const std::string& xml_text,