Fix bug in executing entry/exit actions in self-transitions

Author: dziegel

include/cpp_event_framework/Statemachine.hxx

@@ -511,7 +511,7 @@ public:
         AssertionProviderType::Assert(impl_ != nullptr); // Most probably you forgot to call Init()
         current_state_ = &kInTransition;
         initial_.clear();
-        EnterStatesFromDownTo(nullptr, initial, {});
+        EnterStatesFromDownTo(nullptr, initial, false, {});
     }
 
     /**
@@ -528,6 +528,7 @@ public:
         Transition transition(kInTransition);
         const auto* start = current_state_;
         const auto* s = current_state_;
+        bool is_self_transition = false;
 
         do
         {
@@ -544,9 +545,17 @@ public:
                 working_ = false;
                 return;
             }
+            if (transition.target_ != nullptr)
+            {
+                if (transition.target_ == s)
+                {
+                    is_self_transition = true;
+                }
+                break;
+            }
 
             s = s->parent_;
-        } while ((transition.target_ == nullptr) && (s != nullptr));
+        } while (s != nullptr);
 
         if ((transition.target_ != nullptr))
         {
@@ -562,9 +571,9 @@ public:
                     on_state_change_(*this, event, *old_state, *transition.target_);
                 }
 
-                ExitStatesFromUpTo(old_state, common_parent, event);
+                ExitStatesFromUpTo(old_state, common_parent, is_self_transition, event);
                 transition.ExecuteActions(impl_, event);
-                EnterStatesFromDownTo(common_parent, transition.target_, event);
+                EnterStatesFromDownTo(common_parent, transition.target_, is_self_transition, event);
             }
             else
             {
@@ -788,31 +797,29 @@ private:
         }
     }
 
-    void ExitStatesFromUpTo(StatePtr from, StatePtr top, Event event)
+    void ExitStatesFromUpTo(StatePtr from, StatePtr top, bool is_self_transition, Event event)
     {
         const auto* state = from;
 
-        if (state == top)
+        while (state != top)
         {
-            ExitState(state, event);
-        }
-        else
-        {
-            while (state != top)
+            // Save history state
+            if (state->parent_ != nullptr)
             {
-                // Save history state
-                if (state->parent_ != nullptr)
+                if ((state->parent_->flags_ & EFlags::kHistory) != EFlags::kNone)
                 {
-                    if ((state->parent_->flags_ & EFlags::kHistory) != EFlags::kNone)
-                    {
-                        SetInitialState(state->parent_, state);
-                    }
+                    SetInitialState(state->parent_, state);
                 }
+            }
 
-                ExitState(state, event);
+            ExitState(state, event);
 
-                state = state->parent_;
-            }
+            state = state->parent_;
+        }
+
+        if (is_self_transition)
+        {
+            ExitState(state, event);
         }
     }
 
@@ -839,16 +846,19 @@ private:
         }
     }
 
-    void EnterStatesFromDownTo(StatePtr top, StatePtr target, Event event)
+    void EnterStatesFromDownTo(StatePtr top, StatePtr target, bool is_self_transition, Event event)
     {
         // Enter all states up to parent
         if (top != target)
         {
             EnterStatesFromDownToRecursive(top, target->parent_, event);
+            EnterState(*target, event);
         }
-
-        // Alywas enter target state (we may have exited it, possibly a self transition)
-        EnterState(*target, event);
+        else if (is_self_transition)
+        {
+            EnterState(*target, event);
+        }
+        // else: no enter when we have a direct transition from an inner state to a parent state
 
         // Is target a hierarchical state? If so, enter initial state
         const auto* state = GetInitialState(target);