tsm::detail Namespace Reference

Classes
struct	linux_syscalls
struct	AccurateClock
struct	Timer
struct	IntervalTimer
struct	PeriodicSleepTimer
struct	basic_realtime_configurator
	Host realtime configuration helper.
struct	host_thread_policy
struct	basic_host_realtime_policy
class	basic_thread_executor
class	thread_executor
class	realtime_thread_executor
struct	select_runtime_queue_policy
struct	select_runtime_queue_policy< QueuePolicy, Overflow >
struct	Event
struct	wrapped_event
struct	final_state
struct	history_state
struct	deep_history_state
struct	automatic_event
struct	completion_event
struct	choice
struct	junction
struct	region
struct	fork
struct	join
struct	defer
struct	fork_to
struct	join_from
struct	join_to
struct	is_synchronization_rule
struct	synchronization_of
struct	synchronization_of< T >
struct	on
struct	basic_transition
struct	transition_with_action
struct	transition_with_guard
struct	transition_with_guard_action
struct	transition
struct	guard
struct	action
struct	edge
struct	edge< From, Event, To >
struct	edge< From, Event, To, guard< Guard > >
struct	edge< From, Event, To, action< Action > >
struct	edge< From, Event, To, guard< Guard >, action< Action > >
struct	edge< From, Event, To, action< Action >, guard< Guard > >
struct	transition< Kind, From, Event, To >
struct	transition< Kind, From, Event, To, Action >
struct	transition< Kind, From, Event, To, Action, Guard >
struct	T
struct	T< From, Event, To >
struct	T< From, Event, To, Action >
struct	T< From, Event, To, Action, Guard >
struct	local
struct	internal
struct	Internal
struct	External
struct	ClockTickEvent
struct	ClockedTransition
struct	is_transition
struct	transitions_of
struct	transitions_of< T >
struct	transition_traits
struct	type_list
struct	type_list_traits
struct	front_type
struct	front_type< type_list< T, Ts... > >
struct	empty_type_list
struct	empty_type_list< type_list< Ts... > >
struct	type_at
struct	type_at< Index, type_list< Ts... > >
struct	as_tuple
struct	as_tuple< std::tuple< Ts... > >
struct	as_tuple< type_list< Ts... > >
struct	as_type_list
struct	as_type_list< type_list< Ts... > >
struct	as_type_list< std::tuple< Ts... > >
struct	concat_type_lists
struct	concat_type_lists<>
struct	concat_type_lists< type_list< Ts... > >
struct	concat_type_lists< type_list< As... >, type_list< Bs... >, Rest... >
struct	filter_type_list
struct	filter_type_list< Predicate, type_list< Ts... > >
struct	wrap_type_impl
struct	wrap_type_impl< Wrapper, std::tuple< Ts... > >
struct	append_unique_impl
struct	append_unique_impl< T, std::tuple<> >
struct	append_unique_impl< T, type_list<> >
struct	append_unique_impl< T, std::tuple< Ts... > >
struct	append_unique_impl< T, type_list< Ts... > >
struct	type_set
struct	type_set< type_list< Ts... > >
struct	retain_if_in_set
struct	retain_if_in_set< type_list< Ts... >, StateSet >
struct	type_map
struct	type_map_entry
struct	type_map_lookup
struct	type_map_lookup< Key, type_map<> >
struct	type_map_lookup< Key, type_map< First, Rest... > >
struct	type_map_from_entries
struct	type_map_from_entries< type_list< Entries... > >
struct	unique_tuple_impl
struct	unique_tuple_impl< std::tuple<>, std::tuple< Us... > >
struct	unique_tuple_impl< std::tuple< T, Ts... >, std::tuple< Us... > >
struct	unique_tuple_impl< type_list<>, type_list< Us... > >
struct	unique_tuple_impl< type_list< T, Ts... >, type_list< Us... > >
struct	unique_tuple
struct	transition_map_helper
	Transition lookup.
