Add optional metadata to TreeNodeManifest

adlarkin · adlarkin · commit 49355fd6405c · 2023-12-21T18:26:44.000-05:00
diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
@@ -10,7 +10,9 @@
 #include <chrono>
 #include <memory>
 #include <string_view>
+#include <utility>
 #include <variant>
+#include <vector>
 #include <optional>
 
 #include "behaviortree_cpp/utils/safe_any.hpp"
@@ -450,6 +452,43 @@ struct has_static_method_description<
 {
 };
 
+/// Optional metadata for a TreeNodeManifest.
+/// The metadata can represent an xml element with text:
+///   <metadata_name>Descriptive text</metadata_name>
+/// Or an xml element with an attribute:
+///   <metadata_name attribute="value"/>
+struct ManifestMetadata
+{
+  /// A pair containing the <name, value> of a metadata's XML attribute.
+  using Attribute = std::pair<std::string, std::string>;
+
+  [[nodiscard]] bool representsText() const
+  {
+    return std::holds_alternative<std::string>(text_or_attribute);
+  }
+
+  [[nodiscard]] bool representsAttribute() const
+  {
+    return std::holds_alternative<Attribute>(text_or_attribute);
+  }
+
+  std::string name;
+  std::variant<std::string, Attribute> text_or_attribute;
+};
+
+template <typename T, typename = void>
+struct has_static_method_metadata : std::false_type
+{
+};
+
+template <typename T>
+struct has_static_method_metadata<
+    T, typename std::enable_if<
+           std::is_same<decltype(T::metadata()), std::vector<ManifestMetadata>>::value>::type>
+  : std::true_type
+{
+};
+
 template <typename T> [[nodiscard]]
 inline PortsList getProvidedPorts(enable_if<has_static_method_providedPorts<T>> = nullptr)
 {
@@ -467,4 +506,3 @@ using TimePoint = std::chrono::high_resolution_clock::time_point;
 using Duration = std::chrono::high_resolution_clock::duration;
 
 }   // namespace BT
-
diff --git a/include/behaviortree_cpp/bt_factory.h b/include/behaviortree_cpp/bt_factory.h
@@ -44,13 +44,20 @@ template <typename T>
 inline TreeNodeManifest CreateManifest(const std::string& ID,
                                        PortsList portlist = getProvidedPorts<T>())
 {
-  if constexpr( has_static_method_description<T>::value)
+  if constexpr( has_static_method_description<T>::value && has_static_method_metadata<T>::value )
   {
-    return {getType<T>(), ID, portlist, T::description()};
+    return {getType<T>(), ID, portlist, T::description(), T::metadata()};
   }
-  else {
-    return {getType<T>(), ID, portlist, {}};
+  else if constexpr( has_static_method_description<T>::value && !has_static_method_metadata<T>::value )
+  {
+    return {getType<T>(), ID, portlist, T::description(), {}};
+  }
+  else if constexpr( !has_static_method_description<T>::value && has_static_method_metadata<T>::value )
+  {
+    return {getType<T>(), ID, portlist, {}, T::metadata()};
   }
+
+  return {getType<T>(), ID, portlist, {}, {}};
 }
 
 #ifdef BT_PLUGIN_EXPORT
diff --git a/include/behaviortree_cpp/tree_node.h b/include/behaviortree_cpp/tree_node.h
@@ -17,6 +17,7 @@
 #include <exception>
 #include <mutex>
 #include <map>
+#include <vector>
 
 #include "behaviortree_cpp/utils/signal.h"
 #include "behaviortree_cpp/basic_types.h"
@@ -39,6 +40,7 @@ struct TreeNodeManifest
   std::string registration_ID;
   PortsList ports;
   std::string description;
+  std::vector<ManifestMetadata> metadata;
 };
 
 using PortsRemapping = std::unordered_map<std::string, std::string>;
diff --git a/src/bt_factory.cpp b/src/bt_factory.cpp
@@ -91,7 +91,7 @@ BehaviorTreeFactory::BehaviorTreeFactory():
   registerNodeType<SwitchNode<4>>("Switch4");
   registerNodeType<SwitchNode<5>>("Switch5");
   registerNodeType<SwitchNode<6>>("Switch6");
