Added support for transitions on state enter for HFSM

Author: ockeydockey

include/etl/fsm.h

@@ -160,18 +160,6 @@ namespace etl
     }
   };
 
-  //***************************************************************************
-  /// Exception for forbidden state changes.
-  //***************************************************************************
-  class fsm_state_composite_state_change_forbidden : public etl::fsm_exception
-  {
-  public:
-    fsm_state_composite_state_change_forbidden(string_type file_name_, numeric_type line_number_)
-      : etl::fsm_exception(ETL_ERROR_TEXT("fsm:change in composite state forbidden", ETL_FSM_FILE_ID"E"), file_name_, line_number_)
-    {
-    }
-  };
-
   //***************************************************************************
   /// Exception for message received but not started.
   //***************************************************************************
@@ -330,7 +318,6 @@ namespace etl
 
       if (p_default_child == ETL_NULLPTR)
       {
-        p_active_child = &state;
         p_default_child = &state;
       }
     }
@@ -481,7 +468,7 @@ namespace etl
     virtual void start(bool call_on_enter_state = true)
     {
       // Can only be started once.
-      if (p_state == ETL_NULLPTR)
+      if (!is_started())
       {
         p_state = state_list[0];
         ETL_ASSERT(p_state != ETL_NULLPTR, ETL_ERROR(etl::fsm_null_state_exception));
@@ -589,7 +576,7 @@ namespace etl
     //*******************************************
     virtual void reset(bool call_on_exit_state = false)
     {
-      if ((p_state != ETL_NULLPTR) && call_on_exit_state)
+      if (is_started() && call_on_exit_state)
       {
         p_state->on_exit_state();
       }

include/etl/hfsm.h

@@ -60,18 +60,32 @@ namespace etl
     void start(bool call_on_enter_state = true) ETL_OVERRIDE
     {
       // Can only be started once.
-      if (p_state == ETL_NULLPTR)
+      if (!is_started())
       {
-        p_state = state_list[0];
-        ETL_ASSERT(p_state != ETL_NULLPTR, ETL_ERROR(etl::fsm_null_state_exception));
+        etl::ifsm_state* p_first_state = state_list[0];
+        ETL_ASSERT(p_first_state != ETL_NULLPTR, ETL_ERROR(etl::fsm_null_state_exception));
+        p_state = p_first_state;
 
         if (call_on_enter_state)
         {
-          etl::fsm_state_id_t next_state = do_enters(ETL_NULLPTR, p_state, true);
+          do_enters_result result = do_enters(ETL_NULLPTR, p_first_state, true);
+          
+          if (result.active_state_id != ifsm_state::No_State_Change)
+          {
+            // If the active_state_id is not No_State_Change, it means that an on_enter changed the target state.
+            // Set the active state during that change as the present state before processing the state change.
+            ETL_ASSERT(result.active_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+            p_state = state_list[result.active_state_id];
 
-          if (next_state != ifsm_state::No_State_Change)
+            process_state_change(result.next_state_id);
+          }
+          else
           {
-            p_state = state_list[next_state];
+            if (have_changed_state(result.next_state_id))
+            {
+              ETL_ASSERT(result.next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+              p_state = state_list[result.next_state_id];
+            }
           }
         }
       }
@@ -83,7 +97,7 @@ namespace etl
     //*******************************************
     virtual void reset(bool call_on_exit_state = false) ETL_OVERRIDE
     {
-      if ((p_state != ETL_NULLPTR) && call_on_exit_state)
+      if (is_started() && call_on_exit_state)
       {
         do_exits(ETL_NULLPTR, p_state);
       }
@@ -151,10 +165,21 @@ namespace etl
       return s;
     }
 
+    //*******************************************
+    /// Result of a "do_enters()" call
+    //*******************************************
+    struct do_enters_result
+    {
+      // State which is presently being targeted as the next state
+      etl::fsm_state_id_t next_state_id;
+      // State which was active when the on_enter triggered a state change
+      etl::fsm_state_id_t active_state_id;
+    };
+
     //*******************************************
     /// Entering the state.
     //*******************************************
-    static etl::fsm_state_id_t do_enters(const etl::ifsm_state* p_root, etl::ifsm_state* p_target, bool activate_default_children)
+    static do_enters_result do_enters(const etl::ifsm_state* p_root, etl::ifsm_state* p_target, bool activate_default_children)
     {
       ETL_ASSERT(p_target != ETL_NULLPTR, ETL_ERROR(etl::fsm_null_state_exception));
 
@@ -164,15 +189,26 @@ namespace etl
         if (p_target->p_parent != p_root)
         {
           // The parent we're calling shouldn't activate its defaults, or this state will be deactivated.
-          do_enters(p_root, p_target->p_parent, false);
+          do_enters_result result = do_enters(p_root, p_target->p_parent, false);
+
+          // Short circuit the do enters if the parent state decided that a different state should be entered.
+          if (result.active_state_id != ifsm_state::No_State_Change)
+          {
+            return result;
+          }
         }
 
         // Set us as our parent's active child
         p_target->p_parent->p_active_child = p_target;
       }
 
       etl::fsm_state_id_t next_state = p_target->on_enter_state();
-      ETL_ASSERT(ifsm_state::No_State_Change == next_state, ETL_ERROR(etl::fsm_state_composite_state_change_forbidden));
+      
+      // Short circuit the activation of any child states if the target state changed
+      if (next_state != ifsm_state::No_State_Change)
+      {
+        return do_enters_result{next_state, p_target->get_state_id()};
+      }
 
       // Activate default child if we need to activate any initial states in an active composite state.
       if (activate_default_children)
@@ -182,13 +218,19 @@ namespace etl
           p_target = p_target->p_default_child;
           p_target->p_parent->p_active_child = p_target;
           next_state = p_target->on_enter_state();
-          ETL_ASSERT(ifsm_state::No_State_Change == next_state, ETL_ERROR(etl::fsm_state_composite_state_change_forbidden));
+
+          // Short circuit the activation of any child states if the target state changed
+          if (next_state != ifsm_state::No_State_Change)
+          {
+            return do_enters_result{next_state, p_target->get_state_id()};
+          }
         }
 
         next_state = p_target->get_state_id();
       }
 
-      return next_state;
+      // Wrapping No_State_Change in a static_cast gets rid of the "undefined reference" error when compiling on C++11
+      return do_enters_result{next_state, static_cast<fsm_state_id_t>(ifsm_state::No_State_Change)};
     }
 
     //*******************************************
@@ -217,25 +259,48 @@ namespace etl
     //*******************************************
     etl::fsm_state_id_t process_state_change(etl::fsm_state_id_t next_state_id) ETL_OVERRIDE
     {
-      if (have_changed_state(next_state_id))
+      if (is_self_transition(next_state_id))
+      {
+        p_state->on_exit_state();
+        next_state_id = p_state->on_enter_state();
+      } 
+
+      while (have_changed_state(next_state_id))
       {
         ETL_ASSERT_OR_RETURN_VALUE(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception), p_state->get_state_id());
 
         etl::ifsm_state* p_next_state = state_list[next_state_id];
         etl::ifsm_state* p_root       = common_ancestor(p_state, p_next_state);
 
         do_exits(p_root, p_state);
-        next_state_id = do_enters(p_root, p_next_state, true);
 
-        ETL_ASSERT_OR_RETURN_VALUE(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception), p_state->get_state_id());
-        p_state = state_list[next_state_id];
-      }
-      else if (is_self_transition(next_state_id))
-      {
-        p_state->on_exit_state();
-        p_state->on_enter_state();
-      }
+        do_enters_result result = do_enters(p_root, p_next_state, true);
+        next_state_id = result.next_state_id;
 
+        if (result.active_state_id != ifsm_state::No_State_Change)
+        {
+          // If the active_state_id is not No_State_Change, it means that an on_enter changed the target state.
+          // Set the state pointer as the active state to use it as the new origin for the transition to the
+          // updated target state
+          ETL_ASSERT(result.active_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          p_state = state_list[result.active_state_id];
+          ETL_ASSERT(result.next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          p_next_state = state_list[result.next_state_id];
+        }
+        else if (result.next_state_id != ifsm_state::No_State_Change)
+        {
+          // If the next state is different, means that default children were activated.
+          // Assign both p_state and p_next_state to get out of the loop.
+          ETL_ASSERT(result.next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          p_state = state_list[result.next_state_id];
+          p_next_state = state_list[result.next_state_id];
+        }
+        else
+        {
+          p_state = p_next_state;
+        }
+      }
+      
       return p_state->get_state_id();
     }
   };

test/CMakeLists.txt

@@ -194,6 +194,7 @@ add_executable(etl_tests
 	test_hash.cpp
 	test_hfsm.cpp
 	test_hfsm_recurse_to_inner_state_on_start.cpp
+	test_hfsm_transition_on_enter.cpp
 	test_histogram.cpp
 	test_index_of_type.cpp
 	test_indirect_vector.cpp