struct	transition_map_helper< From, Event, type_list< TransitionEntries... >, Index, std::enable_if_t<(Index< sizeof...(TransitionEntries))> >
struct	transition_map_helper< From, Event, type_list< TransitionEntries... >, Index, std::enable_if_t<!(Index< sizeof...(TransitionEntries))> >
struct	matching_transition
struct	context_type_of
struct	context_type_of< T, std::void_t< typename T::context_type > >
struct	deferred_of
struct	deferred_of< T >
struct	is_defer_rule
struct	deferred_event_list
struct	deferred_event_list< type_list< Deferred... > >
struct	deferred_event_queue
struct	deferred_queue_storage
struct	deferred_queue_storage< type_list< Events... >, Capacity >
struct	defers_event
struct	defers_event< State, Event, type_list< Deferred... > >
struct	has_transitions
struct	is_unwrapped_state_machine
struct	is_hsm_trait
struct	is_clocked_hsm
struct	state_slot
struct	state_storage
struct	state_storage< type_list< States... > >
struct	hierarchy_transition_list
struct	hierarchy_transition_list< Hierarchy, AuthoredTransitionList, std::void_t< typename Hierarchy::transitions > >
struct	context_hierarchy_type
struct	context_hierarchy_type< Context, true >
struct	hsm_state_model
struct	hsm_state_model< Context, AuthoredTransitionList, CoreTable, true >
struct	hsm
struct	make_hsm
struct	make_hsm< T, std::enable_if_t<!is_state_trait_v< T > > >
struct	wrap_transition
struct	wrap_transition< T, true >
struct	wrap_transitions
struct	wrap_transitions< type_list< TransitionEntries... > >
struct	synchronization_entries_of
struct	make_hsm< T, std::enable_if_t< is_state_trait_v< T > > >
struct	join_to_rule_for
struct	join_to_rule_for< Join, type_list<> >
struct	join_to_rule_for< Join, type_list< First, Rest... > >
struct	join_to_rule_count
struct	join_to_rule_count< Join, type_list<> >
struct	join_to_rule_count< Join, type_list< First, Rest... > >
struct	OrthogonalExecutionPolicy
class	erased_event
	Forward declarations.
struct	get_events_from_hsm
struct	get_events_from_transition
	Extract events from a single transition.
struct	aggregate_events
struct	aggregate_events< type_list< TransitionEntries... > >
struct	aggregate_events< type_list<> >
struct	get_events_from_hsm< HsmType, std::enable_if_t< has_transitions_v< HsmType > > >
struct	get_events_from_hsm< HsmType, std::enable_if_t<!has_transitions_v< HsmType > > >
	Non-machine states do not contribute nested events.
class	tick_scheduler

Typedefs
using	RealtimeConfigurator = basic_realtime_configurator< linux_syscalls >
template<typename TickPeriod = std::chrono::milliseconds>
using	host_tick_source = tsm::chrono_ticks::elapsed_tick_source< AccurateClock, TickPeriod >
using	host_realtime_policy = basic_host_realtime_policy< linux_syscalls >
template<typename... Tasks>
using	task_executor = thread_executor< Tasks... >
template<typename ForkMarker , typename... Targets>
using	Fork = fork_to< ForkMarker, Targets... >
template<typename JoinMarker , typename... Sources>
using	Join = join_from< JoinMarker, Sources... >
template<typename JoinMarker , typename Target >
using	JoinTo = join_to< JoinMarker, Target >
template<typename From , typename Event , typename To , auto Action>
using	with_action = transition_with_action< transition_kind::external, From, Event, To, Action >
template<typename From , typename Event , typename To , auto Guard>
using	with_guard = transition_with_guard< transition_kind::external, From, Event, To, Guard >
template<typename From , typename Event , typename To , auto Guard, auto Action>
using	with_guard_action = transition_with_guard_action< transition_kind::external, From, Event, To, Guard, Action >
template<typename T >
using	transitions_of_t = typename transitions_of< T >::type
template<typename T >
using	front_type_t = typename front_type< T >::type
template<std::size_t Index, typename List >
using	type_at_t = typename type_at< Index, List >::type
template<typename T >
using	as_tuple_t = typename as_tuple< T >::type
template<typename T >
using	as_type_list_t = typename as_type_list< T >::type
template<typename... Lists>
using	concat_type_lists_t = typename concat_type_lists< Lists... >::type
template<template< typename > class Predicate, typename List >
using	filter_type_list_t = typename filter_type_list< Predicate, List >::type
template<template< class > class Wrapper, typename Tuple >
using	wrap_type = typename wrap_type_impl< Wrapper, Tuple >::type
template<typename T , typename Tuple >
using	append_unique = typename append_unique_impl< T, Tuple >::type
template<typename Set >
using	type_set_list_t = typename Set::list
template<typename List , typename StateSet >
using	retain_if_in_set_t = typename retain_if_in_set< List, StateSet >::type
template<typename Key , typename Map >
using	type_map_lookup_t = typename type_map_lookup< Key, Map >::type
template<typename EntryList >
using	type_map_from_entries_t = typename type_map_from_entries< EntryList >::type
template<typename Ts >
using	unique_tuple_t = typename unique_tuple< Ts >::type
template<typename From , typename Event , typename TransitionList >
using	find_transition_t = typename matching_transition< From, Event, TransitionList >::type
	find transition More...