-  
+
   registerNodeType<LoopNode<int>>("LoopInt");
   registerNodeType<LoopNode<bool>>("LoopBool");
   registerNodeType<LoopNode<double>>("LoopDouble");
@@ -157,7 +157,7 @@ void BehaviorTreeFactory::registerSimpleCondition(
     return std::make_unique<SimpleConditionNode>(name, tick_functor, config);
   };
 
-  TreeNodeManifest manifest = {NodeType::CONDITION, ID, std::move(ports), {}};
+  TreeNodeManifest manifest = {NodeType::CONDITION, ID, std::move(ports), {}, {}};
   registerBuilder(manifest, builder);
 }
 
@@ -170,7 +170,7 @@ void BehaviorTreeFactory::registerSimpleAction(
     return std::make_unique<SimpleActionNode>(name, tick_functor, config);
   };
 
-  TreeNodeManifest manifest = {NodeType::ACTION, ID, std::move(ports), {}};
+  TreeNodeManifest manifest = {NodeType::ACTION, ID, std::move(ports), {}, {}};
   registerBuilder(manifest, builder);
 }
 
@@ -183,7 +183,7 @@ void BehaviorTreeFactory::registerSimpleDecorator(
     return std::make_unique<SimpleDecoratorNode>(name, tick_functor, config);
   };
 
-  TreeNodeManifest manifest = {NodeType::DECORATOR, ID, std::move(ports), {}};
+  TreeNodeManifest manifest = {NodeType::DECORATOR, ID, std::move(ports), {}, {}};
   registerBuilder(manifest, builder);
 }
 
diff --git a/src/xml_parsing.cpp b/src/xml_parsing.cpp
@@ -83,7 +83,7 @@ struct XMLParser::PImpl
   std::map<std::string, SubtreeModel> subtree_models;
 
   int suffix_count;
-  
+
   explicit PImpl(const BehaviorTreeFactory& fact) :
     factory(fact), current_path(std::filesystem::current_path()), suffix_count(0)
   {}
@@ -989,6 +989,24 @@ void addNodeModelToXML(const TreeNodeManifest& model,
     element->InsertEndChild(description_element);
   }
 
+  for (const auto& metadata : model.metadata)
+  {
+    auto metadata_element = doc.NewElement(metadata.name.c_str());
+
+    if (metadata.representsText())
+    {
+      const auto element_text = std::get<std::string>(metadata.text_or_attribute);
+      metadata_element->SetText(element_text.c_str());
+    }
+    else
+    {
+      const auto [attribute_name, attribute_val] = std::get<ManifestMetadata::Attribute>(metadata.text_or_attribute);
+      metadata_element->SetAttribute(attribute_name.c_str(), attribute_val.c_str());
+    }
+
+    element->InsertEndChild(metadata_element);
+  }
+
   model_root->InsertEndChild(element);
 }
 
@@ -997,7 +1015,7 @@ void addTreeToXML(const Tree& tree,
                   XMLElement* rootXML,
                   bool add_metadata,
                   bool add_builtin_models)
