Merge pull request #671 from BehaviorTree/4.4

4.4

Author: facontidavide

examples/CMakeLists.txt

@@ -36,6 +36,7 @@ endif()
 CompileExample("ex01_wrap_legacy")
 CompileExample("ex02_runtime_ports")
 CompileExample("ex04_waypoints")
+CompileExample("ex05_subtree_model")
 
 CompileExample("t13_plugin_executor")
 

examples/ex05_subtree_model.cpp

@@ -0,0 +1,88 @@
+#include "behaviortree_cpp/bt_factory.h"
+#include "behaviortree_cpp/loggers/bt_cout_logger.h"
+
+using namespace BT;
+
+/*
+ * Demonstrate how to use a SubTree Model (since version 4.4)
+ */
+
+/**
+ * You can optionally add a model to a SubTrees, in this case, "MySub".
+ * We are telling the factory that the callee should remap
+ * two mandatory inputs, and two outputs:
+ *
+ * - sub_in_value (that has the default value 42)
+ * - sub_in_name (no default)
+ * - sub_out_result (default remapping to port {output})
+ * - sub_out_state (no default)
+ *
+ * The callee (parent tree, including the subtree) MUST specify those 
+ * remapping which have no default value.
+ */
+
+// clang-format off
+static const char* xml_subtree = R"(
+<root BTCPP_format="4">
+
+  <TreeNodesModel>
+    <SubTree ID="MySub">
+      <input_port name="sub_in_value" default="42"/>
+      <input_port name="sub_in_name"/>
+      <output_port name="sub_out_result" default="{out_result}"/>
+      <output_port name="sub_out_state"/>
+    </SubTree>
+  </TreeNodesModel>
+
+  <BehaviorTree ID="MySub">
+    <Sequence>
+      <ScriptCondition code="sub_in_value==42 && sub_in_name=='john'" />
+      <Script code="sub_out_result:=69; sub_out_state:='ACTIVE'" />
+    </Sequence>
+  </BehaviorTree>
+</root>
+ )";
+
+/**
+ * Here, when calling "MySub", only `sub_in_name` and `sub_out_state` are explicitly
+ * remapped. We will use the default values for the other two.
+ */
+
+static const char* xml_maintree = R"(
+<root BTCPP_format="4">
+
+  <BehaviorTree ID="MainTree">
+    <Sequence>
+      <Script code="in_name:= 'john' "/>
+      <SubTree ID="MySub" sub_in_name="{in_name}"
+                          sub_out_state="{out_state}"/>
+      <ScriptCondition code=" out_result==69 && out_state=='ACTIVE' " />
+    </Sequence>
+  </BehaviorTree>
+
+</root>
+ )";
+
+// clang-format on
+
+int main()
+{
+  BehaviorTreeFactory factory;
+  factory.registerBehaviorTreeFromText(xml_subtree);
+  factory.registerBehaviorTreeFromText(xml_maintree);
+
+  auto tree = factory.createTree("MainTree");
+  StdCoutLogger logger(tree);
+  tree.tickWhileRunning();
+
+  // We expect the sequence to be successful.
+
+  // The full remapping was:
+  //
+  // - sub_in_name    <-> {in_name}      // specified by callee 'MainTree'
+  // - sub_in_value   <-> 42             // default remapping, see model
+  // - sub_out_result <-> {out_result}   // default remapping, see model
+  // - sub_out_state  <-> {out_state}    // specified by callee 'MainTree'
+
+  return 0;
+}

include/behaviortree_cpp/basic_types.h

