Update initial submachines of composite states upon re-entry

When a composite state is re-entered due to an event any submachines
within the state also need to be initialized, or they will remain in
their previous terminated state.

- Recursively call update_composite_state on any initial states that
are themselves composite
- Add a test for this situation

Author: jefftrull

include/boost/sml.hpp

@@ -258,6 +258,14 @@ using remove_pointer_t = typename remove_pointer<T>::type;
 }  // namespace aux
 namespace aux {
 using swallow = int[];
+template<typename F, template<class...> class L, class... Ts>
+void for_each(L<Ts...>, F f) {
+#if defined(__cpp_fold_expressions)
+  (f(identity<Ts>{}),...);
+#else
+  (void)aux::swallow{0, (f(identity<Ts>{}), 0)...};
+#endif
+}
 template <int...>
 struct index_sequence {
   using type = index_sequence;
@@ -2598,9 +2606,31 @@ constexpr void update_composite_states(TSubs &subs, aux::true_type, const aux::t
                          0)...};
 #endif
 }
+namespace detail {
+template<class T>
+struct is_composite_state {
+  constexpr static bool value = false;
+};
+template<class T>
+struct is_composite_state<back::sm<T>> {
+  constexpr static bool value = true;
+};
+template<class T>
+constexpr bool is_composite_state_v = is_composite_state<T>::value;
+} // namespace detail
+
 template <class T, class TSubs, class... Ts>
 constexpr void update_composite_states(TSubs &subs, aux::false_type, Ts &&...) {
   back::sub_sm<T>::get(&subs).initialize(typename T::initial_states_t{});
+
+  aux::for_each(typename T::initial_states_t{},
+                [&](auto state_identity){
+                  using state_t = typename decltype(state_identity)::type;
+                  if constexpr (detail::is_composite_state_v<state_t>) {
+                    using sm_impl_t = aux::apply_t<back::sm_impl, state_t>;
+                    update_composite_states<sm_impl_t>(subs, aux::false_type{}, Ts{}...);
+                  }
+                });
 }
 template <class SM, class TDeps, class TSubs, class TSrcState, class TDstState>
 constexpr void update_current_state(SM &, TDeps &deps, TSubs &, typename SM::state_t &current_state,

test/ft/composite.cpp

@@ -1049,3 +1049,96 @@ test nested_composite_anonymous = [] {
   expect(sm.is(state<Leaf>));
   expect(sm.is<decltype(state<Leaf>)>(X));
 };
+
+test composite_state_reentry = [] {
+  using namespace boost::sml;
+
+  // events
+  struct E {};
+
+  struct Inner {
+    // states
+    struct START {};
+    struct MID {};
+    struct END {};
+
+    auto operator()() const noexcept {
+      using namespace sml;
+
+      /* clang-format off */
+      return make_transition_table(
+       *state<START>             = state<MID>,
+        state<MID>    + event<E> = state<END>,
+        state<END>               = X
+        );
+      /* clang-format on */
+    }
+  };
+
+  struct Outer {
+    // states
+    struct START {};   // for demonstrating the workaround
+    struct END {};
+
+
+    auto operator()() const noexcept {
+      using namespace sml;
+
+      // just runs the inner state machine
+      /* clang-format off */
+      return make_transition_table(
+       *state<Inner>             = state<END>,
+        state<END>               = X
+        );
+      /* clang-format on */
+    }
+
+  };
+
+  // events
+  struct CONTINUE {};
+  struct EXIT {};
+
+  struct Top {
+    // states
+    struct MID {};
+    struct END {};
+
+    auto operator()() const noexcept {
+      using namespace sml;
+
+      /* clang-format off */
+      return make_transition_table(
+       *state<Outer>                                  = state<MID>,
+        state<MID>                  + event<CONTINUE> = state<Outer>,
+        state<MID>                  + event<EXIT>     = state<END>,
+        state<END>                                    = X
+        );
+      /* clang-format on */
+    }
+
+  };
+
+  sml::sm<Top> sm;
+
+  // we should be in the Inner state machine waiting for its event
+  expect(sm.is(state<Outer>));
+  expect(sm.is<decltype(state<Outer>)>(state<Inner>));
+  expect(sm.is<decltype(state<Inner>)>(state<Inner::MID>));
+
+  // fire the event Inner is waiting for
+  expect(sm.process_event(E{}));
+
+  // now Inner and Outer have both finished and we are sitting in the top level MID
+  expect(sm.is(state<Top::MID>));
+  expect(sm.is<decltype(state<Outer>)>(X));
+  expect(sm.is<decltype(state<Inner>)>(X));
+
+  // fire CONTINUE to re-enter Outer and therefore Inner
+  expect(sm.process_event(CONTINUE{}));
+
+  // back in Inner waiting for an event
+  expect(sm.is(state<Outer>));
+  expect(sm.is<decltype(state<Outer>)>(state<Inner>));
+  expect(sm.is<decltype(state<Inner>)>(state<Inner::MID>));
+};