Merge branch 'master' of github.com:BehaviorTree/BehaviorTree.CPP

facontidavide · facontidavide · commit b3b33e13413f · 2023-02-20T13:52:57.000+01:00
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
@@ -2,6 +2,44 @@
 Changelog for package behaviortree_cpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+4.0.2 (2023-02-17)
+------------------
+* fix issue `#501 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/501>`_
+* fix issue `#505 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/505>`_
+* solve issue `#506 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/506>`_
+* prevent useless exception catcking
+* fix issue `#507 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/507>`_
+* adding the uid to the log to uniquely identify the nodes (`#502 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/502>`_)
+* fix in SharedLibrary and cosmetic changes to the code
+* using tinyxml ErrorStr() instead of ErrorName() to get more info about missing file (`#497 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/497>`_)
+* Fixed use of ros_pkg for ROS1 applications (`#483 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/483>`_)
+* Fix error message StdCoutLogger -> MinitraceLogger (`#495 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/495>`_)
+* Fix boost dependency in package.xml (`#493 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/493>`_)
+  Co-authored-by: Bart Keulen <b.keulen@avular.com>
+* support Enums in string conversion
+* fix issue 489
+* updated example. Demonstrate pass by reference
+* lexy updated
+* rename haltChildren to resetChildren
+* revert `#329 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/329>`_
+* Merge branch 'master' of github.com:BehaviorTree/BehaviorTree.CPP
+* Small improvements (`#479 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/479>`_)
+  * Make message for allowed port names more explicit
+  Also throw an exception for unknown port direction rather than using
+  `PortDirection::INOUT`.
+  * Small code improvements
+  * Remove code without effect
+* Fix some renaming for V4 (`#480 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/480>`_)
+* Define NodeConfiguration for BT3 compatibility (`#477 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/477>`_)
+* Implement `#404 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/404>`_ to solve `#435 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/435>`_ (gtest not found)
+* fix issue `#474 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/474>`_ Make libraries dependencies private
+* fix issue `#413 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/413>`_ (Delay logic)
+* change suggested in `#444 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/444>`_
+* add XML converter
+* Add CodeQL workflow (`#471 <https://github.com/BehaviorTree/BehaviorTree.CPP/issues/471>`_)
+* Update README.md
+* Contributors: Ana, Bart Keulen, Christian Henkel, Davide Faconti, Gaël Écorchard, Jorge, Mahmoud Farshbafdoustar, Norawit Nangsue
+
 4.0.1 (2022-11-19)
 ------------------
 * version 4.X
diff --git a/include/behaviortree_cpp/bt_factory.h b/include/behaviortree_cpp/bt_factory.h
@@ -40,8 +40,7 @@ inline NodeBuilder CreateBuilder(Args... args)
 }
 
 template <typename T>
-inline TreeNodeManifest CreateManifest(const std::string& ID,
-                                       PortsList portlist = getProvidedPorts<T>())
+inline TreeNodeManifest CreateManifest(const std::string& ID, PortsList portlist)
 {
   return {getType<T>(), ID, portlist, {}};
 }
@@ -300,40 +299,53 @@ class BehaviorTreeFactory
                                                 const std::string& ID,
                                                 const NodeConfig& config) const;
 
-  /** registerNodeType is the method to use to register your custom TreeNode.
-     *
-     *  It accepts only classed derived from either ActionNodeBase, DecoratorNode,
-     *  ControlNode or ConditionNode.
-     */
+  /** registerNodeType where you explicitly pass the list of ports.
+   *  Doesn't require the implementation of static method providedPorts()
+  */
   template <typename T, typename... ExtraArgs>
