parallel node fix

Author: facontidavide

include/behaviortree_cpp_v3/controls/parallel_node.h

@@ -20,29 +20,50 @@
 namespace BT
 {
 
+/**
+ * @brief The ParallelNode execute all its children
+ * __concurrently__, but not in separate threads!
+ *
+ * Even if this may look similar to ReactiveSequence,
+ * this Control Node is the only one that may have
+ * multiple children in the RUNNING state at the same time.
+ *
+ * The Node is completed either when the THRESHOLD_SUCCESS
+ * or THRESHOLD_FAILURE number is reached (both configured using ports).
+ *
+ * If any of the threahold is reached, and other childen are still running,
+ * they will be halted.
+ *
+ * Note that threshold indexes work as in Python:
+ * https://www.i2tutorials.com/what-are-negative-indexes-and-why-are-they-used/
+ *
+ * Therefore -1 is equivalent to the number of children.
+ */
 class ParallelNode : public ControlNode
 {
   public:
 
-    ParallelNode(const std::string& name, unsigned success_threshold,
-                 unsigned failure_threshold = 1);
+    ParallelNode(const std::string& name, int success_threshold,
+                 int failure_threshold = 1);
 
     ParallelNode(const std::string& name, const NodeConfiguration& config);
 
     static PortsList providedPorts()
     {
-        return { InputPort<unsigned>(THRESHOLD_SUCCESS, "number of childen which need to succeed to trigger a SUCCESS" ),
-                 InputPort<unsigned>(THRESHOLD_FAILURE, 1, "number of childen which need to fail to trigger a FAILURE" ) };
+        return { InputPort<int>(THRESHOLD_SUCCESS,
+                              "number of childen which need to succeed to trigger a SUCCESS" ),
+                 InputPort<int>(THRESHOLD_FAILURE, 1,
+                              "number of childen which need to fail to trigger a FAILURE" ) };
     }
 
     ~ParallelNode() = default;
 
     virtual void halt() override;
 
-    unsigned int thresholdM();
-    unsigned int thresholdFM();
-    void setThresholdM(int threshold_M);
-    void setThresholdFM(int threshold_M);
+    size_t successThreshold() const;
+    size_t failureThreshold() const;
+    void setSuccessThreshold(int threshold_M);
+    void setFailureThreshold(int threshold_M);
 
   private:
     int success_threshold_;

src/controls/parallel_node.cpp

@@ -22,8 +22,8 @@ namespace BT
 constexpr const char* ParallelNode::THRESHOLD_FAILURE;
 constexpr const char* ParallelNode::THRESHOLD_SUCCESS;
 
-ParallelNode::ParallelNode(const std::string& name, unsigned success_threshold,
-                           unsigned failure_threshold)
+ParallelNode::ParallelNode(const std::string& name, int success_threshold,
+                           int failure_threshold)
     : ControlNode::ControlNode(name, {} ),
     success_threshold_(success_threshold),
     failure_threshold_(failure_threshold),
@@ -61,12 +61,12 @@ NodeStatus ParallelNode::tick()
 
     const size_t children_count = children_nodes_.size();
 
-    if( children_count < thresholdM())
+    if( children_count < successThreshold())
     {
         throw LogicError("Number of children is less than threshold. Can never succeed.");
     }
 
-    if( children_count < thresholdFM())
+    if( children_count < failureThreshold())
     {
         throw LogicError("Number of children is less than threshold. Can never fail.");
     }
@@ -97,7 +97,7 @@ NodeStatus ParallelNode::tick()
                 }
                 success_childred_num++;
 
-                if (success_childred_num == thresholdM())
+                if (success_childred_num == successThreshold())
                 {
                     skip_list_.clear();
                     haltChildren();
@@ -115,8 +115,8 @@ NodeStatus ParallelNode::tick()
 
                 // It fails if it is not possible to succeed anymore or if 
                 // number of failures are equal to failure_threshold_
-                if ((failure_childred_num > children_count - thresholdM())
-                    || (failure_childred_num == thresholdFM()))
+                if ((failure_childred_num > children_count - successThreshold())
+                    || (failure_childred_num == failureThreshold()))
                 {
                     skip_list_.clear();
                     haltChildren();
@@ -145,26 +145,26 @@ void ParallelNode::halt()
     ControlNode::halt();
 }
 
-unsigned int ParallelNode::thresholdM()
+size_t ParallelNode::successThreshold() const
 {
     return success_threshold_ < 0
-      ? std::max(children_nodes_.size() + success_threshold_ + 1, static_cast<std::size_t>(0))
+           ? std::max(children_nodes_.size() + success_threshold_ + 1, size_t(0))
       : success_threshold_;
 }
 
-unsigned int ParallelNode::thresholdFM()
+size_t ParallelNode::failureThreshold() const
 {
     return failure_threshold_ < 0
-      ? std::max(children_nodes_.size() + failure_threshold_ + 1, static_cast<std::size_t>(0))
+           ? std::max(children_nodes_.size() + failure_threshold_ + 1, size_t(0))
       : failure_threshold_;
 }
 
-void ParallelNode::setThresholdM(int threshold_M)
+void ParallelNode::setSuccessThreshold(int threshold_M)
 {
     success_threshold_ = threshold_M;
 }
 
-void ParallelNode::setThresholdFM(int threshold_M)
+void ParallelNode::setFailureThreshold(int threshold_M)
 {
     failure_threshold_ = threshold_M;
 }