allow Input/Output ports with type Any

facontidavide · facontidavide · commit a92b7bda7b03 · 2024-01-10T12:42:09.000+01:00
diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
@@ -297,7 +297,8 @@ class TypeInfo
 
   [[nodiscard]] bool isStronglyTyped() const
   {
-    return type_info_ != typeid(AnyTypeAllowed);
+    return type_info_ != typeid(AnyTypeAllowed) &&
+           type_info_ != typeid(BT::Any);
   }
 
   [[nodiscard]] const StringConverter& converter() const
diff --git a/include/behaviortree_cpp/blackboard.h b/include/behaviortree_cpp/blackboard.h
@@ -196,7 +196,15 @@ class Blackboard
           throw LogicError(msg);
         }
       }
-      new_value.copyInto(previous_any);
+      // if doing set<BT::Any>, skip type check
+      if constexpr(std::is_same_v<Any, T>)
+      {
+        previous_any = new_value;
+      }
+      else {
+        // copy only if the type is compatible
+        new_value.copyInto(previous_any);
+      }
     }
   }
 
diff --git a/include/behaviortree_cpp/tree_node.h b/include/behaviortree_cpp/tree_node.h
@@ -441,10 +441,16 @@ inline Result TreeNode::getInput(const std::string& key, T& destination) const
     if (auto any_ref = config().blackboard->getAnyLocked(std::string(remapped_key)))
     {
       auto val = any_ref.get();
+      // support getInput<Any>()
+      if constexpr (std::is_same_v<T, Any>)
+      {
+        destination = *val;
+        return {};
+      }
+
       if(!val->empty())
       {
-        if (!std::is_same_v<T, std::string> &&
-            val->type() == typeid(std::string))
+        if (!std::is_same_v<T, std::string> && val->isString())
         {
           destination = ParseString(val->cast<std::string>());
         }
@@ -495,6 +501,15 @@ inline Result TreeNode::setOutput(const std::string& key, const T& value)
     return nonstd::make_unexpected("setOutput requires a blackboard pointer. Use {}");
   }
 
+  if constexpr(std::is_same_v<BT::Any, T>)
+  {
+    if(config().manifest->ports.at(key).type() != typeid(BT::Any))
+    {
+      throw LogicError("setOutput<Any> is not allowed, unless the port "
+                       "was declared using OutputPort<Any>");
+    }
+  }
+
   remapped_key = stripBlackboardPointer(remapped_key);
   config().blackboard->set(static_cast<std::string>(remapped_key), value);
 
diff --git a/tests/gtest_ports.cpp b/tests/gtest_ports.cpp
@@ -289,3 +289,86 @@ TEST(PortTest, DefaultInput)
 }
 
 
+class GetAny : public SyncActionNode
+{
+public:
+  GetAny(const std::string& name, const NodeConfig& config) :
+      SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    // case 1: the port is Any, but we can cast dirrectly to string
+    auto res_str = getInput<std::string>("val_str");
+    // case 2: the port is Any, and we retrieve an Any (to be casted later)
+    auto res_int = getInput<BT::Any>("val_int");
+
+    // case 3: port is double and we get a double
+    auto res_real_A = getInput<double>("val_real");
+    // case 4: port is double and we get an Any
+    auto res_real_B = getInput<BT::Any>("val_real");
+
+    bool expected = res_str.value() == "hello" &&
+                    res_int->cast<int>() == 42 &&
+                    res_real_A.value() == 3.14 &&
+                    res_real_B->cast<double>() == 3.14;
+
+    return expected ? NodeStatus::SUCCESS : NodeStatus::FAILURE;
+  }
+
+  static PortsList providedPorts()
+  {
+    return {BT::InputPort<BT::Any>("val_str"),
+            BT::InputPort<BT::Any>("val_int"),
+            BT::InputPort<double>("val_real")};
+  }
+};
+
+class SetAny : public SyncActionNode
+{
+public:
+  SetAny(const std::string& name, const NodeConfig& config) :
+      SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    // check that the port can contain different types
+    setOutput("val_str", BT::Any(1.0));
+    setOutput("val_str", BT::Any(1));
+    setOutput("val_str", BT::Any("hello"));
+
+    setOutput("val_int", 42);
+    setOutput("val_real", 3.14);
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return {BT::OutputPort<BT::Any>("val_str"),
+            BT::OutputPort<int>("val_int"),
+            BT::OutputPort<BT::Any>("val_real")};
+  }
+};
+
+TEST(PortTest, AnyPort)
+{
+  std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree>
+        <Sequence>
+          <SetAny val_str="{val_str}" val_int="{val_int}" val_real="{val_real}"/>
+          <GetAny val_str="{val_str}" val_int="{val_int}" val_real="{val_real}"/>
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<SetAny>("SetAny");
+  factory.registerNodeType<GetAny>("GetAny");
+  auto tree = factory.createTreeFromText(xml_txt);
+  auto status = tree.tickOnce();
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+}
+
+

Original file line number	Diff line number	Diff line change
`@@ -297,7 +297,8 @@ class TypeInfo`
`297`	`297`
`298`	`298`	`[[nodiscard]] bool isStronglyTyped() const`
`299`	`299`	`{`
`300`		`- return type_info_ != typeid(AnyTypeAllowed);`
	`300`	`+ return type_info_ != typeid(AnyTypeAllowed) &&`
	`301`	`+ type_info_ != typeid(BT::Any);`
`301`	`302`	`}`
`302`	`303`
`303`	`304`	`[[nodiscard]] const StringConverter& converter() const`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,15 @@ class Blackboard`
`196`	`196`	`throw LogicError(msg);`
`197`	`197`	`}`
`198`	`198`	`}`
`199`		`- new_value.copyInto(previous_any);`
	`199`	`+ // if doing set<BT::Any>, skip type check`
	`200`	`+ if constexpr(std::is_same_v<Any, T>)`
	`201`	`+ {`
	`202`	`+ previous_any = new_value;`
	`203`	`+ }`
	`204`	`+ else {`
	`205`	`+ // copy only if the type is compatible`
	`206`	`+ new_value.copyInto(previous_any);`
	`207`	`+ }`
`200`	`208`	`}`
`201`	`209`	`}`
`202`	`210`