-  void registerNodeType(const std::string& ID, ExtraArgs... args)
+  void registerNodeType(const std::string& ID, const PortsList& ports, ExtraArgs... args)
   {
     static_assert(std::is_base_of<ActionNodeBase, T>::value ||
-                      std::is_base_of<ControlNode, T>::value ||
-                      std::is_base_of<DecoratorNode, T>::value ||
-                      std::is_base_of<ConditionNode, T>::value,
+                  std::is_base_of<ControlNode, T>::value ||
+                  std::is_base_of<DecoratorNode, T>::value ||
+                  std::is_base_of<ConditionNode, T>::value,
                   "[registerNode]: accepts only classed derived from either "
                   "ActionNodeBase, "
                   "DecoratorNode, ControlNode or ConditionNode");
 
-    static_assert(!std::is_abstract<T>::value, "[registerNode]: Some methods are pure "
-                                               "virtual. "
-                                               "Did you override the methods tick() and "
-                                               "halt()?");
-
     constexpr bool default_constructable =
         std::is_constructible<T, const std::string&>::value;
     constexpr bool param_constructable =
         std::is_constructible<T, const std::string&, const NodeConfig&,
                               ExtraArgs...>::value;
-    constexpr bool has_static_ports_list = has_static_method_providedPorts<T>::value;
 
     // clang-format off
+    static_assert(!std::is_abstract<T>::value,
+                  "[registerNode]: Some methods are pure virtual. "
+                  "Did you override the methods tick() and halt()?");
+
     static_assert(default_constructable || param_constructable,
        "[registerNode]: the registered class must have at least one of these two constructors:\n"
        "  (const std::string&, const NodeConfig&) or (const std::string&)\n"
        "Check also if the constructor is public!)");
+    // clang-format on
+
+    registerBuilder(CreateManifest<T>(ID, ports), CreateBuilder<T>(args...));
+  }
+
+  /** registerNodeType is the method to use to register your custom TreeNode.
+  *
+  *  It accepts only classed derived from either ActionNodeBase, DecoratorNode,
+  *  ControlNode or ConditionNode.
+  */
+  template <typename T, typename... ExtraArgs>
+  void registerNodeType(const std::string& ID, ExtraArgs... args)
+  {
+    constexpr bool param_constructable =
+        std::is_constructible<T, const std::string&, const NodeConfig&, ExtraArgs...>::value;
+    constexpr bool has_static_ports_list = has_static_method_providedPorts<T>::value;
 
+    // clang-format off
     static_assert(!(param_constructable && !has_static_ports_list),
                   "[registerNode]: you MUST implement the static method:\n"
                   "  PortsList providedPorts();\n");
@@ -343,52 +355,7 @@ class BehaviorTreeFactory
                   "you MUST add a constructor with signature:\n"
                   "(const std::string&, const NodeParameters&)\n");
     // clang-format on
-
-    registerBuilder(CreateManifest<T>(ID), CreateBuilder<T>(args...));
-  }
-
-  template <typename T>
-  void registerNodeType(const std::string& ID, PortsList ports)
-  {
-    static_assert(std::is_base_of<ActionNodeBase, T>::value ||
-                      std::is_base_of<ControlNode, T>::value ||
-                      std::is_base_of<DecoratorNode, T>::value ||
-                      std::is_base_of<ConditionNode, T>::value,
-                  "[registerNode]: accepts only classed derived from either "
-                  "ActionNodeBase, "
-                  "DecoratorNode, ControlNode or ConditionNode");
-
-    static_assert(!std::is_abstract<T>::value, "[registerNode]: Some methods are pure "
-                                               "virtual. "
-                                               "Did you override the methods tick() and "
-                                               "halt()?");
-
-    constexpr bool default_constructable =
-        std::is_constructible<T, const std::string&>::value;
-    constexpr bool param_constructable =
-        std::is_constructible<T, const std::string&, const NodeConfig&>::value;
-    constexpr bool has_static_ports_list = has_static_method_providedPorts<T>::value;
-
-    static_assert(default_constructable || param_constructable, "[registerNode]: the "
-                                                                "registered class must "
-                                                                "have at "
-                                                                "least one of these two "
-                                                                "constructors: (const "
-                                                                "std::string&, const "
-                                                                "NodeConfig&) or (const "
-                                                                "std::string&).");
-
-    static_assert(!has_static_ports_list, "[registerNode]: ports are passed to this node "
-                                          "explicitly. The static method"
-                                          "providedPorts() should be removed to avoid "
-                                          "ambiguities\n");
-
-    static_assert(param_constructable, "[registerNode]: since this node has ports, "
-                                       "you MUST add a constructor sign signature (const "
-                                       "std::string&, const "
-                                       "NodeParameters&)\n");
-
-    registerBuilder(CreateManifest<T>(ID, ports), CreateBuilder<T>());
+    registerNodeType<T>(ID, getProvidedPorts<T>(), args...);
   }
 
   /// All the builders. Made available mostly for debug purposes.
