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

Author: Davide Faconti

CHANGELOG.rst

@@ -2,6 +2,23 @@
 Changelog for package behaviortree_cpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+2.2.0 (2018-11-20)
+------------------
+* fix typo
+* method contains() added to BlackBoard
+* back compatible API change to improve the wrapping of legacy code (issue #15)
+  Eventually, SimpleAction, SimpleDecorators and SimpleCondition can use
+  blackboard and NodeParameters too.
+* reduce potential memory allocations using string_view
+* fix important issue with SubtreeNode
+* Read at every tick the parameter if Blackboard is used
+* Adding NodeParameters to ParallelNode
+* travis update
+* merge pull request #14 related to #10 (with some minor changes)
+* Fix issue #8 and warning reported in #4
+  Fixed problem of visibility with TinyXML2
+* Contributors: Davide Faconti, Uilian Ries 
+
 2.1.0 (2018-11-16)
 ------------------
 * version 2.1. New directory structure

README.md

@@ -1,5 +1,5 @@
 ![License MIT](https://img.shields.io/dub/l/vibe-d.svg)
-![Version](https://img.shields.io/badge/version-v2.1-green.svg)
+![Version](https://img.shields.io/badge/version-v2.2-green.svg)
 [![Build Status](https://travis-ci.org/BehaviorTree/BehaviorTree.CPP.svg?branch=master)](https://travis-ci.org/BehaviorTree/BehaviorTree.CPP)
 
 # About BehaviorTree.CPP

docs/tutorial_B_node_parameters.md

@@ -3,12 +3,11 @@
 NodeParameters are like arguments passed to a function.
 
 They are a map of __key/value__ pairs (both strings) that are usually
-parsed from file.
+read from file.
 
 To create a TreeNodes that accepts NodeParameters, you must follow these rules:
 
-- Use inheritance. NodeParameters are __not supported__ by *SimpleActionNodes* nor
- *SimpleConditionNodes*.
+- Inherit from either ActionNodeBase,  ActionNode, ConditionNode or DecoratorNode.
 
 - You must provide a constructor with the following signature:
 
@@ -22,6 +21,9 @@ MyAction(const std::string& name, const BT::NodeParameters& params)
 static const BT::NodeParameters& requiredNodeParameters()
 ```
 
+Alternatively, since version 2.2, Simple Nodes can also support NodeParameters.
+Check the [tutorial 6](tutorial_G_legacy.md) for details.
+
 
 ## Example: an Action requiring the parameter "message"
 

docs/tutorial_G_legacy.md

@@ -0,0 +1,139 @@
+# Wrap legacy code
+
+In this tutorial we see how to deal with legacy code that was not meant to be used
+with BehaviorTree.CPP.
+
+Let's start supposing that this is my class.
+
+``` c++
+// This is my custom type.
+struct Point3D { double x,y,z; };
+
+class MyLegacyMoveTo
+{
+public:
+    bool go(Point3D goal)
+    {
+        printf("Going to: %f %f %f\n", goal.x, goal.y, goal.z);
+        return true; // true means success in my legacy code
+    }
+};
+```
+
+We want to create an ActionNode called "MoveTo" that invokes the method __MyLegacyMoveTo::go()__.
+
+The final goal is to be able to use this ActionNode in a tree like this one:
+
+``` XML
+ <root main_tree_to_execute = "MainTree" >
+     <BehaviorTree ID="MainTree">
+        <SequenceStar name="root">
+            <MoveTo  goal="-1;3;0.5" />
+            <MoveTo  goal="${myGoal}" />
+        </SequenceStar>
+     </BehaviorTree>
+ </root>
+``` 
+
+The first thing that we need to do is to allow our library to convert
+a NodeParameter (that is
+nothing more than a pair of strings representing key/value) into a Point3D.
+
+As we did in a previous tutorial, we should implement a template specialization
+for __convertFromString__.
+
+Our particular string representation of a Point3D consists in three semicolon-separated
+numbers, representing __x, y and z_.
+
+
+``` c++
+namespace BT
+{
+template <> Point3D convertFromString(const StringView& key)
+{
+    // three real numbers separated by semicolons
+    auto parts = BT::splitString(key, ';');
+    if (parts.size() != 3)
+    {
+        throw std::runtime_error("invalid input)");
+    }
+    else
+    {
+        Point3D output;
+        output.x  = convertFromString<double>(parts[0]);
+        output.y  = convertFromString<double>(parts[1]);
+        output.z  = convertFromString<double>(parts[2]);
+        return output;
+    }
+}
+}
+```
+
+Finally, we can use a __C++11 lambda__ (or, alternatively, __std::bind__) to wrap
+out method into a function with the right signature.
+
+``` c++
+int main()
+{
+    using namespace BT;
+
+    MyLegacyMoveTo move_to;
+
+    // Here we use a lambda that captures the reference of move_to
+    auto MoveToWrapperWithLambda = [&move_to](TreeNode& parent_node) -> NodeStatus
+    {
+        Point3D goal;
+        // thanks to paren_node, you can access easily the NodeParameters and the blackboard
+        parent_node.getParam("goal", goal);
+
+        bool res = move_to.go( goal );
+        // convert bool to NodeStatus
+        return res ? NodeStatus::SUCCESS : NodeStatus::FAILURE;
+    };
+
+    BehaviorTreeFactory factory;
+    factory.registerSimpleAction("MoveTo", MoveToWrapperWithLambda);
+
+    auto blackboard = Blackboard::create<BlackboardLocal>();
+    auto tree = buildTreeFromText(factory, xml_text, blackboard);
+
+    // We set the entry "myGoal" in the blackboard.
+    Point3D my_goal = {3,4,5};
+    blackboard->set("myGoal", my_goal);
+
+    NodeStatus status = NodeStatus::RUNNING;
+    while (status == NodeStatus::RUNNING)
+    {
+        status = tree.root_node->executeTick();
+    }
+    return 0;
+}
+
+/* Expected output:
+
+Going to: -1.000000 3.000000 0.500000
+Going to: 3.000000 4.000000 5.000000
+
+The first MoveTo read the parameter from the string "-1;3;0.5"
+whilst the second from the blackboard, that contains a copy of the Point3D my_goal.
+
+*/
+```
+
+
+The functor we are passing to __SimpleActionNode__ requires the following signature:
+
+     BT::NodeStatus myFunction(BT::TreeNode& parent) 
+     
+As a consequence, we can access a NodeParameter by
+
+     parent.getParam()
+     
+or even set/get an entry of the Blackboard using
+
+     parent.blackboard()
+
+
+
+
+

examples/CMakeLists.txt

@@ -25,3 +25,6 @@ target_link_libraries(t04_blackboard  movebase_node ${BEHAVIOR_TREE_LIBRARY}  )
 
 add_executable(t05_crossdoor         t05_crossdoor.cpp )
 target_link_libraries(t05_crossdoor  crossdoor_nodes ${BEHAVIOR_TREE_LIBRARY}  )
+
+add_executable(t06_wrap_legacy         t06_wrap_legacy.cpp )
+target_link_libraries(t06_wrap_legacy  crossdoor_nodes ${BEHAVIOR_TREE_LIBRARY}  )

examples/t04_blackboard.cpp

@@ -41,7 +41,7 @@ const std::string xml_text = R"(
 // Use this function to create a SimpleActionNode that can access the blackboard
 NodeStatus CalculateGoalPose(TreeNode& self)
 {
-    const Pose2D mygoal = {1, 2, M_PI};
+    const Pose2D mygoal = {1.1, 2.3, 1.54};
 
     // RECOMMENDED: check if the blackboard is nullptr first
     if (self.blackboard())

examples/t06_wrap_legacy.cpp

@@ -0,0 +1,113 @@
+#include "behaviortree_cpp/xml_parsing.h"
+#include "behaviortree_cpp/loggers/bt_cout_logger.h"
+#include "behaviortree_cpp/blackboard/blackboard_local.h"
+
+
+/** In this tutorial we will see how to wrap legacy code into a
+ * BehaviorTree in a non-intrusive way, i.e. without modifying the
+ * original class
+*/
+
+// clang-format off
+const std::string xml_text = R"(
+
+ <root main_tree_to_execute = "MainTree" >
+     <BehaviorTree ID="MainTree">
+        <SequenceStar name="root">
+            <MoveTo  goal="-1;3;0.5" />
+            <MoveTo  goal="${myGoal}" />
+        </SequenceStar>
+     </BehaviorTree>
+ </root>
+ )";
+
+// clang-format on
+
+// This is my custom type.
+// By default, we don't know how to read this from a NodeParameter.
+struct Point3D { double x,y,z; };
+
+// We want to create an ActionNode that calls the method MyLegacyMoveTo::go
+class MyLegacyMoveTo
+{
+public:
+    bool go(Point3D goal)
+    {
+        printf("Going to: %f %f %f\n", goal.x, goal.y, goal.z);
+        return true; // true means success in my legacy code
+    }
+};
+
+// Similarly to the previous tutorials, we need to implement this parsing method,
+// providing a specialization of BT::convertFromString
+namespace BT
+{
+template <> Point3D convertFromString(const StringView& key)
+{
+    // three real numbers separated by semicolons
+    auto parts = BT::splitString(key, ';');
+    if (parts.size() != 3)
+    {
+        throw std::runtime_error("invalid input)");
+    }
+    else
+    {
+        Point3D output;
+        output.x  = convertFromString<double>(parts[0]);
+        output.y  = convertFromString<double>(parts[1]);
+        output.z  = convertFromString<double>(parts[2]);
+        return output;
+    }
+}
+}
+
+
+int main()
+{
+    using namespace BT;
+
+    MyLegacyMoveTo move_to;
+
+    // Here we use a lambda that captures the reference of move_to
+    auto MoveToWrapperWithLambda = [&move_to](TreeNode& parent_node) -> NodeStatus
+    {
+        Point3D goal;
+        // thanks to paren_node, you can access easily the NodeParameters and the blackboard
+        parent_node.getParam("goal", goal);
+
+        // you can write and read the blackboard if you like
+        //parent_node.blackboard() ....
+
+        bool res = move_to.go( goal );
+        // convert bool to NodeStatus
+        return res ? NodeStatus::SUCCESS : NodeStatus::FAILURE;
+    };
+
+    BehaviorTreeFactory factory;
+    // Register the lambda with BehaviorTreeFactory::registerSimpleAction
+    factory.registerSimpleAction("MoveTo", MoveToWrapperWithLambda);
+
+    auto blackboard = Blackboard::create<BlackboardLocal>();
+    auto tree = buildTreeFromText(factory, xml_text, blackboard);
+
+    // We set the entry "myGoal" in the blackboard.
+    Point3D my_goal = {3,4,5};
+    blackboard->set("myGoal", my_goal);
+
+    NodeStatus status = NodeStatus::RUNNING;
+    while (status == NodeStatus::RUNNING)
+    {
+        status = tree.root_node->executeTick();
+    }
+    return 0;
+}
+
+/* Expected output:
+
+Going to: -1.000000 3.000000 0.500000
+Going to: 3.000000 4.000000 5.000000
+
+The first MoveTo read the parameter from the string "-1;3;0.5"
+whilst the second from the blackboard, that contains a copy of the Point3D my_goal.
+
+*/

include/behaviortree_cpp/action_node.h

@@ -52,7 +52,8 @@ class SimpleActionNode : public ActionNodeBase
     typedef std::function<NodeStatus(TreeNode&)> TickFunctor;
 
     // Constructor: you must provide the function to call when tick() is invoked
-    SimpleActionNode(const std::string& name, TickFunctor tick_functor);
+    SimpleActionNode(const std::string& name, TickFunctor tick_functor,
+                     const NodeParameters &params = NodeParameters());
 
     ~SimpleActionNode() override = default;
 

include/behaviortree_cpp/blackboard/blackboard.h

@@ -25,6 +25,7 @@ class BlackboardImpl
 
     virtual const SafeAny::Any* get(const std::string& key) const = 0;
     virtual void set(const std::string& key, const SafeAny::Any& value) = 0;
+    virtual bool contains(const std::string& key) const = 0;
 };
 
 // This is the "frontend" to be used by the developer.
@@ -107,6 +108,11 @@ class Blackboard
         }
     }
 
+    bool contains(const std::string& key) const
+    {
+        return (impl_ && impl_->contains(key));
+    }
+
   private:
     std::unique_ptr<BlackboardImpl> impl_;
 };

include/behaviortree_cpp/blackboard/blackboard_local.h

@@ -27,6 +27,11 @@ class BlackboardLocal : public BlackboardImpl
         storage_[key] = value;
     }
 
+    virtual bool contains(const std::string& key) const override
+    {
+        return storage_.find(key) != storage_.end();
+    }
+
   private:
     std::unordered_map<std::string, SafeAny::Any> storage_;
 };