tsm::detail Namespace Reference

Classes
struct	aggregate_events
struct	aggregate_events< std::tuple< Transitions... > >
struct	aggregate_events< std::tuple<> >
struct	append_unique_impl
struct	append_unique_impl< T, std::tuple< Ts... > >
struct	append_unique_impl< T, std::tuple<> >
struct	BaseTransition
struct	BlockingObserverT
struct	CallbackObserver
struct	ClockedHsm
struct	ClockedTransition
struct	ClockTickEvent
struct	ConcurrentExecutionPolicy
struct	Event
struct	EventQueueT
struct	FreeRTOSClock
class	FreeRTOSConditionVariable
class	FreeRTOSMutex
struct	get_events_from_hsm
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 > > >
struct	get_events_from_transition
struct	get_states
struct	get_states< std::tuple< Ts... > >
struct	get_states_impl
struct	get_states_impl< Tuple >
struct	get_states_impl< Tuple, First, Rest... >
struct	has_action
struct	has_action< T, Event, std::void_t< std::disjunction< std::is_invocable< decltype(&T::action), T >, std::is_invocable< decltype(&T::action), T & >, std::is_invocable< decltype(&T::action), T, Event > > > >
struct	has_entry
struct	has_entry< T, Event, std::void_t< std::disjunction< std::is_invocable< decltype(&T::entry), T >, std::is_invocable< decltype(&T::entry), T & >, std::is_invocable< decltype(&T::entry), T, Event > > > >
struct	has_exit
struct	has_exit< T, Event, std::void_t< std::disjunction< std::is_invocable< decltype(&T::exit), T >, std::is_invocable< decltype(&T::exit), T, T & >, std::is_invocable< decltype(&T::exit), T, Event > > > >
struct	has_guard
struct	has_guard< T, Event, std::void_t< std::disjunction< std::is_invocable< decltype(&T::guard), T >, std::is_invocable< decltype(&T::guard), T & >, std::is_invocable< decltype(&T::guard), T, Event > > > >
struct	has_handle_method
struct	has_handle_method< State, Event, Context, std::void_t< decltype(std::declval< State >().handle(std::declval< Context & >(), std::declval< Event >()))> >
struct	has_transitions
struct	has_transitions< T, std::void_t< typename T::transitions > >
struct	Hsm
struct	IntervalTimer
struct	is_clocked_hsm
struct	is_clocked_hsm< T, std::void_t< decltype(T::is_clocked_hsm)> >
struct	is_hsm_trait
struct	is_hsm_trait< T, std::void_t< decltype(T::is_hsm)> >
struct	is_transition_match
struct	is_transition_match< Transition< From, Event, To, Action, Guard >, From, Event >
struct	make_concurrent_hsm
struct	make_hsm
struct	make_hsm< T, std::enable_if_t< is_state_trait_v< T > > >
struct	make_hsm< T, std::enable_if_t<!is_state_trait_v< T > > >
struct	OrthogonalExecutionPolicy
struct	PeriodicExecutionPolicy
struct	PeriodicSleepTimer
struct	RealtimeConfigurator
struct	RealtimeExecutionPolicy
struct	RealtimePeriodicExecutionPolicy
struct	SingleThreadedExecutionPolicy
struct	ThreadedExecutionPolicy
struct	ThreadedExecWithObserver
struct	Timer
	Helper to implement a Timed Execution Policy. More...
struct	Transition
struct	transition_map_helper
struct	transition_map_helper< From, Event, std::tuple< Transitions... >, Index, std::enable_if_t<!(Index< sizeof...(Transitions))> >
struct	transition_map_helper< From, Event, std::tuple< Transitions... >, Index, std::enable_if_t<(Index< sizeof...(Transitions))> >
struct	TransitionMap
struct	tuple_to_variant_impl
struct	tuple_to_variant_impl< std::tuple< Ts... > >
struct	unique_tuple
struct	unique_tuple_impl
struct	unique_tuple_impl< std::tuple< T, Ts... >, std::tuple< Us... > >
struct	unique_tuple_impl< std::tuple<>, std::tuple< Us... > >
struct	wrap_transition
struct	wrap_transitions
struct	wrap_transitions< std::tuple< Ts... > >
struct	wrap_type_impl
struct	wrap_type_impl< Wrapper, std::tuple< Ts... > >
struct	wrapped_event

Typedefs
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 Ts >
using	unique_tuple_t = typename unique_tuple< Ts >::type
template<typename Tuple >
using	tuple_to_variant_t = typename tuple_to_variant_impl< Tuple >::type
template<typename... Ts>
using	get_states_t = typename get_states< Ts... >::type
template<typename From , typename Event , typename Transitions >
using	find_transition_t = typename TransitionMap< From, Event, Transitions >::type
template<typename T >
using	has_transitions_t = typename has_transitions< T >::type
template<typename T >
using	is_hsm_trait_t = typename is_hsm_trait< T >::type
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... Ts>
using	wrap_transitions_t = typename wrap_transitions< Ts... >::type
template<typename Event >
using	EventQueue = EventQueueT< Event, FreeRTOSMutex, FreeRTOSConditionVariable >
template<typename HsmType >
using	get_events_t = unique_tuple_t< typename get_events_from_hsm< HsmType >::type >
using	BlockingObserver = BlockingObserverT< FreeRTOSMutex, FreeRTOSConditionVariable >
template<typename Context >
using	ThreadedBlockingObserver = ThreadedExecWithObserver< Context, BlockingObserver >
template<template< typename > class Policy = ThreadedExecutionPolicy, typename... Ts>
using	make_concurrent_hsm_t = typename make_concurrent_hsm< Policy, Ts... >::type