@@ -158,13 +158,16 @@ inline StringConverter GetAnyFromStringFunctor<void>()
 template<typename T> [[nodiscard]]
 std::string toStr(const T& value)
 {
-  if constexpr(!std::is_arithmetic_v<T>)
+  if constexpr (std::is_convertible_v<T, std::string> ||
+                std::is_convertible_v<T, std::string_view>)
+  {
+    return value;
+  }
+  else if constexpr(!std::is_arithmetic_v<T>)
   {
     throw LogicError(
         StrCat("Function BT::toStr<T>() not specialized for type [",
-               BT::demangle(typeid(T)), "],",
-               "Implement it consistently with BT::convertFromString<T>(), "
-               "or provide at dummy version that returns an empty string.")
+               BT::demangle(typeid(T)), "]")
       );
   } else {
     return std::to_string(value);
@@ -255,25 +258,27 @@ using Result = Expected<std::monostate>;
 [[nodiscard]]
 bool IsAllowedPortName(StringView str);
 
-class PortInfo
+struct AnyTypeAllowed
+{};
+
+class TypeInfo
 {
 public:
-  struct AnyTypeAllowed
-  {
-  };
 
-  PortInfo(PortDirection direction = PortDirection::INOUT) :
-    type_(direction), type_info_(typeid(AnyTypeAllowed)),
+  template <typename T>
+  static TypeInfo Create() {
+    return TypeInfo{typeid(T), GetAnyFromStringFunctor<T>()};
+  }
+
+  TypeInfo(): type_info_(typeid(AnyTypeAllowed)),
     type_str_("AnyTypeAllowed")
   {}
 
-  PortInfo(PortDirection direction, std::type_index type_info, StringConverter conv) :
-    type_(direction), type_info_(type_info), converter_(conv), 
+  TypeInfo(std::type_index type_info, StringConverter conv) :
+    type_info_(type_info), converter_(conv),
     type_str_(BT::demangle(type_info))
   {}
 
-  [[nodiscard]] PortDirection direction() const;
-
   [[nodiscard]] const std::type_index& type() const;
 
   [[nodiscard]] const std::string& typeName() const;
@@ -289,6 +294,38 @@ class PortInfo
     return {};
   }
 
+  [[nodiscard]] bool isStronglyTyped() const
+  {
+    return type_info_ != typeid(AnyTypeAllowed);
+  }
+
+  [[nodiscard]] const StringConverter& converter() const
+  {
+    return converter_;
+  }
+
+private:
+
+  std::type_index type_info_;
+  StringConverter converter_;
+  std::string type_str_;
+};
+
+
+class PortInfo: public TypeInfo
+{
+public:
+
+  PortInfo(PortDirection direction = PortDirection::INOUT) :
+    TypeInfo(), direction_(direction)
+  {}
+
+  PortInfo(PortDirection direction, std::type_index type_info, StringConverter conv) :
+    TypeInfo(type_info, conv), direction_(direction)
+  {}
+
+  [[nodiscard]] PortDirection direction() const;
+
   void setDescription(StringView description);
 
   template <typename T>
@@ -306,27 +343,14 @@ class PortInfo
 
   [[nodiscard]] const std::string& defaultValueString() const;
 
-  [[nodiscard]] bool isStronglyTyped() const
-  {
-    return type_info_ != typeid(AnyTypeAllowed);
-  }
-
-  [[nodiscard]] const StringConverter& converter() const
-  {
-    return converter_;
-  }
-
 private:
-  PortDirection type_;
-  std::type_index type_info_;
-  StringConverter converter_;
+  PortDirection direction_;
   std::string description_;
   Any default_value_;
   std::string default_value_str_;
-  std::string type_str_;
 };
 
-template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
+template <typename T = AnyTypeAllowed> [[nodiscard]]
 std::pair<std::string, PortInfo> CreatePort(PortDirection direction,
                                             StringView name,
                                             StringView description = {})
@@ -357,28 +381,28 @@ std::pair<std::string, PortInfo> CreatePort(PortDirection direction,
 }
 
 //----------
-template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
+template <typename T = AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> InputPort(StringView name,
                                                   StringView description = {})
 {
   return CreatePort<T>(PortDirection::INPUT, name, description);
 }
 
-template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
+template <typename T = AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> OutputPort(StringView name,
                                                    StringView description = {})
 {
   return CreatePort<T>(PortDirection::OUTPUT, name, description);
 }
 
-template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
+template <typename T = AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> BidirectionalPort(StringView name,
                                                           StringView description = {})
 {
   return CreatePort<T>(PortDirection::INOUT, name, description);
 }
 //----------
