revert new behavior of Sequence and Fallback

Author: facontidavide

include/behaviortree_cpp/controls/fallback_node.h

@@ -32,7 +32,7 @@ namespace BT
 class FallbackNode : public ControlNode
 {
 public:
-  FallbackNode(const std::string& name);
+  FallbackNode(const std::string& name, bool make_aynch = false);
 
   virtual ~FallbackNode() override = default;
 
@@ -41,6 +41,7 @@ class FallbackNode : public ControlNode
 private:
   size_t current_child_idx_;
   bool all_skipped_ = true;
+  bool asynch_ = false;
 
   virtual BT::NodeStatus tick() override;
 };

include/behaviortree_cpp/controls/reactive_sequence.h

@@ -36,8 +36,14 @@ class ReactiveSequence : public ControlNode
   ReactiveSequence(const std::string& name) : ControlNode(name, {})
   {}
 
+  static void EnableException(bool enable);
+
 private:
   virtual BT::NodeStatus tick() override;
+
+  int running_child_ = -1;
+
+  static bool throw_if_multiple_running;
 };
 
 }   // namespace BT

include/behaviortree_cpp/controls/sequence_node.h

@@ -30,10 +30,12 @@ namespace BT
  *   Restart the loop only if (reset_on_failure == true)
  *
  */
+
 class SequenceNode : public ControlNode
 {
 public:
-  SequenceNode(const std::string& name);
+  SequenceNode(const std::string& name,
+               bool make_async = false);
 
   virtual ~SequenceNode() override = default;
 
@@ -42,6 +44,7 @@ class SequenceNode : public ControlNode
 private:
   size_t current_child_idx_;
   bool all_skipped_ = true;
+  bool asynch_ = false;
 
   virtual BT::NodeStatus tick() override;
 };

include/behaviortree_cpp/tree_node.h

@@ -266,7 +266,7 @@ class TreeNode
     }
     else if constexpr (hasNodeNameCtor<DerivedT>())
     {
-      auto node_ptr = new DerivedT(name);
+      auto node_ptr = new DerivedT(name, args...);
       node_ptr->config_ = config;
       return std::unique_ptr<DerivedT>(node_ptr);
     }

src/bt_factory.cpp