template<typename T >
using	context_type_of_t = typename context_type_of< T >::type
template<typename T >
using	deferred_of_t = typename deferred_of< T >::type
template<typename DeferredList >
using	deferred_event_list_t = typename deferred_event_list< DeferredList >::type
template<typename Events , std::size_t Capacity>
using	deferred_queue_storage_t = typename deferred_queue_storage< Events, Capacity >::type
template<typename Definition >
using	transition_entries_t = filter_type_list_t< is_transition, as_type_list_t< Definition > >
template<typename Definition >
using	synchronization_entries_t = filter_type_list_t< is_synchronization_rule, as_type_list_t< Definition > >
template<typename T >
using	make_hsm_t = typename make_hsm< T >::type
template<typename T >
using	wrap_transition_t = typename wrap_transition< T >::type
template<typename T >
using	wrap_transitions_t = typename wrap_transitions< as_type_list_t< T > >::type
template<typename T >
using	synchronization_entries_of_t = typename synchronization_entries_of< T >::type
template<typename Join , typename Rules >
using	join_to_rule_for_t = typename join_to_rule_for< Join, Rules >::type
template<typename HsmType >
using	get_events_t = unique_tuple_t< typename get_events_from_hsm< HsmType >::type >
template<typename HsmType , std::size_t Capacity>
using	TickScheduler = tick_scheduler< HsmType, Capacity >

Enumerations
enum class	transition_kind { external , local , internal , reentering_external }

Functions
template<typename... Tasks>
	thread_executor (Tasks &...) -> thread_executor< Tasks... >
template<typename... Tasks>
	realtime_thread_executor (Tasks &...) -> realtime_thread_executor< Tasks... >
template<typename Transition >
consteval transition_kind	get_transition_kind ()
template<typename T >
	requires (!has_transition_type_c< T > &&has_transition_member_c< T >) struct transitions_of< T >
template<typename T , typename... Ts>
consteval bool	contains_type (type_list< Ts... >)
template<typename T , typename... Ts>
consteval bool	contains_type (std::tuple< Ts... >)
template<typename T , typename... Ts>
consteval std::size_t	max_sizeof (type_list< T, Ts... >)
template<typename T , typename... Ts>
consteval std::size_t	max_sizeof (std::tuple< T, Ts... >)
template<typename T , typename... Ts>
consteval std::size_t	max_alignof (type_list< T, Ts... >)
template<typename T , typename... Ts>
consteval std::size_t	max_alignof (std::tuple< T, Ts... >)
template<typename Callable , typename Context , typename Event >
bool	invoke_guard (Callable &&callable, Context &ctx, Event &e)
template<typename Callable , typename Context , typename Event >
void	invoke_action (Callable &&callable, Context &ctx, Event &e)

