[COSMETIC]: non functional change in the code

Author: Davide Faconti

src/controls/fallback_node.cpp

@@ -22,47 +22,45 @@ FallbackNode::FallbackNode(const std::string& name) : ControlNode::ControlNode(n
 NodeStatus FallbackNode::tick()
 {
     // gets the number of children. The number could change if, at runtime, one edits the tree.
-    const unsigned N_of_children = children_nodes_.size();
+    const unsigned children_count = children_nodes_.size();
 
     // Routing the ticks according to the fallback node's logic:
 
     setStatus(NodeStatus::RUNNING);
 
-    for (unsigned i = 0; i < N_of_children; i++)
+    for (unsigned index = 0; index < children_count; index++)
     {
-        TreeNode* child_node = children_nodes_[i];
-
+        TreeNode* child_node = children_nodes_[index];
         const NodeStatus child_status = child_node->executeTick();
 
-        // Ponderate on which status to send to the parent
-        if (child_status != NodeStatus::FAILURE)
+        switch( child_status )
         {
-            if (child_status == NodeStatus::SUCCESS)
-            {
-                for (unsigned t = 0; t <= i; t++)
-                {
-                    children_nodes_[t]->setStatus(NodeStatus::IDLE);
-                }
-            }
-            // If the  child status is not failure, halt the next children and return the status to your parent.
-            haltChildren(i + 1);
+        case NodeStatus::RUNNING:{
             return child_status;
         }
-        else
-        {
-            // the child returned failure.
-            if (i == N_of_children - 1)
+        case NodeStatus::SUCCESS:{
+            for (unsigned t = 0; t <= index; t++)
             {
-                // If the  child status is failure, and it is the last child to be ticked,
-                // then the sequence has failed.
-                for (unsigned t = 0; t <= i; t++)
-                {
-                    children_nodes_[t]->setStatus(NodeStatus::IDLE);
-                }
-                return NodeStatus::FAILURE;
+                children_nodes_[t]->setStatus(NodeStatus::IDLE);
             }
+            haltChildren(index + 1);
+            return child_status;
         }
+        case NodeStatus::FAILURE: {
+            // continue;
+        }break;
+
+        case NodeStatus::IDLE:{
+            throw std::runtime_error("This is not supposed to happen");
+        }
+        } // end switch
+    }// end for loop
+
+    for (auto& ch : children_nodes_)
+    {
+        ch->setStatus(NodeStatus::IDLE);
     }
-    throw std::runtime_error("This is not supposed to happen");
+    return NodeStatus::FAILURE;
 }
+
 }

src/controls/fallback_star_node.cpp

@@ -24,12 +24,12 @@ FallbackStarNode::FallbackStarNode(const std::string& name)
 
 NodeStatus FallbackStarNode::tick()
 {
-    // Vector size initialization. N_of_children_ could change at runtime if you edit the tree
-    const unsigned N_of_children = children_nodes_.size();
+    // Vector size initialization. children_count_ could change at runtime if you edit the tree
+    const unsigned children_count = children_nodes_.size();
 
     setStatus(NodeStatus::RUNNING);
 
-    while (current_child_idx_ < N_of_children)
+    while (current_child_idx_ < children_count)
     {
         TreeNode* current_child_node = children_nodes_[current_child_idx_];
         const NodeStatus child_status = current_child_node->executeTick();
@@ -61,9 +61,9 @@ NodeStatus FallbackStarNode::tick()
     }// end while loop
 
     // The entire while loop completed. This means that all the children returned FAILURE.
-    if (current_child_idx_ == N_of_children)
+    if (current_child_idx_ == children_count)
     {
-        for (unsigned t = 0; t < N_of_children; t++)
+        for (unsigned t = 0; t < children_count; t++)
         {
             children_nodes_[t]->setStatus(NodeStatus::IDLE);
         }

src/controls/parallel_node.cpp

@@ -22,11 +22,11 @@ BT::NodeStatus BT::ParallelNode::tick()
 {
     success_childred_num_ = 0;
     failure_childred_num_ = 0;
-    // Vector size initialization. N_of_children_ could change at runtime if you edit the tree
-    const unsigned N_of_children = children_nodes_.size();
+    // Vector size initialization. children_count_ could change at runtime if you edit the tree
+    const unsigned children_count = children_nodes_.size();
 
     // Routing the tree according to the sequence node's logic:
-    for (unsigned int i = 0; i < N_of_children; i++)
+    for (unsigned int i = 0; i < children_count; i++)
     {
         TreeNode* child_node = children_nodes_[i];
 
@@ -46,7 +46,7 @@ BT::NodeStatus BT::ParallelNode::tick()
                 break;
             case NodeStatus::FAILURE:
                 child_node->setStatus(NodeStatus::IDLE);   // the child goes in idle if it has returned failure.
-                if (++failure_childred_num_ > N_of_children - threshold_M_)
+                if (++failure_childred_num_ > children_count - threshold_M_)
                 {
                     success_childred_num_ = 0;
                     failure_childred_num_ = 0;

src/controls/sequence_node.cpp

@@ -13,53 +13,52 @@
 
 #include "behavior_tree_core/controls/sequence_node.h"
 
-BT::SequenceNode::SequenceNode(const std::string& name) : ControlNode::ControlNode(name, NodeParameters())
+namespace BT
 {
-}
 
-BT::NodeStatus BT::SequenceNode::tick()
+SequenceNode::SequenceNode(const std::string& name) : ControlNode::ControlNode(name, NodeParameters())
 {
-    // gets the number of children. The number could change if, at runtime, one edits the tree.
-    const unsigned N_of_children = children_nodes_.size();
+}
 
-    // Routing the ticks according to the sequence node's logic:
+NodeStatus SequenceNode::tick()
+{
+    const unsigned children_count = children_nodes_.size();
 
     setStatus(NodeStatus::RUNNING);
 
-    for (unsigned int i = 0; i < N_of_children; i++)
+    for (unsigned int index = 0; index < children_count; index++)
     {
-        TreeNode* child_node = children_nodes_[i];
-
+        TreeNode* child_node = children_nodes_[index];
         const NodeStatus child_status = child_node->executeTick();
 
-        // Ponderate on which status to send to the parent
-        if (child_status != NodeStatus::SUCCESS)
+        switch( child_status )
         {
-            // If the  child status is not success, halt the next children and return the status to your parent.
-            if (child_status == NodeStatus::FAILURE)
-            {
-                for (unsigned t = 0; t <= i; t++)
+            case NodeStatus::RUNNING:{
+                return child_status;
+            }
+            case NodeStatus::FAILURE:{
+                for (unsigned t = 0; t <= index; t++)
                 {
                     children_nodes_[t]->setStatus(NodeStatus::IDLE);
                 }
+                haltChildren(index + 1);
+                return child_status;
             }
+            case NodeStatus::SUCCESS: {
+            // continue;
+            }break;
 
-            haltChildren(i + 1);
-            return child_status;
-        }
-        else
-        {
-            if (i == N_of_children - 1)
-            {
-                // If the  child status is success, and it is the last child to be ticked,
-                // then the sequence has succeeded.
-                for (auto& ch : children_nodes_)
-                {
-                    ch->setStatus(NodeStatus::IDLE);
-                }
-                return NodeStatus::SUCCESS;
+            case NodeStatus::IDLE:{
+                throw std::runtime_error("This is not supposed to happen");
             }
-        }
+        } // end switch
+    }// end for loop
+
+    for (auto& ch : children_nodes_)
+    {
+        ch->setStatus(NodeStatus::IDLE);
     }
-    throw std::runtime_error("This is not supposed to happen");
+    return NodeStatus::SUCCESS;
+}
+
 }

src/controls/sequence_star_node.cpp

@@ -33,12 +33,12 @@ SequenceStarNode::SequenceStarNode(const std::string& name, const NodeParameters
 
 NodeStatus SequenceStarNode::tick()
 {
-    // Vector size initialization. N_of_children_ could change at runtime if you edit the tree
-    const unsigned N_of_children = children_nodes_.size();
+    // Vector size initialization. children_count_ could change at runtime if you edit the tree
+    const unsigned children_count = children_nodes_.size();
 
     setStatus(NodeStatus::RUNNING);
 
-    while (current_child_idx_ < N_of_children)
+    while (current_child_idx_ < children_count)
     {
         TreeNode* current_child_node = children_nodes_[current_child_idx_];
         const NodeStatus child_status = current_child_node->executeTick();
@@ -77,9 +77,9 @@ NodeStatus SequenceStarNode::tick()
 
 
     // The entire while loop completed. This means that all the children returned SUCCESS.
-    if (current_child_idx_ == N_of_children)
+    if (current_child_idx_ == children_count)
     {
-        for (unsigned t = 0; t < N_of_children; t++)
+        for (unsigned t = 0; t < children_count; t++)
         {
             children_nodes_[t]->setStatus(NodeStatus::IDLE);
         }