-template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
+template <typename T = AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> InputPort(StringView name, const T& default_value,
                                                   StringView description)
 {
@@ -387,7 +411,7 @@ inline std::pair<std::string, PortInfo> InputPort(StringView name, const T& defa
   return out;
 }
 
-template <typename T = PortInfo::AnyTypeAllowed> [[nodiscard]]
+template <typename T = AnyTypeAllowed> [[nodiscard]]
 inline std::pair<std::string, PortInfo> BidirectionalPort(StringView name,
                                                           const T& default_value,
                                                           StringView description)

include/behaviortree_cpp/blackboard.h

@@ -40,14 +40,11 @@ class Blackboard
   struct Entry
   {
     Any value;
-    PortInfo port_info;
+    TypeInfo info;
+    StringConverter string_converter;
     mutable std::mutex entry_mutex;
-
-    Entry(const PortInfo& info) : port_info(info)
-    {}
-
-    Entry(Any&& other_any, const PortInfo& info) :
-          value(std::move(other_any)), port_info(info)
+    
+    Entry(const TypeInfo& _info) : info(_info)
     {}
   };
 
@@ -149,21 +146,19 @@ class Blackboard
       std::scoped_lock lock(entry.entry_mutex);
 
       Any& previous_any = entry.value;
-      const PortInfo& port_info = entry.port_info;
 
       Any new_value(value);
 
       // special case: entry exists but it is not strongly typed... yet
-      if (!port_info.isStronglyTyped())
+      if (!entry.info.isStronglyTyped())
       {
         // Use the new type to create a new entry that is strongly typed.
-        entry.port_info =
-            PortInfo(port_info.direction(), new_value.type(), port_info.converter());
+        entry.info = TypeInfo::Create<T>();
         previous_any = std::move(new_value);
         return;
       }
 
-      std::type_index previous_type = port_info.type();
+      std::type_index previous_type = entry.info.type();
 
       // check type mismatch
       if (previous_type != std::type_index(typeid(T)) &&
@@ -172,7 +167,7 @@ class Blackboard
         bool mismatching = true;
         if (std::is_constructible<StringView, T>::value)
         {
-          Any any_from_string = port_info.parseString(value);
+          Any any_from_string = entry.info.parseString(value);
           if (any_from_string.empty() == false)
           {
             mismatching = false;
@@ -204,8 +199,8 @@ class Blackboard
       new_value.copyInto(previous_any);
     }
   }
-
-   [[nodiscard]] const PortInfo* portInfo(const std::string& key);
+  
+  [[nodiscard]] const TypeInfo* entryInfo(const std::string& key);
 
   void addSubtreeRemapping(StringView internal, StringView external);
 
@@ -217,17 +212,17 @@ class Blackboard
 
   [[deprecated("Use getAnyLocked to access safely an Entry")]]
   std::recursive_mutex& entryMutex() const;
-
-  void createEntry(const std::string& key, const PortInfo& info);
+  
+  void createEntry(const std::string& key, const TypeInfo& info);
 
 private:
   mutable std::mutex mutex_;
   mutable std::recursive_mutex entry_mutex_;
   std::unordered_map<std::string, std::shared_ptr<Entry>> storage_;
   std::weak_ptr<Blackboard> parent_bb_;
   std::unordered_map<std::string, std::string> internal_to_external_;
-
-  std::shared_ptr<Entry> createEntryImpl(const std::string &key, const PortInfo& info);
+  
+  std::shared_ptr<Entry> createEntryImpl(const std::string &key, const TypeInfo& info);
 
   bool autoremapping_ = false;
 };

include/behaviortree_cpp/scripting/operators.hpp

@@ -380,6 +380,16 @@ struct ExprComparison : ExprBase
           return False;
         }
       }
+      else if ((lhs_v.isString() && rhs_v.isNumber()) ||
+               (lhs_v.isNumber() && rhs_v.isString()))
+      {
+        auto lv = lhs_v.cast<double>();
+        auto rv = lhs_v.cast<double>();
+        if (!SwitchImpl(lv, rv, ops[i]))
+        {
+          return False;
+        }
+      }
       else
       {
         throw RuntimeError(StrCat("Can't mix different types in Comparison. "
@@ -504,7 +514,7 @@ struct ExprAssignment : ExprBase
     {
       // the very fist assignment can come from any type.
       // In the future, type check will be done by Any::copyInto
-      if (dst_ptr->empty() && entry->port_info.type() == typeid(PortInfo::AnyTypeAllowed))
+      if (dst_ptr->empty() && entry->info.type() == typeid(AnyTypeAllowed))
       {
         *dst_ptr = value;
       }
@@ -513,8 +523,8 @@ struct ExprAssignment : ExprBase
         // special case: string to other type.
         // Check if we can use the StringConverter
         auto const str = value.cast<std::string>();
-        const auto& port_info = env.vars->portInfo(key);
-        if (auto converter = port_info->converter())
+        const auto& entry_info = env.vars->entryInfo(key);
+        if (auto converter = entry_info->converter())
         {
           *dst_ptr = converter(str);
         }