Variables
template<typename T >
concept	final_state_like
template<typename T >
concept	history_state_like
template<typename T >
concept	deep_history_state_like
template<typename T >
concept	choice_like = std::derived_from<T, choice>
template<typename T >
concept	junction_like = std::derived_from<T, junction>
template<typename T >
concept	decision_pseudostate_like = choice_like<T> || junction_like<T>
template<typename T >
concept	region_like = std::derived_from<T, region>
template<typename T >
concept	fork_like = std::derived_from<T, fork>
template<typename T >
concept	join_like = std::derived_from<T, join>
template<typename T >
concept	defer_like
template<typename T >
concept	fork_rule_like
template<typename T >
concept	join_from_rule_like
template<typename T >
concept	join_to_rule_like
template<typename T >
concept	synchronization_rule_like
template<typename T >
concept	has_synchronization_type_c
template<typename Transition >
concept	transition_edge_like
template<typename Transition >
concept	transition_like
template<typename Transition >
concept	transition_has_guard
template<typename Transition >
concept	transition_has_action
template<typename Transition >
constexpr transition_kind	transition_kind_v
template<typename Transition , typename From , typename Event >
concept	transition_matches
template<typename T >
concept	has_transition_type_c
template<typename T >
concept	has_transition_member_c
template<typename T >
concept	has_transitions_c
template<typename Ts >
concept	type_list_like = type_list_traits::accepts<Ts>::value
template<typename List >
constexpr bool	empty_type_list_v = empty_type_list<List>::value
template<typename State , typename Event , typename TransitionList >
constexpr bool	has_valid_transition_v
	variable template to check for the existence of a valid transition More...
template<typename State , typename Event , typename TransitionList >
concept	transition_available
template<typename T >
concept	state_has_exit
template<typename T >
concept	state_has_entry
template<typename T >
concept	state_has_guard
template<typename T >
concept	state_has_action
template<typename T >
concept	has_hierarchy_c
template<typename T >
concept	has_deferred_type_c
template<typename T >
constexpr bool	has_transitions_v = has_transitions_c<T>
template<typename State , typename Event , typename Context >
concept	state_handles_event
template<typename T >
concept	hsm_like
template<typename T >
constexpr bool	is_hsm_trait_v = hsm_like<T>
template<typename T >
constexpr bool	is_state_trait_v = has_transitions_c<T> && !hsm_like<T>
	Define a helper to check for 'from' and 'to' types in transitions,. More...
template<typename T >
concept	clocked_hsm_like
template<typename T >
constexpr bool	is_clocked_hsm_v = clocked_hsm_like<T>
template<typename... >
constexpr bool	dependent_false_v = false
template<typename Callable , typename Context , typename Event >
concept	guard_with_context_event
template<typename Callable , typename Context >
concept	guard_with_context
template<typename Callable , typename Event >
concept	guard_with_event
template<typename Callable >
concept	guard_without_args
template<typename Callable , typename Context , typename Event >
concept	transition_guard
template<typename Callable , typename Context , typename Event >
concept	action_with_context_event
template<typename Callable , typename Context >
concept	action_with_context
template<typename Callable , typename Event >
concept	action_with_event
template<typename Callable >
concept	action_without_args
template<typename Callable , typename Context , typename Event >
concept	transition_action

Typedef Documentation

append_unique

template<typename T , typename Tuple >

using tsm::detail::append_unique = typedef typename append_unique_impl<T, Tuple>::type

as_tuple_t

template<typename T >

using tsm::detail::as_tuple_t = typedef typename as_tuple<T>::type

as_type_list_t

template<typename T >

using tsm::detail::as_type_list_t = typedef typename as_type_list<T>::type

concat_type_lists_t

template<typename... Lists>

using tsm::detail::concat_type_lists_t = typedef typename concat_type_lists<Lists...>::type

context_type_of_t

template<typename T >

using tsm::detail::context_type_of_t = typedef typename context_type_of<T>::type

deferred_event_list_t

template<typename DeferredList >

using tsm::detail::deferred_event_list_t = typedef typename deferred_event_list<DeferredList>::type

deferred_of_t

template<typename T >

using tsm::detail::deferred_of_t = typedef typename deferred_of<T>::type

deferred_queue_storage_t

template<typename Events , std::size_t Capacity>

using tsm::detail::deferred_queue_storage_t = typedef typename deferred_queue_storage<Events, Capacity>::type

filter_type_list_t

template<template< typename > class Predicate, typename List >

