Handling the any state correctly when using a nested state machine

Author: Edvard Vasdal

include/boost/sml.hpp

@@ -1137,7 +1137,15 @@ template <class T, class... Ts>
 transitions_sub<T, Ts...> get_sub_state_mapping_impl(state_mappings<T, aux::type_list<Ts...>> *);
 template <class T, class TMappings, class TUnexpected>
 struct get_state_mapping<sm<T>, TMappings, TUnexpected> {
-  using type = decltype(get_sub_state_mapping_impl<sm<T>>((TMappings *)0));
+  using sub_sm_mapping = decltype(get_sub_state_mapping_impl<sm<T>>((TMappings *)0));
+  using fallback_event_mapping = decltype(get_state_mapping_impl<_, TUnexpected>((TMappings *)0));
+  struct type : sub_sm_mapping {
+    template <class TEvent, class TSm, class TDeps, class TSubs>
+    constexpr static bool execute(const TEvent& event, TSm& sm, TDeps& deps, TSubs& subs, typename TSm::state_t& current_state) {
+      return sub_sm_mapping::template execute<TEvent, TSm, TDeps, TSubs>(event, sm, deps, subs, current_state) ||
+             fallback_event_mapping::template execute<TEvent, TSm, TDeps, TSubs>(event, sm, deps, subs, current_state);
+    }
+  };
 };
 template <class T, class TMappings, class TUnexpected>
 using get_state_mapping_t = typename get_state_mapping<T, TMappings, TUnexpected>::type;

test/ft/states.cpp

@@ -261,6 +261,62 @@ test any_state = [] {
   expect("a1|a1|a2|a3|" == c_.calls);
 };
 
+test any_state_nested = [] {
+  struct s {
+    auto operator()() noexcept {
+      using namespace sml;
+      auto action1 = [this]{ calls += "a1|"; };
+      // clang-format off
+      return make_transition_table(
+         *idle + event<e1> / action1 = s1
+      );
+      // clang-format on
+    }
+    std::string& calls;
+  };
+
+  struct c {
+    auto operator()() noexcept {
+      using namespace sml;
+      auto action2 = [this]{ calls += "a2|"; };
+      auto action3 = [this]{ calls += "a3|"; };
+      // clang-format off
+      return make_transition_table(
+         any + event<e2> / action2,
+         any + event<e3> / action3 = idle,
+         *idle + event<e1> = state<s>,
+         state<s> + event<e4> = s2
+      );
+      // clang-format on
+    }
+    std::string& calls;
+  };
+
+  auto calls = std::string{};
+  auto c_ = c{calls};
+  auto s_ = s{calls};
+
+  sml::sm<c> sm{c_, s_};
+
+  sm.process_event(e1());
+  expect(sm.is(sml::state<s>));
+  expect(sm.is<decltype(sml::state<s>)>(idle));
+
+  sm.process_event(e1());
+  expect(sm.is(sml::state<s>));
+  expect(sm.is<decltype(sml::state<s>)>(s1));
+  expect("a1|" == c_.calls);
+
+  sm.process_event(e2());
+  expect(sm.is(sml::state<s>));
+  expect(sm.is<decltype(sml::state<s>)>(s1));
+  expect("a1|a2|" == c_.calls);
+
+  sm.process_event(e3());
+  expect(sm.is(idle));
+  expect("a1|a2|a3|" == c_.calls);
+};
+
 #if !defined(_MSC_VER)
 test state_names = [] {
   struct c {