simplified policy of nodes with memory

Davide Faconti · Davide Faconti · commit 295eb1f12324 · 2018-10-09T13:51:49.000+02:00
diff --git a/include/behavior_tree_core/basic_types.h b/include/behavior_tree_core/basic_types.h
@@ -48,12 +48,7 @@ enum FailurePolicy
     FAIL_ON_ONE,
     FAIL_ON_ALL
 };
-enum ResetPolicy
-{
-    ON_SUCCESS_OR_FAILURE,
-    ON_SUCCESS,
-    ON_FAILURE
-};
+
 
 // Enumerates the options for when a parallel node is considered to have succeeded:
 // - "SUCCEED_ON_ONE" indicates that the node will return success as soon as one
@@ -85,13 +80,6 @@ const char* toStr(const BT::NodeType& type);
 
 std::ostream& operator<<(std::ostream& os, const BT::NodeType& type);
 
-/**
- * @brief toStr converts ResetPolicy to string.
- */
-const char* toStr(const BT::ResetPolicy& policy);
-
-std::ostream& operator<<(std::ostream& os, const BT::ResetPolicy& type);
-
 // small utility, unless you want to use <boost/algorithm/string.hpp>
 std::vector<std::string> splitString(const std::string& strToSplit, char delimeter);
 
diff --git a/include/behavior_tree_core/controls/fallback_node.h b/include/behavior_tree_core/controls/fallback_node.h
@@ -20,20 +20,17 @@ namespace BT
 {
 
 /**
- * @brief The FallbackNode is used when you want to evaluate different "strategies".
+ * @brief The FallbackNode is used to try different strategies,
+ * until one succeed.
+ * If any child returns RUNNING, previous children will be ticked again.
  *
- * This control node ticks its children UNTIL one of them returns SUCCESS.
+ * - If all the children return FAILURE, this node returns FAILURE.
  *
- * In that case it return SUCCESS, otherwise it return FAILURE.
- * If it finds a child returning RUNNING, it returns RUNNING and it restarts from the first child.
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   The loop is restarted, but already completed children are not halted.
+ *   This generally implies that ConditionNode are ticked again.
  *
- * If you don't want to restart from the first child, use FallbackNodeWithMemory instead.
- *
- * Example: three children, A, B and C
- *
- * 1) A returns FAILURE. Continue.
- * 2) B returns RUNNING, Restart from A
- * 3) A returns FAILURE again but B return SUCCESS. Stop and return SUCCESS.
+ * - If a child returns SUCCESS, stop the loop and returns SUCCESS.
  *
  */
 class FallbackNode : public ControlNode
diff --git a/include/behavior_tree_core/controls/fallback_node_with_memory.h b/include/behavior_tree_core/controls/fallback_node_with_memory.h
@@ -20,46 +20,28 @@ namespace BT
 {
 
 /**
- * @brief The FallbackNodeWithMemory is used when you want to evaluate different "strategies".
+ * @brief The FallbackNodeWithMemory is used to try different strategies,
+ * until one succeed.
+ * If any child returns RUNNING, previous children will NOT be ticked again.
  *
- * This control node ticks its children UNTIL one of them returns SUCCESS.
+ * - If all the children return FAILURE, this node returns FAILURE.
  *
- * In that case it returns SUCCESS, otherwise it returns FAILURE.
- * If a child return RUNNING, this node returns RUNNING and at the next tick it will continue
- * from the same index.
- * It is recommended for asynchronous children which may return RUNNING.
- *
- * Example: three children, A, B and C
- *
- * 1) A returns FAILURE. Continue.
- * 2) B returns RUNNING. Stop and return RUNNING.
- * 3) B is ticked again but it returns SUCCESS. Stop and return SUCCESS.
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   Loop is NOT restarted, the same running child will be ticked again.
  *
+ * - If a child returns SUCCESS, stop the loop and returns SUCCESS.
  */
 
 class FallbackNodeWithMemory : public ControlNode
 {
   public:
-    FallbackNodeWithMemory(const std::string& name, ResetPolicy reset_policy = BT::ON_SUCCESS_OR_FAILURE);
-
-    // Reset policy passed by parameter [reset_policy]
-    FallbackNodeWithMemory(const std::string&, const NodeParameters& params);
-
-    virtual ~FallbackNodeWithMemory() override = default;
+    FallbackNodeWithMemory(const std::string& name);
 
     virtual void halt() override;
 
-    static const NodeParameters& requiredNodeParameters()
-    {
-        static NodeParameters params = {{RESET_POLICY, toStr(BT::ON_SUCCESS_OR_FAILURE)}};
-        return params;
-    }
-
   private:
     unsigned int current_child_idx_;
-    ResetPolicy reset_policy_;
 
-    constexpr static const char* RESET_POLICY = "reset_policy";
     virtual BT::NodeStatus tick() override;
 };
 }
diff --git a/include/behavior_tree_core/controls/sequence_node.h b/include/behavior_tree_core/controls/sequence_node.h
@@ -19,22 +19,17 @@
 namespace BT
 {
 /**
- * @brief The SequenceNode is used to execute a sequence of synchronous children.
+ * @brief The SequenceNode is used to execute a sequence of children.
+ * If any child returns RUNNING, previous children will be ticked again.
  *
- * This control node ticks its children AS LONG AS they returns SUCCESS.
+ * - If all the children return SUCCESS, this node returns SUCCESS.
  *
- * If all the children return SUCCESS, the sequence is SUCCESS.
- * If any return FAILURE, the sequence returns FAILURE and it starts from the beginning.
- * If a child returns RUNNING, this node returns RUNNING and at the next tick it will continue
- * from the same index.
- * It is recommended for asynchronous children which may return RUNNING.
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   The loop is restarted, but already completed children are not halted.
+ *   This generally implies that ConditionNode are ticked again.
  *
- * Example: three children, A , B and C
+ * - If a child returns FAILURE, stop the loop and returns FAILURE.
  *
- * 1) A returns SUCCESS. Continue.
- * 2) B returns RUNNING. Stop and return RUNNING.
- * 3) A is ticked again and return SUCCESS. B is ticked and retuns SUCCESS. Continue.
- * 4) C returns SUCCESS. The entire sequence returns SUCCESS.
  */
 class SequenceNode : public ControlNode
 {
diff --git a/include/behavior_tree_core/controls/sequence_node_with_memory.h b/include/behavior_tree_core/controls/sequence_node_with_memory.h
@@ -20,24 +20,23 @@ namespace BT
 {
 
 /**
- * @brief The SequenceNode is used to execute a sequence of asynchronous children.
+ * @brief The SequenceNodeWithMemory is used to execute a sequence of children.
+ * If any child returns RUNNING, previous children are not ticked again.
  *
- * Tick all the children as long as they return SUCCESS.
- * If any child return FAILURE, stop the sequence and return FAILURE.
- * If any child return RUNNING, stop the sequence, return RUNNING. Restart from the same child
+ * - If all the children return SUCCESS, this node returns SUCCESS.
  *
- * Example: three children, A , B and C
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   Loop is NOT restarted, the same running child will be ticked again.
+ *
+ * - If a child returns FAILURE, stop the loop and returns FAILURE.
+ *   Restart the loop only if (reset_on_failure == true)
  *
- * 1) A returns SUCCESS. Continue.
- * 2) B returns RUNNING. Stop and return RUNNING.
- * 3) B is ticked and retuns SUCCESS. Continue.
- * 4) C returns SUCCESS. The entire sequence returns SUCCESS.
  */
 
 class SequenceNodeWithMemory : public ControlNode
 {
   public:
-    SequenceNodeWithMemory(const std::string& name, ResetPolicy reset_policy = BT::ON_SUCCESS_OR_FAILURE);
+    SequenceNodeWithMemory(const std::string& name, bool reset_on_failure = true);
 
     // Reset policy passed by parameter [reset_policy]
     SequenceNodeWithMemory(const std::string& name, const NodeParameters& params);
@@ -48,15 +47,14 @@ class SequenceNodeWithMemory : public ControlNode
 
     static const NodeParameters& requiredNodeParameters()
     {
-        static NodeParameters params = {{RESET_POLICY, toStr(BT::ON_SUCCESS_OR_FAILURE)}};
+        static NodeParameters params = {{"reset_on_failure", "true"}};
         return params;
     }
 
   private:
     unsigned int current_child_idx_;
-    ResetPolicy reset_policy_;
+    bool reset_on_failure_;
 
-    static constexpr const char* RESET_POLICY = "reset_policy";
     virtual BT::NodeStatus tick() override;
 };
 }
diff --git a/src/basic_types.cpp b/src/basic_types.cpp
@@ -63,21 +63,6 @@ const char* toStr(const NodeType& type)
     }
 }
 
-const char* toStr(const ResetPolicy& policy)
-{
-    switch (policy)
-    {
-        case ResetPolicy::ON_FAILURE:
-            return "ON_FAILURE";
-        case ResetPolicy::ON_SUCCESS:
-            return "ON_SUCCESS";
-        case ResetPolicy::ON_SUCCESS_OR_FAILURE:
-            return "ON_SUCCESS_OR_FAILURE";
-        default:
-            return "Undefined";
-    }
-}
-
 template <>
 std::string convertFromString<std::string>(const std::string& str)
 {
@@ -110,45 +95,73 @@ double convertFromString<double>(const std::string& str)
 }
 
 template <>
-NodeStatus convertFromString<NodeStatus>(const std::string& str)
+bool convertFromString<bool>(const std::string& str)
 {
-    for (auto status : {NodeStatus::IDLE, NodeStatus::RUNNING, NodeStatus::SUCCESS, NodeStatus::FAILURE})
+    if( str.size() == 1)
     {
-        if (std::strcmp(toStr(status), str.c_str()) == 0)
+        if ( str[0] == '0'){
+            return false;
+        }
+        else if( str[0] == '1'){
+            return true;
+        }
+        else{
+            std::runtime_error("invalid bool conversion");
+        }
+    }
+    else if( str.size() == 4)
+    {
+        if( str == "true" || str == "TRUE" || str == "True")
         {
-            return status;
+            return true;
+        }
+        else{
+            std::runtime_error("invalid bool conversion");
         }
     }
-    throw std::invalid_argument(std::string("Cannot convert this to NodeStatus: ") + str);
+    else if( str.size() == 5)
+    {
+        if( str == "false" || str == "FALSE" || str == "False")
+        {
+            return false;
+        }
+        else{
+            std::runtime_error("invalid bool conversion");
+        }
+    }
+
+    std::runtime_error("invalid bool conversion");
+    return false;
 }
 
 template <>
-NodeType convertFromString<NodeType>(const std::string& str)
+NodeStatus convertFromString<NodeStatus>(const std::string& str)
 {
-    for (auto status : {NodeType::ACTION, NodeType::CONDITION, NodeType::CONTROL, NodeType::DECORATOR,
-                        NodeType::SUBTREE, NodeType::UNDEFINED})
+    for (auto status : {NodeStatus::IDLE, NodeStatus::RUNNING, NodeStatus::SUCCESS, NodeStatus::FAILURE})
     {
         if (std::strcmp(toStr(status), str.c_str()) == 0)
         {
             return status;
         }
     }
-    throw std::invalid_argument(std::string("Cannot convert this to NodeType: ") + str);
+    throw std::invalid_argument(std::string("Cannot convert this to NodeStatus: ") + str);
 }
 
 template <>
-ResetPolicy convertFromString<ResetPolicy>(const std::string& str)
+NodeType convertFromString<NodeType>(const std::string& str)
 {
-    for (auto status : {ResetPolicy::ON_SUCCESS, ResetPolicy::ON_SUCCESS_OR_FAILURE, ResetPolicy::ON_FAILURE})
+    for (auto status : {NodeType::ACTION, NodeType::CONDITION, NodeType::CONTROL, NodeType::DECORATOR,
+                        NodeType::SUBTREE, NodeType::UNDEFINED})
     {
         if (std::strcmp(toStr(status), str.c_str()) == 0)
         {
             return status;
         }
     }
-    throw std::invalid_argument(std::string("Cannot convert this to ResetPolicy: ") + str);
+    throw std::invalid_argument(std::string("Cannot convert this to NodeType: ") + str);
 }
 
+
 std::ostream &operator<<(std::ostream &os, const NodeType &type)
 {
     os << toStr(type);
@@ -161,11 +174,6 @@ std::ostream &operator<<(std::ostream &os, const NodeStatus &status)
     return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const ResetPolicy &type)
-{
-    os << toStr(type);
-    return os;
-}
 
 std::vector<std::string> splitString(const std::string &strToSplit, char delimeter)
 {
diff --git a/src/controls/fallback_node_with_memory.cpp b/src/controls/fallback_node_with_memory.cpp
diff --git a/src/controls/sequence_node_with_memory.cpp b/src/controls/sequence_node_with_memory.cpp

Original file line number	Diff line number	Diff line change
`@@ -20,20 +20,17 @@ namespace BT`
`20`	`20`	`{`
`21`	`21`
`22`	`22`	`/**`
`23`		`- * @brief The FallbackNode is used when you want to evaluate different "strategies".`
	`23`	`+ * @brief The FallbackNode is used to try different strategies,`
	`24`	`+ * until one succeed.`
	`25`	`+ * If any child returns RUNNING, previous children will be ticked again.`
`24`	`26`	`*`
`25`		`- * This control node ticks its children UNTIL one of them returns SUCCESS.`
	`27`	`+ * - If all the children return FAILURE, this node returns FAILURE.`
`26`	`28`	`*`
`27`		`- * In that case it return SUCCESS, otherwise it return FAILURE.`
`28`		`- * If it finds a child returning RUNNING, it returns RUNNING and it restarts from the first child.`
	`29`	`+ * - If a child returns RUNNING, this node returns RUNNING.`
	`30`	`+ * The loop is restarted, but already completed children are not halted.`
	`31`	`+ * This generally implies that ConditionNode are ticked again.`
`29`	`32`	`*`
`30`		`- * If you don't want to restart from the first child, use FallbackNodeWithMemory instead.`
`31`		`- *`
`32`		`- * Example: three children, A, B and C`
`33`		`- *`
`34`		`- * 1) A returns FAILURE. Continue.`
`35`		`- * 2) B returns RUNNING, Restart from A`
`36`		`- * 3) A returns FAILURE again but B return SUCCESS. Stop and return SUCCESS.`
	`33`	`+ * - If a child returns SUCCESS, stop the loop and returns SUCCESS.`
`37`	`34`	`*`
`38`	`35`	`*/`
`39`	`36`	`class FallbackNode : public ControlNode`
Original file line number	Diff line number	Diff line change
`@@ -19,22 +19,17 @@`
`19`	`19`	`namespace BT`
`20`	`20`	`{`
`21`	`21`	`/**`
`22`		`- * @brief The SequenceNode is used to execute a sequence of synchronous children.`
	`22`	`+ * @brief The SequenceNode is used to execute a sequence of children.`
	`23`	`+ * If any child returns RUNNING, previous children will be ticked again.`
`23`	`24`	`*`
`24`		`- * This control node ticks its children AS LONG AS they returns SUCCESS.`
	`25`	`+ * - If all the children return SUCCESS, this node returns SUCCESS.`
`25`	`26`	`*`
`26`		`- * If all the children return SUCCESS, the sequence is SUCCESS.`
`27`		`- * If any return FAILURE, the sequence returns FAILURE and it starts from the beginning.`
`28`		`- * If a child returns RUNNING, this node returns RUNNING and at the next tick it will continue`
`29`		`- * from the same index.`
`30`		`- * It is recommended for asynchronous children which may return RUNNING.`
	`27`	`+ * - If a child returns RUNNING, this node returns RUNNING.`
	`28`	`+ * The loop is restarted, but already completed children are not halted.`
	`29`	`+ * This generally implies that ConditionNode are ticked again.`
`31`	`30`	`*`
`32`		`- * Example: three children, A , B and C`
	`31`	`+ * - If a child returns FAILURE, stop the loop and returns FAILURE.`
`33`	`32`	`*`
`34`		`- * 1) A returns SUCCESS. Continue.`
`35`		`- * 2) B returns RUNNING. Stop and return RUNNING.`
`36`		`- * 3) A is ticked again and return SUCCESS. B is ticked and retuns SUCCESS. Continue.`
`37`		`- * 4) C returns SUCCESS. The entire sequence returns SUCCESS.`
`38`	`33`	`*/`
`39`	`34`	`class SequenceNode : public ControlNode`
`40`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -63,21 +63,6 @@ const char* toStr(const NodeType& type)`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`		`-const char* toStr(const ResetPolicy& policy)`
`67`		`-{`
`68`		`- switch (policy)`
`69`		`- {`
`70`		`- case ResetPolicy::ON_FAILURE:`
`71`		`- return "ON_FAILURE";`
`72`		`- case ResetPolicy::ON_SUCCESS:`
`73`		`- return "ON_SUCCESS";`
`74`		`- case ResetPolicy::ON_SUCCESS_OR_FAILURE:`
`75`		`- return "ON_SUCCESS_OR_FAILURE";`
`76`		`- default:`
`77`		`- return "Undefined";`
`78`		`- }`
`79`		`-}`
`80`		`-`
`81`	`66`	`template <>`
`82`	`67`	`std::string convertFromString<std::string>(const std::string& str)`
`83`	`68`	`{`
`@@ -110,45 +95,73 @@ double convertFromString<double>(const std::string& str)`
`110`	`95`	`}`
`111`	`96`
`112`	`97`	`template <>`
`113`		`-NodeStatus convertFromString<NodeStatus>(const std::string& str)`
	`98`	`+bool convertFromString<bool>(const std::string& str)`
`114`	`99`	`{`
`115`		`- for (auto status : {NodeStatus::IDLE, NodeStatus::RUNNING, NodeStatus::SUCCESS, NodeStatus::FAILURE})`
	`100`	`+ if( str.size() == 1)`
`116`	`101`	`{`
`117`		`- if (std::strcmp(toStr(status), str.c_str()) == 0)`
	`102`	`+ if ( str[0] == '0'){`
	`103`	`+ return false;`
	`104`	`+ }`
	`105`	`+ else if( str[0] == '1'){`
	`106`	`+ return true;`
	`107`	`+ }`
	`108`	`+ else{`
	`109`	`+ std::runtime_error("invalid bool conversion");`
	`110`	`+ }`
	`111`	`+ }`
	`112`	`+ else if( str.size() == 4)`
	`113`	`+ {`
	`114`	`+ if( str == "true" \|\| str == "TRUE" \|\| str == "True")`
`118`	`115`	`{`
`119`		`- return status;`
	`116`	`+ return true;`
	`117`	`+ }`
	`118`	`+ else{`
	`119`	`+ std::runtime_error("invalid bool conversion");`
`120`	`120`	`}`
`121`	`121`	`}`
`122`		`- throw std::invalid_argument(std::string("Cannot convert this to NodeStatus: ") + str);`
	`122`	`+ else if( str.size() == 5)`
	`123`	`+ {`
	`124`	`+ if( str == "false" \|\| str == "FALSE" \|\| str == "False")`
	`125`	`+ {`
	`126`	`+ return false;`
	`127`	`+ }`
	`128`	`+ else{`
	`129`	`+ std::runtime_error("invalid bool conversion");`
	`130`	`+ }`
	`131`	`+ }`
	`132`	`+`
	`133`	`+ std::runtime_error("invalid bool conversion");`
	`134`	`+ return false;`
`123`	`135`	`}`
`124`	`136`
`125`	`137`	`template <>`
`126`		`-NodeType convertFromString<NodeType>(const std::string& str)`
	`138`	`+NodeStatus convertFromString<NodeStatus>(const std::string& str)`
`127`	`139`	`{`
`128`		`- for (auto status : {NodeType::ACTION, NodeType::CONDITION, NodeType::CONTROL, NodeType::DECORATOR,`
`129`		`- NodeType::SUBTREE, NodeType::UNDEFINED})`
	`140`	`+ for (auto status : {NodeStatus::IDLE, NodeStatus::RUNNING, NodeStatus::SUCCESS, NodeStatus::FAILURE})`
`130`	`141`	`{`
`131`	`142`	`if (std::strcmp(toStr(status), str.c_str()) == 0)`
`132`	`143`	`{`
`133`	`144`	`return status;`
`134`	`145`	`}`
`135`	`146`	`}`
`136`		`- throw std::invalid_argument(std::string("Cannot convert this to NodeType: ") + str);`
	`147`	`+ throw std::invalid_argument(std::string("Cannot convert this to NodeStatus: ") + str);`
`137`	`148`	`}`
`138`	`149`
`139`	`150`	`template <>`
`140`		`-ResetPolicy convertFromString<ResetPolicy>(const std::string& str)`
	`151`	`+NodeType convertFromString<NodeType>(const std::string& str)`
`141`	`152`	`{`
`142`		`- for (auto status : {ResetPolicy::ON_SUCCESS, ResetPolicy::ON_SUCCESS_OR_FAILURE, ResetPolicy::ON_FAILURE})`
	`153`	`+ for (auto status : {NodeType::ACTION, NodeType::CONDITION, NodeType::CONTROL, NodeType::DECORATOR,`
	`154`	`+ NodeType::SUBTREE, NodeType::UNDEFINED})`
`143`	`155`	`{`
`144`	`156`	`if (std::strcmp(toStr(status), str.c_str()) == 0)`
`145`	`157`	`{`
`146`	`158`	`return status;`
`147`	`159`	`}`
`148`	`160`	`}`
`149`		`- throw std::invalid_argument(std::string("Cannot convert this to ResetPolicy: ") + str);`
	`161`	`+ throw std::invalid_argument(std::string("Cannot convert this to NodeType: ") + str);`
`150`	`162`	`}`
`151`	`163`
	`164`	`+`
`152`	`165`	`std::ostream &operator<<(std::ostream &os, const NodeType &type)`
`153`	`166`	`{`
`154`	`167`	`os << toStr(type);`
`@@ -161,11 +174,6 @@ std::ostream &operator<<(std::ostream &os, const NodeStatus &status)`
`161`	`174`	`return os;`
`162`	`175`	`}`
`163`	`176`
`164`		`-std::ostream &operator<<(std::ostream &os, const ResetPolicy &type)`
`165`		`-{`
`166`		`- os << toStr(type);`
`167`		`- return os;`
`168`		`-}`
`169`	`177`
`170`	`178`	`std::vector<std::string> splitString(const std::string &strToSplit, char delimeter)`
`171`	`179`	`{`