using tsm::detail::filter_type_list_t = typedef typename filter_type_list<Predicate, List>::type

find_transition_t

template<typename From , typename Event , typename TransitionList >

using tsm::detail::find_transition_t = typedef typename matching_transition<From, Event, TransitionList>::type

find transition

Fork

template<typename ForkMarker , typename... Targets>

using tsm::detail::Fork = typedef fork_to<ForkMarker, Targets...>

front_type_t

template<typename T >

using tsm::detail::front_type_t = typedef typename front_type<T>::type

get_events_t

template<typename HsmType >

using tsm::detail::get_events_t = typedef unique_tuple_t<typename get_events_from_hsm<HsmType>::type>

host_realtime_policy

using tsm::detail::host_realtime_policy = typedef basic_host_realtime_policy<linux_syscalls>

host_tick_source

template<typename TickPeriod = std::chrono::milliseconds>

using tsm::detail::host_tick_source = typedef tsm::chrono_ticks::elapsed_tick_source<AccurateClock, TickPeriod>

Join

template<typename JoinMarker , typename... Sources>

using tsm::detail::Join = typedef join_from<JoinMarker, Sources...>

join_to_rule_for_t

template<typename Join , typename Rules >

using tsm::detail::join_to_rule_for_t = typedef typename join_to_rule_for<Join, Rules>::type

JoinTo

template<typename JoinMarker , typename Target >

using tsm::detail::JoinTo = typedef join_to<JoinMarker, Target>

make_hsm_t

template<typename T >

using tsm::detail::make_hsm_t = typedef typename make_hsm<T>::type

RealtimeConfigurator

using tsm::detail::RealtimeConfigurator = typedef basic_realtime_configurator<linux_syscalls>

retain_if_in_set_t

template<typename List , typename StateSet >

using tsm::detail::retain_if_in_set_t = typedef typename retain_if_in_set<List, StateSet>::type

synchronization_entries_of_t

template<typename T >

using tsm::detail::synchronization_entries_of_t = typedef typename synchronization_entries_of<T>::type

synchronization_entries_t

template<typename Definition >

using tsm::detail::synchronization_entries_t = typedef filter_type_list_t<is_synchronization_rule, as_type_list_t<Definition> >

task_executor

template<typename... Tasks>

using tsm::detail::task_executor = typedef thread_executor<Tasks...>

TickScheduler

template<typename HsmType , std::size_t Capacity>

using tsm::detail::TickScheduler = typedef tick_scheduler<HsmType, Capacity>

transition_entries_t

template<typename Definition >

using tsm::detail::transition_entries_t = typedef filter_type_list_t<is_transition, as_type_list_t<Definition> >

transitions_of_t

template<typename T >

using tsm::detail::transitions_of_t = typedef typename transitions_of<T>::type

type_at_t

template<std::size_t Index, typename List >

using tsm::detail::type_at_t = typedef typename type_at<Index, List>::type

type_map_from_entries_t

template<typename EntryList >

using tsm::detail::type_map_from_entries_t = typedef typename type_map_from_entries<EntryList>::type

type_map_lookup_t

template<typename Key , typename Map >

using tsm::detail::type_map_lookup_t = typedef typename type_map_lookup<Key, Map>::type

type_set_list_t

template<typename Set >

using tsm::detail::type_set_list_t = typedef typename Set::list

unique_tuple_t

template<typename Ts >

using tsm::detail::unique_tuple_t = typedef typename unique_tuple<Ts>::type

with_action

template<typename From , typename Event , typename To , auto Action>

using tsm::detail::with_action = typedef transition_with_action<transition_kind::external, From, Event, To, Action>

with_guard

template<typename From , typename Event , typename To , auto Guard>

using tsm::detail::with_guard = typedef transition_with_guard<transition_kind::external, From, Event, To, Guard>

with_guard_action

template<typename From , typename Event , typename To , auto Guard, auto Action>

using tsm::detail::with_guard_action = typedef transition_with_guard_action<transition_kind::external, From, Event, To, Guard, Action>

wrap_transition_t

template<typename T >

using tsm::detail::wrap_transition_t = typedef typename wrap_transition<T>::type

