Test and fix issue #653: AnyTypeAllowed by default

Author: facontidavide

include/behaviortree_cpp/actions/set_blackboard_node.h

@@ -38,11 +38,9 @@ class SetBlackboard : public SyncActionNode
 
   static PortsList providedPorts()
   {
-    return {InputPort("value", "Value represented as a string. convertFromString must be "
-                               "implemented."),
+    return {InputPort("value", "Value to be written int othe output_key"),
             BidirectionalPort("output_key", "Name of the blackboard entry where the "
-                                            "value "
-                                            "should be written")};
+                                            "value should be written")};
   }
 
 private:

include/behaviortree_cpp/basic_types.h

@@ -357,28 +357,28 @@ std::pair<std::string, PortInfo> CreatePort(PortDirection direction,
 }
 
 //----------
-template <typename T = void> [[nodiscard]]
+template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> InputPort(StringView name,
                                                   StringView description = {})
 {
   return CreatePort<T>(PortDirection::INPUT, name, description);
 }
 
-template <typename T = void> [[nodiscard]]
+template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> OutputPort(StringView name,
                                                    StringView description = {})
 {
   return CreatePort<T>(PortDirection::OUTPUT, name, description);
 }
 
-template <typename T = void> [[nodiscard]]
+template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> BidirectionalPort(StringView name,
                                                           StringView description = {})
 {
   return CreatePort<T>(PortDirection::INOUT, name, description);
 }
 //----------
-template <typename T = void> [[nodiscard]]
+template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> InputPort(StringView name, const T& default_value,
                                                   StringView description)
 {
@@ -387,7 +387,7 @@ inline std::pair<std::string, PortInfo> InputPort(StringView name, const T& defa
   return out;
 }
 
-template <typename T = void> [[nodiscard]]
+template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> BidirectionalPort(StringView name,
                                                           const T& default_value,
                                                           StringView description)

include/behaviortree_cpp/blackboard.h

@@ -124,11 +124,20 @@ class Blackboard
     {
       // create a new entry
       Any new_value(value);
-      PortInfo new_port(PortDirection::INOUT, new_value.type(),
-                        GetAnyFromStringFunctor<T>());
       lock.unlock();
-      auto entry = createEntryImpl(key, new_port);
+      std::shared_ptr<Blackboard::Entry> entry;
+      // if a new generic port is created with a string, it's type should be AnyTypeAllowed
+      if constexpr (std::is_same_v<std::string, T>)
+      {
+        entry = createEntryImpl(key, PortInfo(PortDirection::INOUT));
+      }
+      else {
+        PortInfo new_port(PortDirection::INOUT, new_value.type(),
+                          GetAnyFromStringFunctor<T>());
+        entry = createEntryImpl(key, new_port);
+      }
       lock.lock();
+
       storage_.insert( {key, entry} );
       entry->value = new_value;
     }

src/blackboard.cpp

@@ -174,14 +174,16 @@ Blackboard::createEntryImpl(const std::string& key, const PortInfo& info)
   auto storage_it = storage_.find(key);
   if(storage_it != storage_.end())
   {
-    const auto old_type = storage_it->second->port_info.type();
-    if (old_type != info.type() &&
-        old_type != typeid(BT::PortInfo::AnyTypeAllowed) &&
-        info.type() != typeid(BT::PortInfo::AnyTypeAllowed))
+    const auto& prev_info = storage_it->second->port_info;
+    if (prev_info.type() != info.type() &&
+        prev_info.isStronglyTyped() &&
+        info.isStronglyTyped())
     {
       auto msg = StrCat("Blackboard entry [", key, "]: once declared, the type of a port"
-                        " shall not change. Previously declared type [", BT::demangle(old_type),
-                        "], current type [", BT::demangle(typeid(info.type())), "]");
+                        " shall not change. Previously declared type [",
+                        BT::demangle(prev_info.type()),
+                        "], current type [",
+                        BT::demangle(info.type()), "]");
 
       throw LogicError(msg);
     }

tests/gtest_subtree.cpp

@@ -459,3 +459,52 @@ TEST(SubTree, Issue623_String_to_Pose2d)
   auto tree = factory.createTreeFromText(xml_text);
   tree.tickWhileRunning();
 }
+
+
+class Assert : public BT::SyncActionNode
+{
+public:
+  Assert(const std::string& name, const BT::NodeConfiguration& config)
+    : BT::SyncActionNode(name, config) {}
+
+  static BT::PortsList providedPorts() {
+    return {BT::InputPort<bool>("condition")};
+  }
+
+private:
+  virtual BT::NodeStatus tick() override {
+    if (getInput<bool>("condition").value())
+      return BT::NodeStatus::SUCCESS;
+    else
+      return BT::NodeStatus::FAILURE;
+  }
+};
+
+TEST(SubTree, Issue653_SetBlackboard)
+{
+  // clang-format off
+
+  static const char* xml_text = R"(
+<root main_tree_to_execute = "MainTree" BTCPP_format="4">
+  <BehaviorTree ID="MainTree">
+    <Sequence>
+      <SubTree ID="Init" test="{test}" />
+      <Assert condition="{test}" />
+    </Sequence>
+  </BehaviorTree>
+
+  <BehaviorTree ID="Init">
+    <SetBlackboard output_key="test" value="true"/>
+  </BehaviorTree>
+</root>
+ )";
+
+  // clang-format on
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<Assert>("Assert");
+  auto tree = factory.createTreeFromText(xml_text);
+  tree.tickWhileRunning();
+}
+
+