@@ -28,7 +28,9 @@ BehaviorTreeFactory::BehaviorTreeFactory()
 {
   parser_ = std::make_shared<XMLParser>(*this);
   registerNodeType<FallbackNode>("Fallback");
+  registerNodeType<FallbackNode>("AsyncFallback", true);
   registerNodeType<SequenceNode>("Sequence");
+  registerNodeType<SequenceNode>("AsyncSequence", true);
   registerNodeType<SequenceWithMemory>("SequenceWithMemory");
 
 #ifdef USE_BTCPP3_OLD_NAMES

src/controls/fallback_node.cpp

@@ -15,10 +15,16 @@
 
 namespace BT
 {
-FallbackNode::FallbackNode(const std::string& name) :
-  ControlNode::ControlNode(name, {}), current_child_idx_(0), all_skipped_(true)
+FallbackNode::FallbackNode(const std::string& name, bool make_aynch) :
+  ControlNode::ControlNode(name, {}),
+  current_child_idx_(0),
+  all_skipped_(true),
+  asynch_(make_aynch)
 {
-  setRegistrationID("Fallback");
+  if(asynch_)
+    setRegistrationID("AsyncFallback");
+  else
+    setRegistrationID("Fallback");
 }
 
 NodeStatus FallbackNode::tick()
@@ -56,7 +62,8 @@ NodeStatus FallbackNode::tick()
         current_child_idx_++;
         // Return the execution flow if the child is async,
         // to make this interruptable.
-        if (requiresWakeUp() && prev_status == NodeStatus::IDLE &&
+        if (asynch_ && requiresWakeUp() &&
+            prev_status == NodeStatus::IDLE &&
             current_child_idx_ < children_count)
         {
           emitWakeUpSignal();

src/controls/reactive_sequence.cpp

@@ -14,6 +14,14 @@
 
 namespace BT
 {
+
+bool ReactiveSequence::throw_if_multiple_running = true;
+
+void ReactiveSequence::EnableException(bool enable)
+{
+  ReactiveSequence::throw_if_multiple_running = enable;
+}
+
 NodeStatus ReactiveSequence::tick()
 {
   bool all_skipped = true;
@@ -36,6 +44,14 @@ NodeStatus ReactiveSequence::tick()
         {
           haltChild(i);
         }
+        if(running_child_ == -1)
+        {
+          running_child_ = int(index);
+        }
+        else if(throw_if_multiple_running && running_child_ != int(index))
+        {
+          throw LogicError("[ReactiveSequence]: only a single child can return RUNNING");
+        }
         return NodeStatus::RUNNING;
       }
 

src/controls/sequence_node.cpp

@@ -15,10 +15,16 @@
 
 namespace BT
 {
-SequenceNode::SequenceNode(const std::string& name) :
-  ControlNode::ControlNode(name, {}), current_child_idx_(0), all_skipped_(true)
+SequenceNode::SequenceNode(const std::string& name, bool make_async) :
+  ControlNode::ControlNode(name, {}),
+  current_child_idx_(0),
+  all_skipped_(true),
+  asynch_(make_async)
 {
-  setRegistrationID("Sequence");
+  if(asynch_)
+    setRegistrationID("AsyncSequence");
+  else
+    setRegistrationID("Sequence");
 }
 
 void SequenceNode::halt()
@@ -63,7 +69,8 @@ NodeStatus SequenceNode::tick()
         current_child_idx_++;
         // Return the execution flow if the child is async,
         // to make this interruptable.
-        if (requiresWakeUp() && prev_status == NodeStatus::IDLE &&
+        if (asynch_ && requiresWakeUp() &&
+            prev_status == NodeStatus::IDLE &&
             current_child_idx_ < children_count)
         {
           emitWakeUpSignal();

tests/CMakeLists.txt

@@ -16,6 +16,7 @@ set(BT_TESTS
   gtest_match.cpp
   gtest_ports.cpp
   gtest_json.cpp
+  gtest_reactive.cpp
   gtest_sequence.cpp
   gtest_skipping.cpp
   gtest_substitution.cpp

tests/gtest_reactive.cpp

@@ -0,0 +1,58 @@
+#include <gtest/gtest.h>
+#include "behaviortree_cpp/bt_factory.h"
+#include "test_helper.hpp"
+
+using BT::NodeStatus;
+using std::chrono::milliseconds;
+
+static const char* reactive_xml_text = R"(
+<root BTCPP_format="4" >
+  <BehaviorTree ID="MainTree">
+    <ReactiveSequence>
+      <Sequence name="first">
+        <TestA/>
+        <TestB/>
+        <TestC/>
+      </Sequence>
+      <AsyncSequence name="second">
+        <TestD/>
+        <TestE/>
+        <TestF/>
+      </AsyncSequence>
+    </ReactiveSequence>
+  </BehaviorTree>
+</root>
+)";
+
+
+TEST(Reactive, RunningChildren)
+{
+  BT::BehaviorTreeFactory factory;
+  std::array<int, 6> counters;
+  RegisterTestTick(factory, "Test", counters);
+
+  auto tree = factory.createTreeFromText(reactive_xml_text);
+
+  NodeStatus status = NodeStatus::IDLE;
+
+  int count=0;
+  while(!BT::isStatusCompleted(status) && count<100)
+  {
+    count++;
+    status = tree.tickExactlyOnce();
+  }
+
+  ASSERT_NE(100, count);
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+
+  ASSERT_EQ(counters[0], 3);
+  ASSERT_EQ(counters[1], 3);
+  ASSERT_EQ(counters[2], 3);
+
+  ASSERT_EQ(counters[3], 1);
+  ASSERT_EQ(counters[4], 1);
+  ASSERT_EQ(counters[5], 1);
+}
+
+