wrap_transitions_t

template<typename T >

using tsm::detail::wrap_transitions_t = typedef typename wrap_transitions<as_type_list_t<T> >::type

wrap_type

template<template< class > class Wrapper, typename Tuple >

using tsm::detail::wrap_type = typedef typename wrap_type_impl<Wrapper, Tuple>::type

Enumeration Type Documentation

transition_kind

enum tsm::detail::transition_kind

strong

Enumerator
external
local
internal
reentering_external

Function Documentation

contains_type() [1/2]

template<typename T , typename... Ts>

consteval bool tsm::detail::contains_type

(

std::tuple< Ts... >

)

contains_type() [2/2]

template<typename T , typename... Ts>

consteval bool tsm::detail::contains_type

(

type_list< Ts... >

)

Compile-time membership and storage-shape helpers.

Event queues and transport buffers need a concrete maximum payload size and alignment, but the set of possible events is still known as a type list. These consteval helpers fold over the list and produce ordinary numeric constants.

get_transition_kind()

template<typename Transition >

consteval transition_kind tsm::detail::get_transition_kind

(

)

invoke_action()

template<typename Callable , typename Context , typename Event >

void tsm::detail::invoke_action	(	Callable &&	callable,
		Context &	ctx,
		Event &	e
	)

invoke_guard()

template<typename Callable , typename Context , typename Event >

bool tsm::detail::invoke_guard	(	Callable &&	callable,
		Context &	ctx,
		Event &	e
	)

max_alignof() [1/2]

template<typename T , typename... Ts>

consteval std::size_t tsm::detail::max_alignof

(

std::tuple< T, Ts... >

)

max_alignof() [2/2]

template<typename T , typename... Ts>

consteval std::size_t tsm::detail::max_alignof

(

type_list< T, Ts... >

)

max_sizeof() [1/2]

template<typename T , typename... Ts>

consteval std::size_t tsm::detail::max_sizeof

(

std::tuple< T, Ts... >

)

max_sizeof() [2/2]

template<typename T , typename... Ts>

consteval std::size_t tsm::detail::max_sizeof

(

type_list< T, Ts... >

)

realtime_thread_executor()

template<typename... Tasks>

tsm::detail::realtime_thread_executor

(

Tasks &

...

)

-> realtime_thread_executor< Tasks... >

requires()

template<typename T >

tsm::detail::requires

(

!has_transition_type_c< T > &&has_transition_member_c< T >

)

thread_executor()

template<typename... Tasks>

tsm::detail::thread_executor

(

Tasks &

...

)

-> thread_executor< Tasks... >

Variable Documentation

action_with_context

template<typename Callable , typename Context >

concept tsm::detail::action_with_context

Initial value:

=
  requires(Callable&& callable, Context& ctx) {
      { std::invoke(std::forward<Callable>(callable), ctx) } -> std::same_as<void>;
  }

action_with_context_event

template<typename Callable , typename Context , typename Event >

concept tsm::detail::action_with_context_event

Initial value:

=
  requires(Callable&& callable, Context& ctx, Event& event) {
      { std::invoke(std::forward<Callable>(callable), ctx, event) } -> std::same_as<void>;
  }

action_with_event

template<typename Callable , typename Event >

concept tsm::detail::action_with_event

Initial value:

=
  requires(Callable&& callable, Event& event) {
      { std::invoke(std::forward<Callable>(callable), event) } -> std::same_as<void>;
  }

action_without_args

template<typename Callable >

concept tsm::detail::action_without_args

Initial value:

=
  requires(Callable&& callable) {
      { std::invoke(std::forward<Callable>(callable)) } -> std::same_as<void>;
  }

choice_like

template<typename T >

concept tsm::detail::choice_like = std::derived_from<T, choice>

clocked_hsm_like

template<typename T >

concept tsm::detail::clocked_hsm_like

Initial value:

= requires {
    T::is_clocked_hsm;
}

decision_pseudostate_like

template<typename T >

concept tsm::detail::decision_pseudostate_like = choice_like<T> || junction_like<T>

deep_history_state_like

template<typename T >

concept tsm::detail::deep_history_state_like