diff --git a/include/behaviortree_cpp/decorators/subtree_node.h b/include/behaviortree_cpp/decorators/subtree_node.h
@@ -50,20 +50,15 @@ namespace BT
 class SubTreeNode : public DecoratorNode
 {
 public:
-  SubTreeNode(const std::string& instance_name);
+  SubTreeNode(const std::string& name, const NodeConfig& config);
 
   virtual ~SubTreeNode() override = default;
 
+  static PortsList providedPorts();
+
 private:
   virtual BT::NodeStatus tick() override;
 
-  static PortsList providedPorts()
-  {
-    return {InputPort<bool>("_autoremap", false,
-                            "If true, all the ports with the same name will be "
-                            "remapped")};
-  }
-
   virtual NodeType type() const override final
   {
     return NodeType::SUBTREE;
diff --git a/include/behaviortree_cpp/scripting/operators.hpp b/include/behaviortree_cpp/scripting/operators.hpp
@@ -157,40 +157,49 @@ struct ExprBinaryArithmetic : ExprBase
                 return Any(lv / rv);
             default: {}
             }
-            try {
-                int64_t li = lhs_v.cast<int64_t>();
-                int64_t ri = rhs_v.cast<int64_t>();
-                switch (op)
-                {
-                case bit_and:
+
+            if(op == bit_and || op == bit_or || op == bit_xor)
+            {
+                try {
+                  int64_t li = lhs_v.cast<int64_t>();
+                  int64_t ri = rhs_v.cast<int64_t>();
+                  switch (op)
+                  {
+                  case bit_and:
                     return Any(static_cast<double>(li & ri));
-                case bit_or:
+                  case bit_or:
                     return Any(static_cast<double>(li | ri));
-                case bit_xor:
+                  case bit_xor:
                     return Any(static_cast<double>(li ^ ri));
-                default: {}
+                  default: {}
+                  }
+                }
+                catch(...)
+                {
+                  throw std::runtime_error("Binary operators are not allowed if "
+                                           "one of the operands is not an integer");
                 }
-            }
-            catch(...)
-            {
-                throw std::runtime_error("Binary operators are not allowed if one of the operands is an integer");
             }
 
-            try {
-                auto lb = lhs_v.cast<bool>();
-                auto rb = rhs_v.cast<bool>();
-                switch (op)
-                {
-                case logic_or:
+            if(op == logic_or || op == logic_and)
+            {
+                try {
+                  auto lb = lhs_v.cast<bool>();
+                  auto rb = rhs_v.cast<bool>();
+                  switch (op)
+                  {
+                  case logic_or:
                     return Any(static_cast<double>(lb || rb));
-                case logic_and:
+                  case logic_and:
                     return Any(static_cast<double>(lb && rb));
-                default: {}
+                  default: {}
+                  }
+                }
+                catch(...)
+                {
+                  throw std::runtime_error("Logic operators are not allowed if "
+                                           "one of the operands is not castable to bool");
                 }
-            }
-            catch(...)
-            {
-                throw std::runtime_error("Logic operators are not allowed if one of the operands is not castable to bool");
             }
         }
         else if(rhs_v.isType<SimpleString>() && lhs_v.isType<SimpleString>() && op == plus)
diff --git a/include/behaviortree_cpp/utils/convert_impl.hpp b/include/behaviortree_cpp/utils/convert_impl.hpp
@@ -142,7 +142,11 @@ void convertNumber( const SRC& source, DST& target )
     // casting to/from floating points might cause truncation.
     else if constexpr( std::is_floating_point<SRC>::value || std::is_floating_point<DST>::value )
     {
-        checkTruncation<SRC,DST>(source);
+        bool both_float = std::is_floating_point<SRC>::value && std::is_floating_point<DST>::value;
+        // to avoid being too pedantic, let's accept casting between double and float
+        if(!both_float){
+            checkTruncation<SRC,DST>(source);
+        }
         target = static_cast<DST>(source);
     }
 }
diff --git a/include/behaviortree_cpp/utils/simple_string.hpp b/include/behaviortree_cpp/utils/simple_string.hpp
@@ -114,18 +114,23 @@ class SimpleString {
     return std::strcmp(data(), other.data()) > 0;
   }
 
-  bool isSOO() const { return !(_storage.soo.capacity_left & IS_LONG_BIT); }
+  bool isSOO() const {
+    return !(_storage.soo.capacity_left & IS_LONG_BIT);
+  }
 
   private:
-  constexpr static std::size_t CAPACITY = sizeof(void *) * 2 - 1;
+
+  struct String {
+    char *data;
+    std::size_t size;
+  };
+
+  constexpr static std::size_t CAPACITY = std::max(size_t(15), sizeof(String) - 1);
   constexpr static std::size_t IS_LONG_BIT = 1 << 7;
-  constexpr static std::size_t LONG_MASK = ~(uint32_t(0));
+  constexpr static std::size_t LONG_MASK = (~std::size_t(0)) >> 1;
 
   union {
-    struct String {
-      char *data;
-      std::size_t size;
-    } str;
+    String str;
 
     struct SOO {
       char data[CAPACITY];
diff --git a/package.xml b/package.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <package format="3">
   <name>behaviortree_cpp</name>
-  <version>4.0.1</version>
+  <version>4.0.2</version>
   <description>
   This package provides the Behavior Trees core library.
   </description>
diff --git a/src/decorators/subtree_node.cpp b/src/decorators/subtree_node.cpp
@@ -1,11 +1,23 @@
 #include "behaviortree_cpp/decorators/subtree_node.h"
 
-BT::SubTreeNode::SubTreeNode(const std::string& instance_name) :
-  DecoratorNode(instance_name, {})
+BT::SubTreeNode::SubTreeNode(const std::string& name,
+                             const NodeConfig &config) :
+  DecoratorNode(name, config)
 {
   setRegistrationID("SubTree");
 }
 
+BT::PortsList BT::SubTreeNode::providedPorts()
+{
+  auto port = PortInfo(PortDirection::INPUT, typeid(bool),
+                       GetAnyFromStringFunctor<bool>());
+  port.setDefaultValue("false");
+  port.setDescription("If true, all the ports with the same name "
+                      "will be remapped");
+
+  return {{"_autoremap", port}};
+}
+
 BT::NodeStatus BT::SubTreeNode::tick()
 {
   NodeStatus prev_status = status();
diff --git a/src/xml_parsing.cpp b/src/xml_parsing.cpp
diff --git a/tests/gtest_skipping.cpp b/tests/gtest_skipping.cpp

Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,11 @@ void convertNumber( const SRC& source, DST& target )`
`142`	`142`	`// casting to/from floating points might cause truncation.`
`143`	`143`	`else if constexpr( std::is_floating_point<SRC>::value \|\| std::is_floating_point<DST>::value )`
`144`	`144`	`{`
`145`		`- checkTruncation<SRC,DST>(source);`
	`145`	`+ bool both_float = std::is_floating_point<SRC>::value && std::is_floating_point<DST>::value;`
	`146`	`+ // to avoid being too pedantic, let's accept casting between double and float`
	`147`	`+ if(!both_float){`
	`148`	`+ checkTruncation<SRC,DST>(source);`
	`149`	`+ }`
`146`	`150`	`target = static_cast<DST>(source);`
`147`	`151`	`}`
`148`	`152`	`}`