Merge origin/main into codex/completion-event

Author: gabewillen

benchmark/simple/CMakeLists.txt

@@ -13,4 +13,5 @@ add_example(simple_sc benchmark_simple_sc sc.cpp)
 
 if (NOT IS_MSVC_2015)
   add_example(simple_sml benchmark_simple_sml sml.cpp)
+  add_example(simple_co_sm benchmark_simple_co_sm co_sm.cpp)
 endif()

benchmark/simple/co_sm.cpp

@@ -0,0 +1,101 @@
+//
+// Copyright (c) 2016-2026 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+#include <boost/sml.hpp>
+#include <boost/sml/utility/co_sm.hpp>
+
+#include "benchmark.hpp"
+
+namespace sml = boost::sml;
+
+struct play {};
+struct end_pause {};
+struct stop {};
+struct pause {};
+struct open_close {};
+struct cd_detected {};
+
+auto start_playback = [] {};
+auto resume_playback = [] {};
+auto close_drawer = [] {};
+auto open_drawer = [] {};
+auto stop_and_open = [] {};
+auto stopped_again = [] {};
+auto store_cd_info = [] {};
+auto pause_playback = [] {};
+auto stop_playback = [] {};
+
+struct player {
+  auto operator()() const noexcept {
+    using namespace sml;
+    auto Empty = state<class Empty>;
+    auto Open = state<class Open>;
+    auto Stopped = state<class Stopped>;
+    auto Playing = state<class Playing>;
+    auto Pause = state<class Pause>;
+
+    // clang-format off
+    return make_transition_table(
+        Playing <= Stopped + event<play> / start_playback,
+        Playing <= Pause + event<end_pause> / resume_playback,
+        Empty <= Open + event<open_close> / close_drawer,
+        Open <= *Empty + event<open_close> / open_drawer,
+        Open <= Pause + event<open_close> / stop_and_open,
+        Open <= Stopped + event<open_close> / open_drawer,
+        Open <= Playing + event<open_close> / stop_and_open,
+        Pause <= Playing + event<pause> / pause_playback,
+        Stopped <= Playing + event<stop> / stop_playback,
+        Stopped <= Pause + event<stop> / stop_playback,
+        Stopped <= Empty + event<cd_detected> / store_cd_info,
+        Stopped <= Stopped + event<stop> / stopped_again
+    );
+    // clang-format on
+  }
+};
+
+int main() {
+#if BOOST_SML_UTILITY_CO_SM_ENABLED
+  using co_sm_t =
+      sml::utility::co_sm<player, sml::utility::policy::coroutine_scheduler<sml::utility::policy::inline_scheduler>>;
+  co_sm_t sm{};
+
+  benchmark_execution_speed([&] {
+    for (auto i = 0; i < 1'000'000; ++i) {
+      sm.process_event_async(open_close{}).result();
+      sm.process_event_async(open_close{}).result();
+      sm.process_event_async(cd_detected{}).result();
+      sm.process_event_async(play{}).result();
+      sm.process_event_async(pause{}).result();
+      sm.process_event_async(end_pause{}).result();
+      sm.process_event_async(pause{}).result();
+      sm.process_event_async(stop{}).result();
+      sm.process_event_async(stop{}).result();
+      sm.process_event_async(open_close{}).result();
+      sm.process_event_async(open_close{}).result();
+    }
+  });
+  benchmark_memory_usage(sm);
+#else
+  sml::sm<player> sm{};
+  benchmark_execution_speed([&] {
+    for (auto i = 0; i < 1'000'000; ++i) {
+      sm.process_event(open_close{});
+      sm.process_event(open_close{});
+      sm.process_event(cd_detected{});
+      sm.process_event(play{});
+      sm.process_event(pause{});
+      sm.process_event(end_pause{});
+      sm.process_event(pause{});
+      sm.process_event(stop{});
+      sm.process_event(stop{});
+      sm.process_event(open_close{});
+      sm.process_event(open_close{});
+    }
+  });
+  benchmark_memory_usage(sm);
+#endif
+}

include/boost/sml.hpp

@@ -763,6 +763,10 @@ template <class R, class T, int N>
 constexpr R get_id(type_id_type<N, T> *) {
   return static_cast<R>(N);
 }
+template <class T, int N>
+constexpr true_type has_type_id(type_id_type<N, T> *);
+template <class T>
+constexpr false_type has_type_id(...);
 template <template <class...> class, class T>
 struct is : false_type {};
 template <template <class...> class T, class... Ts>
@@ -1303,6 +1307,15 @@ struct transitions<aux::false_type> {
     return false;
   }
 };
+template <class TEvent, class...>
+struct has_terminate_parent_transition : aux::false_type {};
+template <class TEvent, class TTransition, class... TRest>
+struct has_terminate_parent_transition<TEvent, TTransition, TRest...>
+    : aux::conditional<
+          aux::is_same<terminate_state, typename TTransition::dst_state>::value &&
+              aux::is_same<TEvent, typename TTransition::event>::value,
+          aux::true_type,
+          has_terminate_parent_transition<TEvent, TRest...>>::type {};
 template <class Tsm, class T, class... Ts>
 struct transitions_sub<sm<Tsm>, T, Ts...> {
   template <class TEvent, class SM, class TDeps, class TSubs>
@@ -1318,7 +1331,14 @@ struct transitions_sub<sm<Tsm>, T, Ts...> {
   }
   template <class TEvent, class SM, class TDeps, class TSubs>
   constexpr static bool execute_impl(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
-    const auto handled = sub_sm<sm_impl<Tsm>>::get(&subs).process_event(event, deps, subs);
+    auto &sub = sub_sm<sm_impl<Tsm>>::get(&subs);
+    const auto handled = sub.process_event(event, deps, subs);
+
+    if (handled && sub.is_terminated() && has_terminate_parent_transition<TEvent, T, Ts...>::value) {
+      const auto propagated = transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
+      return propagated ? propagated : handled;
+    }
+
     return handled ? handled : transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
   }
   template <class _, class TEvent, class SM, class TDeps, class TSubs>
@@ -2114,12 +2134,17 @@ struct sm_impl : aux::conditional_t<aux::should_not_subclass_statemachine_class<
   constexpr static void visit_state(const TVisitor &visitor) {
     visitor(aux::string<TState>{});
   }
-  constexpr bool is_terminated() const { return is_terminated_impl(aux::make_index_sequence<regions>{}); }
-  constexpr bool is_terminated_impl(aux::index_sequence<0>) const {
-    return current_state_[0] == aux::get_id<state_t, terminate_state>((states_ids_t *)0);
+  constexpr bool is_terminated() const {
+    return is_terminated_impl(aux::make_index_sequence<regions>{},
+                              decltype(aux::has_type_id<terminate_state>((states_ids_t *)0)){});
+  }
+  template <int... Ns>
+  constexpr bool is_terminated_impl(aux::index_sequence<Ns...>, aux::false_type) const {
+    (void)sizeof...(Ns);
+    return false;
   }
   template <int... Ns>
-  constexpr bool is_terminated_impl(aux::index_sequence<Ns...>) const {
+  constexpr bool is_terminated_impl(aux::index_sequence<Ns...>, aux::true_type) const {
 #if defined(__cpp_fold_expressions)
     return ((current_state_[Ns] == aux::get_id<state_t, terminate_state>((states_ids_t *)0)) && ...);
 #else