Initial value:

= requires {
    typename T::history_parent;
} && std::same_as<T, deep_history_state<typename T::history_parent>>

defer_like

template<typename T >

concept tsm::detail::defer_like

Initial value:

= requires {
    typename T::state;
    typename T::event;
}

dependent_false_v

template<typename... >

constexpr bool tsm::detail::dependent_false_v = false

inlineconstexpr

empty_type_list_v

template<typename List >

constexpr bool tsm::detail::empty_type_list_v = empty_type_list<List>::value

inlineconstexpr

final_state_like

template<typename T >

concept tsm::detail::final_state_like

Initial value:

= requires {
    typename T::final_parent;
}

fork_like

template<typename T >

concept tsm::detail::fork_like = std::derived_from<T, fork>

fork_rule_like

template<typename T >

concept tsm::detail::fork_rule_like

Initial value:

= requires {
    typename T::fork;
    typename T::targets;
} && fork_like<typename T::fork> && type_list_like<typename T::targets>

guard_with_context

template<typename Callable , typename Context >

concept tsm::detail::guard_with_context

Initial value:

=
  requires(Callable&& callable, Context& ctx) {
      { std::invoke(std::forward<Callable>(callable), ctx) } -> std::same_as<bool>;
  }

guard_with_context_event

template<typename Callable , typename Context , typename Event >

concept tsm::detail::guard_with_context_event

Initial value:

=
  requires(Callable&& callable, Context& ctx, Event& event) {
      { std::invoke(std::forward<Callable>(callable), ctx, event) } -> std::same_as<bool>;
  }

guard_with_event

template<typename Callable , typename Event >

concept tsm::detail::guard_with_event

Initial value:

=
  requires(Callable&& callable, Event& event) {
      { std::invoke(std::forward<Callable>(callable), event) } -> std::same_as<bool>;
  }

guard_without_args

template<typename Callable >

concept tsm::detail::guard_without_args

Initial value:

=
  requires(Callable&& callable) {
      { std::invoke(std::forward<Callable>(callable)) } -> std::same_as<bool>;
  }

has_deferred_type_c

template<typename T >

concept tsm::detail::has_deferred_type_c

Initial value:

= requires {
    typename T::deferred;
}

has_hierarchy_c

template<typename T >

concept tsm::detail::has_hierarchy_c

Initial value:

= requires {
    typename T::hierarchy;
}

has_synchronization_type_c

template<typename T >

concept tsm::detail::has_synchronization_type_c

Initial value:

= requires {
    typename T::synchronization;
}

Synchronization rules attached to a definition.

A definition may either put rules in using synchronization = ... or place authored Fork, Join, and JoinTo entries beside transitions. This helper validates the explicit form and presents missing synchronization as an empty list.

has_transition_member_c

template<typename T >

concept tsm::detail::has_transition_member_c

Initial value:

= requires(T& context) {
    context.transitions();
}

has_transition_type_c

template<typename T >

concept tsm::detail::has_transition_type_c

Initial value:

= requires {
    typename T::transitions;
}

has_transitions_c

template<typename T >

concept tsm::detail::has_transitions_c

Initial value:

=
  has_transition_type_c<T> || has_transition_member_c<T>

has_transitions_v

template<typename T >

constexpr bool tsm::detail::has_transitions_v = has_transitions_c<T>

inlineconstexpr

has_valid_transition_v

template<typename State , typename Event , typename TransitionList >

constexpr bool tsm::detail::has_valid_transition_v

inlineconstexpr

Initial value:

=
  !std::is_same_v<typename matching_transition<State, Event, TransitionList>::type,
                  void>

variable template to check for the existence of a valid transition

history_state_like

template<typename T >

concept tsm::detail::history_state_like

Initial value:

= requires {
    typename T::history_parent;
}

hsm_like

template<typename T >

concept tsm::detail::hsm_like

Initial value:

= requires {
    T::is_hsm;
}

is_clocked_hsm_v

template<typename T >

constexpr bool tsm::detail::is_clocked_hsm_v = clocked_hsm_like<T>

inlineconstexpr

is_hsm_trait_v

template<typename T >

