transitional [concept]

Header

#include <boost/sml.hpp> 

Description

Requirements for transition.

Synopsis

template <class T> concept bool transitional() { return requires(T transition) { typename T::src_state; typename T::dst_state; typename T::event; typename T::deps; T::initial; T::history; { transition.execute() } -> bool; } }; 

Semantics

transitional<T> 

Example

using namespace sml; { auto transition = ("idle"_s = X); // Postfix Notation static_assert(transitional<decltype(transition)>::value); } { auto transition = (X <= "idle"_s); // Prefix Notation static_assert(transitional<decltype(transition)>::value); } 

 

---

configurable [concept]

Header

#include <boost/sml.hpp> 

Description

Requirements for the state machine.

Synopsis

template <class SM> concept bool configurable() { return requires(SM sm) { { sm.operator()() }; } }; 

Semantics

configurable<SM> 

Example

class example { auto operator()() const noexcept { return make_transition_table(); } }; static_assert(configurable<example>::value); 

 

---

callable [concept]

Header

#include <boost/sml.hpp> 

Description

Requirements for action and guards.

Synopsis

template <class TResult, class T> concept bool callable() { return requires(T object) { { object(...) } -> TResult; } } 

Semantics

callable<SM> 

Example

auto guard = [] { return true; }; auto action = [] { }; static_assert(callable<bool, decltype(guard)>::value); static_assert(callable<void, decltype(action)>::value); 

 

---

dispatchable [concept]

Header

#include <boost/sml.hpp> 

Description

Requirements for the dispatch table.

Synopsis

template <class TDynamicEvent, TEvent> concept bool dispatchable() { return requires(T) { typename TEvent::id; { TEvent(declval<TDynamicEvent>()) }; } }; 

Semantics

dispatchable<SM> 

Example

struct runtime_event { }; struct event1 { static constexpr auto id = 1; }; struct event2 { static constexpr auto id = 2; explicit event2(const runtime_event&) {} }; static_assert(dispatchable<runtime_event, event1>::value); static_assert(dispatchable<runtime_event, event2>::value); 

 

---

state [core]

Header

#include <boost/sml.hpp> 

Description

Represents a state machine state.

Synopsis

template<class TState> // no requirements, TState may be a state machine class state { public: initial operator*() const noexcept; // no requirements template <class T> // no requirements auto operator<=(const T &) const noexcept; template <class T> // no requirements auto operator=(const T &) const noexcept; template <class T> // no requirements auto operator+(const T &) const noexcept; template <class T> requires callable<bool, T> auto operator[](const T) const noexcept; template <class T> requires callable<void, T> auto operator/(const T &t) const noexcept; const char* c_str() noexcept; }; template <class T, T... Chrs> state<unspecified> operator""_s() noexcept; // predefined states state<unspecified> X; 

Requirements

• callable

Semantics

state<T>{} 

Example

auto idle = state<class idle>; auto idle = "idle"_s; auto initial_state = *idle; auto history_state = idle(H); auto terminate_state = X; 

 

---

event [core]

Header

#include <boost/sml.hpp> 

Description

Represents a state machine event.

Synopsis

template<TEvent> // no requirements class event { public: template <class T> requires callable<bool, T> auto operator[](const T &) const noexcept; template <class T> requires callable<void, T> auto operator/(const T &t) const noexcept; }; template<class TEvent> event<TEvent> event{}; // predefined events auto on_entry = event<unspecified>; auto on_exit = event<unspecified>; template<class TEvent> unexpected_event{}; template<class T> exception{}; 

Requirements

• callable

Semantics

event<T> 

Example

auto my_int_event = event<int>; 

 

---

make_transition_table [state machine]

Header

#include <boost/sml.hpp> 

Description

Creates a transition table.

Synopsis

template <class... Ts> requires transitional<Ts>... auto make_transition_table(Ts...) noexcept; 

Requirements

• transitional

Semantics

make_transition_table(transitions...); 

Example

auto transition_table_postfix_notation = make_transition_table( *"idle_s" + event<int> / [] {} = X ); auto transition_table_prefix_notation = make_transition_table( X <= *"idle_s" + event<int> / [] {} ); class example { public: auto operator()() const noexcept { return make_transition_table(); } }; 

 

---

sm [state machine]

Header

#include <boost/sml.hpp> 

Description

Creates a State Machine.

Synopsis

template<class T> requires configurable<T> class sm { public: using states = unspecified; // unique list of states using events = unspecified; // unique list of events which can be handled by the State Machine using transitions = unspecified; // list of transitions sm(sm &&) = default; sm(const sm &) = delete; sm &operator=(const sm &) = delete; template <class... TDeps> requires is_base_of<TDeps, dependencies>... sm(TDeps&&...) noexcept; template<class TEvent> // no requirements bool process_event(const TEvent&) template <class TVisitor> requires callable<void, TVisitor> void visit_current_states(const TVisitor &) const noexcept(noexcept(visitor(state{}))); template <class TState> bool is(const state<TState> &) const noexcept; template <class... TStates> requires sizeof...(TStates) == number_of_initial_states bool is(const state<TStates> &...) const noexcept; }; 

Expression	Requirement	Description	Returns
TDeps...	is_base_of dependencies	constructor
process_event<TEvent>	-	process event TEvent	returns true when handled, false otherwise
visit_current_states<TVisitor>	callable	visit current states	-
is<TState>	-	verify whether any of current states equals TState	true when any current state matches TState, false otherwise
is<TStates...>	size of TStates... equals number of initial states	verify whether all current states match TStates...	true when all states match TState..., false otherwise

Semantics

sml::sm<T>{...}; sm.process_event(TEvent{}); sm.visit_current_states([](auto state){}); sm.is(X); sm.is(s1, s2); 

Example

struct my_event {}; class example { public: auto operator()() const noexcept { using namespace sml; return make_transition_table( *"idle"_s + event<my_event> / [](int i) { std::cout << i << std::endl; } = X ); } }; sml::sm<example> sm{42}; assert(sm.is("idle"_s)); sm.process_event(int{}); // no handled, will call unexpected_event<int> sm.process_event(my_event{}); // handled assert(sm.is(X)); sm.visit_current_states([](auto state) { std::cout << state.c_str() << std::endl; }); 

 

---

policies [state machine]

Header

#include <boost/sml.hpp> 

Description

Additional State Machine configurations.

Synopsis

thread_safe<Lockable> logger<Loggable> 

Expression	Requirement	Description	Example
Lockable	lock/unlock	Lockable type	std::mutex, std::recursive_mutex
Loggable	log_process_event/log_state_change/log_action/log_guard	Loggable type	-

Example

sml::sm<example, sml::thread_safe<std::recursive_mutex>> sm; // thread safe policy sml::sm<example, sml::logger<my_logger>> sm; // logger policy sml::sm<example, sml::thread_safe<std::recursive_mutex>, sml::logger<my_logger>> sm; // thread safe and logger policy sml::sm<example, sml::logger<my_logger>, sml::thread_safe<std::recursive_mutex>> sm; // thread safe and logger policy 

 

---

testing::sm [testing]

Header

#include <boost/sml/testing/state_machine.hpp> 

Description

Creates a state machine with testing capabilities.

Synopsis

namespace testing { template <class T> class sm : public sml::sm<T> { public: using sml::sm<T>::sm; template <class... TStates> void set_current_states(const detail::state<TStates> &...) noexcept; }; } 

Expression	Requirement	Description	Returns
set_current_states<TStates...>	-	set current states

Semantics

sml::testing::sm<T>{...}; sm.set_current_states("s1"_s); 

Example

sml::testing::sm<T>{inject_fake_data...}; sm.set_current_states("s1"_s); sm.process_event(TEvent{}); sm.is(X); 

 

---

make_dispatch_table [utility]

Header

#include <boost/sml/utility/dispatch_table.hpp> 

Description

Creates a dispatch table to handle runtime events.

Synopsis

namespace utility { template<class TEvent, int EventRangeBegin, int EventRangeBegin, class SM> requires dispatchable<TEvent, typename SM::events> callable<bool, (TEvent, int)> make_dispatch_table(sm<SM>&) noexcept; } 

Requirements

• dispatchable

Semantics

sml::utility::make_dispatch_table<T, 0, 10>(sm); 

Example

struct runtime_event { int id = 0; }; struct event1 { static constexpr auto id = 1; event1(const runtime_event &) {} }; auto dispatch_event = sml::utility::make_dispatch_table<runtime_event, 1 /*min*/, 5 /*max*/>(sm); dispatch_event(event, event.id); 

 

---