Variables
template<typename State , typename Event , typename Transitions >
constexpr bool	has_valid_transition_v
template<typename T , typename Event >
constexpr bool	has_exit_v = has_exit<T, Event>::value
template<typename T , typename Event >
constexpr bool	has_entry_v = has_entry<T, Event>::value
template<typename T , typename Event >
constexpr bool	has_guard_v = has_guard<T, Event>::value
template<typename T , typename Event >
constexpr bool	has_action_v = has_action<T, Event>::value
template<typename T >
constexpr bool	has_transitions_v = has_transitions<T>::value
template<typename State , typename Event , typename Context >
constexpr bool	has_handle_method_v
template<typename T >
constexpr bool	is_hsm_trait_v = is_hsm_trait<T>::value
template<typename T >
constexpr bool	is_state_trait_v
template<typename T >
constexpr bool	is_clocked_hsm_v = is_clocked_hsm<T>::value
constexpr int	MaxEvents = 10

Typedef Documentation

append_unique

template<typename T , typename Tuple >

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

BlockingObserver

using tsm::detail::BlockingObserver = typedef BlockingObserverT<FreeRTOSMutex, FreeRTOSConditionVariable>

EventQueue

template<typename Event >

using tsm::detail::EventQueue = typedef EventQueueT<Event, FreeRTOSMutex, FreeRTOSConditionVariable>

find_transition_t

template<typename From , typename Event , typename Transitions >

using tsm::detail::find_transition_t = typedef typename TransitionMap<From, Event, Transitions>::type

get_events_t

template<typename HsmType >

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

get_states_t

template<typename... Ts>

using tsm::detail::get_states_t = typedef typename get_states<Ts...>::type

has_transitions_t

template<typename T >

using tsm::detail::has_transitions_t = typedef typename has_transitions<T>::type

is_hsm_trait_t

template<typename T >

using tsm::detail::is_hsm_trait_t = typedef typename is_hsm_trait<T>::type

make_concurrent_hsm_t

template<template< typename > class Policy = ThreadedExecutionPolicy, typename... Ts>

using tsm::detail::make_concurrent_hsm_t = typedef typename make_concurrent_hsm<Policy, Ts...>::type

make_hsm_t

template<typename T >

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

ThreadedBlockingObserver

template<typename Context >

using tsm::detail::ThreadedBlockingObserver = typedef ThreadedExecWithObserver<Context, BlockingObserver>

Execution policy that uses a BlockingObserver. This is illustrative of chaining policies together.

tuple_to_variant_t

template<typename Tuple >

using tsm::detail::tuple_to_variant_t = typedef typename tuple_to_variant_impl<Tuple>::type

unique_tuple_t

template<typename Ts >

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

wrap_transition_t

template<typename T >

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

wrap_transitions_t

template<typename... Ts>

using tsm::detail::wrap_transitions_t = typedef typename wrap_transitions<Ts...>::type

wrap_type

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

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

Variable Documentation

has_action_v

template<typename T , typename Event >

constexpr bool tsm::detail::has_action_v = has_action<T, Event>::value

inlineconstexpr

has_entry_v

template<typename T , typename Event >

constexpr bool tsm::detail::has_entry_v = has_entry<T, Event>::value

inlineconstexpr

has_exit_v

template<typename T , typename Event >

constexpr bool tsm::detail::has_exit_v = has_exit<T, Event>::value

inlineconstexpr

has_guard_v

template<typename T , typename Event >

constexpr bool tsm::detail::has_guard_v = has_guard<T, Event>::value

inlineconstexpr

has_handle_method_v

template<typename State , typename Event , typename Context >

constexpr bool tsm::detail::has_handle_method_v

inlineconstexpr

Initial value:

=
  has_handle_method<State, Event, Context>::value

has_transitions_v

template<typename T >

constexpr bool tsm::detail::has_transitions_v = has_transitions<T>::value

inlineconstexpr

has_valid_transition_v

template<typename State , typename Event , typename Transitions >

constexpr bool tsm::detail::has_valid_transition_v

inlineconstexpr

Initial value:

=
  !std::is_same_v<typename TransitionMap<State, Event, Transitions>::type,
                  void>

is_clocked_hsm_v

template<typename T >

constexpr bool tsm::detail::is_clocked_hsm_v = is_clocked_hsm<T>::value

inlineconstexpr

is_hsm_trait_v

template<typename T >

constexpr bool tsm::detail::is_hsm_trait_v = is_hsm_trait<T>::value

inlineconstexpr

is_state_trait_v

template<typename T >

constexpr bool tsm::detail::is_state_trait_v

inlineconstexpr

Initial value:

=
  std::conjunction_v<has_transitions<T>, std::negation<is_hsm_trait<T>>>

MaxEvents

constexpr int tsm::detail::MaxEvents = 10

constexpr