constexpr bool tsm::detail::is_hsm_trait_v = hsm_like<T>

inlineconstexpr

is_state_trait_v

template<typename T >

constexpr bool tsm::detail::is_state_trait_v = has_transitions_c<T> && !hsm_like<T>

inlineconstexpr

Define a helper to check for 'from' and 'to' types in transitions,.

join_from_rule_like

template<typename T >

concept tsm::detail::join_from_rule_like

Initial value:

= requires {
    typename T::join;
    typename T::sources;
} && join_like<typename T::join> && type_list_like<typename T::sources>

join_like

template<typename T >

concept tsm::detail::join_like = std::derived_from<T, join>

join_to_rule_like

template<typename T >

concept tsm::detail::join_to_rule_like

Initial value:

= requires {
    typename T::join;
    typename T::target;
} && join_like<typename T::join>

junction_like

template<typename T >

concept tsm::detail::junction_like = std::derived_from<T, junction>

region_like

template<typename T >

concept tsm::detail::region_like = std::derived_from<T, region>

state_handles_event

template<typename State , typename Event , typename Context >

concept tsm::detail::state_handles_event

Initial value:

= requires(State& state, Context& ctx, Event& event) {
    { state.handle(ctx, event) } -> std::convertible_to<bool>;
}

state_has_action

template<typename T >

concept tsm::detail::state_has_action

Initial value:

= requires {
    &T::action;
}

state_has_entry

template<typename T >

concept tsm::detail::state_has_entry

Initial value:

= requires {
    &T::entry;
}

state_has_exit

template<typename T >

concept tsm::detail::state_has_exit

Initial value:

= requires {
    &T::exit;
}

state_has_guard

template<typename T >

concept tsm::detail::state_has_guard

Initial value:

= requires {
    &T::guard;
}

synchronization_rule_like

template<typename T >

concept tsm::detail::synchronization_rule_like

Initial value:

=
  fork_rule_like<T> || join_from_rule_like<T> || join_to_rule_like<T>

transition_action

template<typename Callable , typename Context , typename Event >

concept tsm::detail::transition_action

Initial value:

=
  action_with_context_event<Callable, Context, Event> ||
  action_with_context<Callable, Context> ||
  action_with_event<Callable, Event> ||
  action_without_args<Callable>

transition_available

template<typename State , typename Event , typename TransitionList >

concept tsm::detail::transition_available

Initial value:

=
  has_valid_transition_v<State, Event, TransitionList>

transition_edge_like

template<typename Transition >

concept tsm::detail::transition_edge_like

Initial value:

= requires {
    typename Transition::from;
    typename Transition::to;
}

Transition concepts.

These concepts are the public contract consumed by transition tables and core algorithms. They accept framework helper types and user-authored structural transition types without requiring inheritance from a common base.

transition_guard

template<typename Callable , typename Context , typename Event >

concept tsm::detail::transition_guard

Initial value:

=
  guard_with_context_event<Callable, Context, Event> ||
  guard_with_context<Callable, Context> ||
  guard_with_event<Callable, Event> ||
  guard_without_args<Callable>

transition_has_action

template<typename Transition >

concept tsm::detail::transition_has_action

Initial value:

= transition_like<Transition> && requires {
    Transition::action;
}

transition_has_guard

template<typename Transition >

concept tsm::detail::transition_has_guard

Initial value:

= transition_like<Transition> && requires {
    Transition::guard;
}

transition_kind_v

template<typename Transition >

constexpr transition_kind tsm::detail::transition_kind_v

inlineconstexpr

Initial value:

=
  get_transition_kind<Transition>()

transition_like

template<typename Transition >

concept tsm::detail::transition_like

Initial value:

= transition_edge_like<Transition> && requires {
    typename Transition::event;
}

transition_matches

template<typename Transition , typename From , typename Event >

concept tsm::detail::transition_matches

Initial value:

=
  transition_like<Transition> &&
  std::same_as<typename Transition::from, From> &&
  std::same_as<typename Transition::event, Event>

type_list_like

template<typename Ts >

concept tsm::detail::type_list_like = type_list_traits::accepts<Ts>::value