-{  
+{
   std::function<void(const TreeNode&, XMLElement*)> addNode;
   addNode = [&](const TreeNode& node,
                 XMLElement* parent_elem)
diff --git a/tests/gtest_factory.cpp b/tests/gtest_factory.cpp
@@ -1,5 +1,8 @@
 #include <gtest/gtest.h>
 #include <filesystem>
+#include <string>
+#include <utility>
+#include <vector>
 #include "behaviortree_cpp/xml_parsing.h"
 #include "../sample_nodes/crossdoor_nodes.h"
 #include "../sample_nodes/dummy_nodes.h"
@@ -409,7 +412,6 @@ class DescriptiveAction : public SyncActionNode
 
 TEST(BehaviorTreeFactory, DescriptionMethod)
 {
-
   BehaviorTreeFactory factory;
   factory.registerNodeType<DescriptiveAction>("DescriptiveAction");
   const auto& manifest = factory.manifests().at("DescriptiveAction");
@@ -420,3 +422,56 @@ TEST(BehaviorTreeFactory, DescriptionMethod)
 
   ASSERT_NE(xml.find( "<description>THE DESCRIPTION</description>"), std::string::npos);
 }
+
+std::vector<ManifestMetadata> makeTestMetadata()
+{
+  ManifestMetadata text_metadata;
+  text_metadata.name = "text_metadata";
+  text_metadata.text_or_attribute = "text";
+
+  ManifestMetadata attribute_metadata;
+  attribute_metadata.name = "attribute_metadata";
+  attribute_metadata.text_or_attribute = std::make_pair<std::string, std::string>("attribute_name", "attribute_value");
+
+  return {text_metadata, attribute_metadata};
+}
+
+class ActionWithMetadata : public SyncActionNode
+{
+public:
+  ActionWithMetadata(const std::string& name, const NodeConfig& config):
+    SyncActionNode(name, config) {}
+
+  BT::NodeStatus tick() override {
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts() {
+    return {};
+  }
+
+  static std::vector<ManifestMetadata> metadata() {
+    return makeTestMetadata();
+  }
+};
+
+TEST(BehaviorTreeFactory, ManifestMethod)
+{
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<ActionWithMetadata>("ActionWithMetadata");
+  const auto& manifest = factory.manifests().at("ActionWithMetadata");
+  ASSERT_EQ(manifest.metadata.size(), 2u);
+  auto expected_metadata = makeTestMetadata();
+  EXPECT_EQ(manifest.metadata[0].name, expected_metadata[0].name);
+  EXPECT_EQ(manifest.metadata[0].text_or_attribute, expected_metadata[0].text_or_attribute);
+  EXPECT_TRUE(manifest.metadata[0].representsText());
+  EXPECT_EQ(manifest.metadata[1].name, expected_metadata[1].name);
+  EXPECT_EQ(manifest.metadata[1].text_or_attribute, expected_metadata[1].text_or_attribute);
+  EXPECT_TRUE(manifest.metadata[1].representsAttribute());
+
+  auto xml = writeTreeNodesModelXML(factory, false);
+  std::cout << xml << std::endl;
+
+  ASSERT_NE(xml.find("<text_metadata>text</text_metadata>"), std::string::npos);
+  ASSERT_NE(xml.find("<attribute_metadata attribute_name=\"attribute_value\"/>"), std::string::npos);
+}

Original file line number	Diff line number	Diff line change
`@@ -44,13 +44,20 @@ template <typename T>`
`44`	`44`	`inline TreeNodeManifest CreateManifest(const std::string& ID,`
`45`	`45`	`PortsList portlist = getProvidedPorts<T>())`
`46`	`46`	`{`
`47`		`- if constexpr( has_static_method_description<T>::value)`
	`47`	`+ if constexpr( has_static_method_description<T>::value && has_static_method_metadata<T>::value )`
`48`	`48`	`{`
`49`		`- return {getType<T>(), ID, portlist, T::description()};`
	`49`	`+ return {getType<T>(), ID, portlist, T::description(), T::metadata()};`
`50`	`50`	`}`
`51`		`- else {`
`52`		`- return {getType<T>(), ID, portlist, {}};`
	`51`	`+ else if constexpr( has_static_method_description<T>::value && !has_static_method_metadata<T>::value )`
	`52`	`+ {`
	`53`	`+ return {getType<T>(), ID, portlist, T::description(), {}};`
	`54`	`+ }`
	`55`	`+ else if constexpr( !has_static_method_description<T>::value && has_static_method_metadata<T>::value )`
	`56`	`+ {`
	`57`	`+ return {getType<T>(), ID, portlist, {}, T::metadata()};`
`53`	`58`	`}`
	`59`	`+`
	`60`	`+ return {getType<T>(), ID, portlist, {}, {}};`
`54`	`61`	`}`
`55`	`62`
`56`	`63`	`#ifdef BT_PLUGIN_EXPORT`