yasmine
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
sxy Namespace Reference

Namespaces

 impl
 
 utils
 
 version
 

Classes

class  async_behavior
 
class  async_event_handler
 
class  behavior
 
class  choice
 
class  completion_event
 
class  complex_state
 
class  complex_state_impl
 
class  complex_state_visitor
 
class  composite_state
 
class  compound_transition
 
class  compound_transition_consumer
 
class  const_vertex_visitor
 
class  constraint
 
class  deep_history
 
class  entry_point
 
interface  event
 Interface of an event. An event has an ID, a name and a priority (for processing by the async state machine). More...
 
class  event_collector
 
struct  event_creation_request_time_comparer
 
class  event_impl
 Events that are processed by the state machine. An event can have an ID, a name and a priority (for processing by the async state machine). More...
 
interface  event_processing_callback
 Callback interface that is called by a state machine during event processing. See the different methods to find out which events can be monitored. More...
 
class  execution_step
 
class  execution_step_visitor
 
class  exit_point
 
class  final_state
 
class  fork
 
struct  has_get_event_id
 
class  history
 
class  history_impl
 
class  initial_pseudostate
 
class  interruptible
 
class  join
 
class  junction
 
class  pseudostate
 
class  pseudostate_impl
 
class  pseudostate_visitor
 
class  region
 
class  region_pseudostate
 
class  region_pseudostate_impl
 
class  shallow_history
 
class  shallow_history_impl
 
class  simple_state
 
class  simple_state_base
 
class  specialized_event
 Class that inherits event_impl and provides a fixed event ID and priority as well as create methods for creating instances of the event. More...
 
class  state
 
class  state_impl
 
class  state_machine_base
 
class  state_machine_element
 
class  state_machine_element_impl
 
interface  state_machine_introspection
 The interface for state machine introspection. It is inherited by the state machine class state_machine. More...
 
class  state_pseudostate
 
class  state_pseudostate_impl
 
class  state_visitor
 
class  states_to_enter_visitor_impl
 
class  SX_FINAL
 
class  sync_state_machine
 Class for the "single-threaded version" of the state machine. It provides the methods to start the state machine, to fire events, to check the state machine for possible defects and to get the root state reference. More...
 
class  terminate_pseudostate
 
class  transition
 
class  transition_step
 
class  try_to_build_compound_transition_visitor
 
class  vertex
 
class  vertex_impl
 
class  vertex_visitor
 

Typedefs

typedef sxe::SX_UNIQUE_PTR< async_behavior > async_behavior_uptr
 
typedef sxe::SX_UNIQUE_PTR< behavior_exception > behavior_exception_uptr
 
typedef std::vector< behavior_exception_uptr > behavior_exceptions
 
typedef sxe::SX_UNIQUE_PTR< behavior > behavior_uptr
 
typedef sxe::function< void(const event &, event_collector &) > behavior_function
 
typedef sxe::SX_UNIQUE_PTR< choice > choice_uptr
 
typedef std::vector< choice_uptr > choices
 
typedef std::vector< const choice *> raw_const_choices
 
typedef sxe::SX_UNIQUE_PTR< composite_state > composite_state_uptr
 
typedef std::vector< composite_state *> raw_composite_states
 
typedef sxe::SX_UNIQUE_PTR< constraint > constraint_uptr
 
typedef sxe::function< bool(const event &, event_collector &) > constraint_function
 
typedef sxe::SX_UNIQUE_PTR< deep_history > deep_history_uptr
 
typedef sxe::SX_UNIQUE_PTR< entry_point > entry_point_uptr
 
typedef std::vector< entry_point_uptr > entry_points
 
typedef std::vector< const entry_point *> raw_const_entry_points
 
typedef sxe::shared_ptr< event > event_sptr
 
typedef std::vector< event_sptr > events
 
typedef sxe::uint32_t handle_type
 The type alias for yasmine's event handle. More...
 
typedef sxe::uint32_t event_id
 The type alias for yasmine's event IDs. More...
 
typedef std::vector< event_id > event_ids
 The type alias for yasmine's event ID list. More...
 
typedef sxe::int8_t event_priority
 The type alias for yasmine's event priorities. More...
 
typedef std::vector< event_priority > event_prioritys
 The type alias for yasmine's event priority list. More...
 
typedef sxe::SX_UNIQUE_PTR< exit_point > exit_point_uptr
 
typedef std::vector< exit_point_uptr > exit_points
 
typedef std::vector< const exit_point *> raw_const_exit_points
 
typedef sxe::SX_UNIQUE_PTR< fork > fork_uptr
 
typedef std::vector< fork_uptr > forks
 
typedef std::vector< const fork *> raw_const_forks
 
typedef sxe::SX_UNIQUE_PTR< initial_pseudostate > initial_pseudostate_uptr
 
typedef sxe::SX_UNIQUE_PTR< join > join_uptr
 
typedef std::vector< join_uptr > joins
 
typedef std::vector< const join *> raw_const_joins
 
typedef sxe::SX_UNIQUE_PTR< junction > junction_uptr
 
typedef std::vector< junction_uptr > junctions
 
typedef std::vector< const junction *> raw_const_junctions
 
typedef sxe::SX_UNIQUE_PTR< pseudostate > pseudostate_uptr
 
typedef std::vector< pseudostate_uptr > pseudostates
 
typedef std::vector< const pseudostate *> raw_const_pseudostates
 
typedef sxe::SX_UNIQUE_PTR< region > region_uptr
 
typedef std::vector< region_uptr > regions
 
typedef std::vector< region *> raw_regions
 
typedef std::set< const region *> raw_const_region_set
 
typedef sxe::SX_UNIQUE_PTR< shallow_history > shallow_history_uptr
 
typedef sxe::SX_UNIQUE_PTR< state > state_uptr
 
typedef std::vector< const state *> raw_const_states
 
typedef std::vector< state_uptr > states
 
typedef std::set< const state *> raw_const_state_set
 
typedef std::set< const state *, states_nesting_comparer > raw_const_states_by_nesting_level
 
typedef std::set< state *, states_nesting_comparer > raw_states_by_nesting_level
 
typedef std::set< state *, states_nesting_comparer_ascending > raw_states_by_nesting_level_ascending
 
typedef std::vector< state_machine_defect > state_machine_defects
 
typedef sync_state_machine state_machine
 
typedef sxe::SX_UNIQUE_PTR< terminate_pseudostate > terminate_pseudostate_uptr
 
typedef std::vector< terminate_pseudostate_uptr > terminate_pseudostates
 
typedef std::vector< const terminate_pseudostate *> raw_const_terminate_pseudostates
 
typedef std::set< event_creation_request, event_creation_request_time_comparer > event_queue
 
typedef sxe::SX_UNIQUE_PTR< transition > transition_uptr
 
typedef std::vector< const transition *> raw_const_transitions
 
typedef std::vector< transition *> raw_transitions
 
typedef std::vector< transition_uptr > transitions
 
typedef sxe::SX_UNIQUE_PTR< vertex > vertex_uptr
 
typedef std::vector< const vertex *> raw_const_vertices
 
typedef std::vector< vertex_uptr > vertices
 
typedef sxe::SX_UNIQUE_PTR< compound_transition > compound_transition_uptr
 
typedef std::vector< compound_transition *> raw_compound_transitions
 
typedef std::vector< compound_transition_uptr > compound_transitions
 
typedef sxe::SX_UNIQUE_PTR< execution_step > execution_step_uptr
 
typedef std::vector< execution_step_uptr > execution_steps
 
typedef sxe::SX_UNIQUE_PTR< transition_step > transition_step_uptr
 
typedef std::vector< transition_step_uptr > transition_steps
 

Enumerations

enum  state_machine_status {
  state_machine_status::NEW, state_machine_status::STARTED, state_machine_status::STOP_REQUESTED, state_machine_status::TERMINATED,
  state_machine_status::STOPPED
}
 
enum  transition_kind { transition_kind::EXTERNAL = 0, transition_kind::INTERNAL = 1, transition_kind::LOCAL = 2 }
 

Functions

template<typename T >
sxe::function< void()> adapt (T *_object, void(T::*_method)())
 
template<typename T , typename _event_type >
sxe::function< void(const _event_type &)> adapt (T *_object, void(T::*_method)(const _event_type &))
 
template<typename T >
sxe::function< void(sxy::event_collector &)> adapt (T *_object, void(T::*_method)(sxy::event_collector &))
 
template<typename T , typename _event_type >
sxe::function< void(const _event_type &, sxy::event_collector &)> adapt (T *_object, void(T::*_method)(const _event_type &, sxy::event_collector &))
 
sxe::function< void()> adapt_function (void(*_function)())
 
template<typename _event_type >
sxe::function< void(const _event_type &)> adapt_function (void(*_function)(const _event_type &))
 
template<typename _event_type >
sxe::function< void(const _event_type &, sxy::event_collector &)> adapt_function (void(*_function)(const _event_type &, sxy::event_collector &))
 
template<typename T >
sxe::function< bool()> adapt (T *_object, bool(T::*_method)())
 
template<typename T , typename _event_type >
sxe::function< bool(const _event_type &)> adapt (T *_object, bool(T::*_method)(const _event_type &))
 
template<typename T >
sxe::function< bool(sxy::event_collector &)> adapt (T *_object, bool(T::*_method)(sxy::event_collector &))
 
template<typename T , typename _event_type >
sxe::function< bool(const _event_type &, sxy::event_collector &)> adapt (T *_object, bool(T::*_method)(const _event_type &, sxy::event_collector &))
 
sxe::function< bool()> adapt_function (bool(*_function)())
 
template<typename _event_type >
sxe::function< bool(const _event_type &)> adapt_function (bool(*_function)(const _event_type &))
 
template<typename _event_type >
sxe::function< bool(const _event_type &, sxy::event_collector &)> adapt_function (bool(*_function)(const _event_type &, sxy::event_collector &))
 
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void()> &_function)
 
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(event_collector &)> &_function)
 
template<typename _event_type >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type &)> &_function)
 
template<typename _event_type >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type &, sxy::event_collector &_event_collector)> &_function)
 
template<typename _event_type1 , typename _event_type2 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &_function4)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &_function5)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &_function6)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &_function7)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &_function7, const sxe::function< void(const _event_type8 &, sxy::event_collector &)> &_function8)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &_function7, const sxe::function< void(const _event_type8 &, sxy::event_collector &)> &_function8, const sxe::function< void(const _event_type9 &, sxy::event_collector &)> &_function9)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 , typename _event_type10 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &_function7, const sxe::function< void(const _event_type8 &, sxy::event_collector &)> &_function8, const sxe::function< void(const _event_type9 &, sxy::event_collector &)> &_function9, const sxe::function< void(const _event_type10 &, sxy::event_collector &)> &_function10)
 
template<typename ... Args>
sxy::behavior_function create_behavior_function (Args...args)
 
template<typename ... Args>
sxy::constraint_function create_guard_function (Args...args)
 
template<typename _event_type >
const _event_type & adjust_event_type (const event &_event)
 
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool()> &_function)
 
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(sxy::event_collector &_event_collector)> &_function)
 
template<typename _event_type >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type &)> &_function)
 
template<typename _event_type >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type &, sxy::event_collector &_event_collector)> &_function)
 
template<typename _event_type1 , typename _event_type2 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &_function4)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &_function5)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &_function6)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &_function7)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &_function7, const sxe::function< bool(const _event_type8 &, sxy::event_collector &)> &_function8)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &_function7, const sxe::function< bool(const _event_type8 &, sxy::event_collector &)> &_function8, const sxe::function< bool(const _event_type9 &, sxy::event_collector &)> &_function9)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 , typename _event_type10 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &_function1, const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &_function2, const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &_function3, const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &_function4, const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &_function5, const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &_function6, const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &_function7, const sxe::function< bool(const _event_type8 &, sxy::event_collector &)> &_function8, const sxe::function< bool(const _event_type9 &, sxy::event_collector &)> &_function9, const sxe::function< bool(const _event_type10 &, sxy::event_collector &)> &_function10)
 
void write_defects_to_log (const state_machine_defects &_defects)
 
std::string to_string (const transition_kind _kind)
 
bool try_to_build_compound_transition (transition &_enabled_transition, compound_transitions &_enabled_compound_transitions, const event &_event, event_collector &_event_collector)
 
compound_transition_uptr build_compound_transition (transition &_first_transition, const event &_event, event_collector &_event_collector)
 
void dummy_to_silence_linker_warning_in_adapter_cpp03 ()
 
sxe::function< void(sxy::event_collector &)> adapt_function (void(*_function)(sxy::event_collector &))
 
sxe::function< bool(sxy::event_collector &)> adapt_function (bool(*_function)(sxy::event_collector &))
 
void dummy_to_silence_linker_warning_in_create_behavior_function ()
 
void dummy_to_silence_linker_warning_in_create_guard_function ()
 

Variables

sxe::function< void(sxy::event_collector &)> adapt_function (void(*_function)(sxy::event_collector &))
 
const int TRANSITION_PRIORITIES_VECTOR_SIZE = 16
 
const int EXECUTION_STEPS_VECTOR_SIZE = 128
 
const int TRANSITION_STEPS_VECTOR_SIZE = 128
 
const int COMPOUND_TRANSITIONS_VECTOR_SIZE = 8
 
const int STATES_TO_EXIT_VECTOR_SIZE
 
const int EXCEPTION_EVENTS_VECTOR_SIZE = 8
 
const int CHOICES_VECTOR_SIZE = 8
 
const int ENABLED_COMPOUND_TRANSITION_VECTOR_SIZE = 16
 
const int DEFERRED_EVENTS_VECTOR_SIZE = 16
 
const int DEFAULT_TRANSITIONS_OF_HISTORY_VECTORS_SIZE = 8
 
const int ENTRY_POINTS_VECTOR_SIZE = 8
 
const int EXIT_POINTS_VECTOR_SIZE = 8
 
const int PSEUDOSTETS_IN_REGION_VECTOR_SIZE = 16
 
const int ANCESTORS_VECTOR_SIZE = 64
 
const int ASCENDING_PATH_ANCESTORS_VECTOR_SIZE = 64
 
const int REGIONS_OF_FINAL_STATE = 0
 
const int REGIONS_OF_SIMPLE_STATE = 0
 
const int ANCESTORS_REGION_VECTOR_SIZE = 64
 
const int ACTIVE_STATE_CONFIGRATION_VECTOR_SIZE = 32
 
constexpr event_id Y_COMPLETION_EVENT_ID = std::numeric_limits<sxy::event_id>::max()
 
const handle_type Y_INVALID_EVENT_CREATION_REQUEST_HANDLE = std::numeric_limits< handle_type >::max()
 
const handle_type Y_DEFAULT_HANDLE = 0
 
constexpr event_priority STATE_MACHINE_INTERNAL_EVENT_PRIORITY = 127
 yasmine's predefined event priority for the internal use. More...
 
constexpr event_priority DEFAULT_EVENT_PRIORITY = 0
 yasmine's predefined default event priority. More...
 

Typedef Documentation

◆ async_behavior_uptr

typedef sxe::SX_UNIQUE_PTR< async_behavior > sxy::async_behavior_uptr

◆ behavior_exception_uptr

typedef sxe::SX_UNIQUE_PTR< behavior_exception > sxy::behavior_exception_uptr

◆ behavior_exceptions

typedef std::vector< behavior_exception_uptr > sxy::behavior_exceptions

◆ behavior_function

typedef sxe::function< void ( const event&, event_collector& ) > sxy::behavior_function

◆ behavior_uptr

typedef sxe::SX_UNIQUE_PTR< behavior > sxy::behavior_uptr

◆ choice_uptr

typedef sxe::SX_UNIQUE_PTR< choice > sxy::choice_uptr

◆ choices

typedef std::vector< choice_uptr > sxy::choices

◆ composite_state_uptr

typedef sxe::SX_UNIQUE_PTR< composite_state > sxy::composite_state_uptr

◆ compound_transition_uptr

typedef sxe::SX_UNIQUE_PTR< compound_transition > sxy::compound_transition_uptr

◆ compound_transitions

typedef std::vector< compound_transition_uptr > sxy::compound_transitions

◆ constraint_function

typedef sxe::function< bool ( const event&, event_collector& ) > sxy::constraint_function

◆ constraint_uptr

typedef sxe::SX_UNIQUE_PTR< constraint > sxy::constraint_uptr

◆ deep_history_uptr

typedef sxe::SX_UNIQUE_PTR< deep_history > sxy::deep_history_uptr

◆ entry_point_uptr

typedef sxe::SX_UNIQUE_PTR< entry_point > sxy::entry_point_uptr

◆ entry_points

typedef std::vector< entry_point_uptr > sxy::entry_points

◆ event_id

typedef sxe::uint32_t sxy::event_id

The type alias for yasmine's event IDs.

◆ event_ids

typedef std::vector< event_id > sxy::event_ids

The type alias for yasmine's event ID list.

◆ event_priority

typedef sxe::int8_t sxy::event_priority

The type alias for yasmine's event priorities.

◆ event_prioritys

typedef std::vector< event_priority > sxy::event_prioritys

The type alias for yasmine's event priority list.

◆ event_queue

typedef std::set< event_creation_request, event_creation_request_time_comparer > sxy::event_queue

◆ event_sptr

typedef sxe::shared_ptr< event > sxy::event_sptr

◆ events

typedef std::vector< event_sptr > sxy::events

◆ execution_step_uptr

typedef sxe::SX_UNIQUE_PTR< execution_step > sxy::execution_step_uptr

◆ execution_steps

typedef std::vector< execution_step_uptr > sxy::execution_steps

◆ exit_point_uptr

typedef sxe::SX_UNIQUE_PTR< exit_point > sxy::exit_point_uptr

◆ exit_points

typedef std::vector< exit_point_uptr > sxy::exit_points

◆ fork_uptr

typedef sxe::SX_UNIQUE_PTR< fork > sxy::fork_uptr

◆ forks

typedef std::vector< fork_uptr > sxy::forks

◆ handle_type

typedef sxe::uint32_t sxy::handle_type

The type alias for yasmine's event handle.

◆ initial_pseudostate_uptr

typedef sxe::SX_UNIQUE_PTR< initial_pseudostate > sxy::initial_pseudostate_uptr

◆ join_uptr

typedef sxe::SX_UNIQUE_PTR< join > sxy::join_uptr

◆ joins

typedef std::vector< join_uptr > sxy::joins

◆ junction_uptr

typedef sxe::SX_UNIQUE_PTR< junction > sxy::junction_uptr

◆ junctions

typedef std::vector< junction_uptr > sxy::junctions

◆ pseudostate_uptr

typedef sxe::SX_UNIQUE_PTR< pseudostate > sxy::pseudostate_uptr

◆ pseudostates

typedef std::vector< pseudostate_uptr > sxy::pseudostates

◆ raw_composite_states

typedef std::vector< composite_state* > sxy::raw_composite_states

◆ raw_compound_transitions

typedef std::vector< compound_transition* > sxy::raw_compound_transitions

◆ raw_const_choices

typedef std::vector< const choice* > sxy::raw_const_choices

◆ raw_const_entry_points

typedef std::vector< const entry_point* > sxy::raw_const_entry_points

◆ raw_const_exit_points

typedef std::vector< const exit_point* > sxy::raw_const_exit_points

◆ raw_const_forks

typedef std::vector< const fork* > sxy::raw_const_forks

◆ raw_const_joins

typedef std::vector< const join* > sxy::raw_const_joins

◆ raw_const_junctions

typedef std::vector< const junction* > sxy::raw_const_junctions

◆ raw_const_pseudostates

typedef std::vector< const pseudostate* > sxy::raw_const_pseudostates

◆ raw_const_region_set

typedef std::set< const region* > sxy::raw_const_region_set

◆ raw_const_state_set

typedef std::set< const state* > sxy::raw_const_state_set

◆ raw_const_states

typedef std::vector< const state* > sxy::raw_const_states

◆ raw_const_states_by_nesting_level

typedef std::set< const state*, states_nesting_comparer > sxy::raw_const_states_by_nesting_level

◆ raw_const_terminate_pseudostates

typedef std::vector< const terminate_pseudostate* > sxy::raw_const_terminate_pseudostates

◆ raw_const_transitions

typedef std::vector< const transition* > sxy::raw_const_transitions

◆ raw_const_vertices

typedef std::vector< const vertex* > sxy::raw_const_vertices

◆ raw_regions

typedef std::vector< region* > sxy::raw_regions

◆ raw_states_by_nesting_level

typedef std::set< state*, states_nesting_comparer > sxy::raw_states_by_nesting_level

◆ raw_states_by_nesting_level_ascending

typedef std::set< state*, states_nesting_comparer_ascending > sxy::raw_states_by_nesting_level_ascending

◆ raw_transitions

typedef std::vector< transition* > sxy::raw_transitions

◆ region_uptr

typedef sxe::SX_UNIQUE_PTR< region > sxy::region_uptr

◆ regions

typedef std::vector< region_uptr > sxy::regions

◆ shallow_history_uptr

typedef sxe::SX_UNIQUE_PTR< shallow_history > sxy::shallow_history_uptr

◆ state_machine

typedef sync_state_machine sxy::state_machine
Deprecated:
use sync_state_machine instead

◆ state_machine_defects

typedef std::vector< state_machine_defect > sxy::state_machine_defects

◆ state_uptr

typedef sxe::SX_UNIQUE_PTR< state > sxy::state_uptr

◆ states

typedef std::vector< state_uptr > sxy::states

◆ terminate_pseudostate_uptr

typedef sxe::SX_UNIQUE_PTR< terminate_pseudostate > sxy::terminate_pseudostate_uptr

◆ terminate_pseudostates

typedef std::vector< terminate_pseudostate_uptr > sxy::terminate_pseudostates

◆ transition_step_uptr

typedef sxe::SX_UNIQUE_PTR< transition_step > sxy::transition_step_uptr

◆ transition_steps

typedef std::vector< transition_step_uptr > sxy::transition_steps

◆ transition_uptr

typedef sxe::SX_UNIQUE_PTR< transition > sxy::transition_uptr

◆ transitions

typedef std::vector< transition_uptr > sxy::transitions

◆ vertex_uptr

typedef sxe::SX_UNIQUE_PTR< vertex > sxy::vertex_uptr

◆ vertices

typedef std::vector< vertex_uptr > sxy::vertices

Enumeration Type Documentation

◆ state_machine_status

enum sxy::state_machine_status
strong
Enumerator
NEW 
STARTED 
STOP_REQUESTED 
TERMINATED 
STOPPED 

◆ transition_kind

enum sxy::transition_kind
strong
Enumerator
EXTERNAL 
INTERNAL 
LOCAL 

Function Documentation

◆ adapt() [1/8]

template<typename T >
sxe::function< void()> sxy::adapt ( T *  _object,
void(T::*)()  _method 
)

◆ adapt() [2/8]

template<typename T , typename _event_type >
sxe::function< void(const _event_type &)> sxy::adapt ( T *  _object,
void(T::*)(const _event_type &)  _method 
)

◆ adapt() [3/8]

template<typename T >
sxe::function< void(sxy::event_collector &)> sxy::adapt ( T *  _object,
void(T::*)(sxy::event_collector &)  _method 
)

◆ adapt() [4/8]

template<typename T , typename _event_type >
sxe::function< void(const _event_type &, sxy::event_collector &)> sxy::adapt ( T *  _object,
void(T::*)(const _event_type &, sxy::event_collector &)  _method 
)

◆ adapt() [5/8]

template<typename T >
sxe::function< bool()> sxy::adapt ( T *  _object,
bool(T::*)()  _method 
)

◆ adapt() [6/8]

template<typename T , typename _event_type >
sxe::function< bool(const _event_type &)> sxy::adapt ( T *  _object,
bool(T::*)(const _event_type &)  _method 
)

◆ adapt() [7/8]

template<typename T >
sxe::function< bool(sxy::event_collector &)> sxy::adapt ( T *  _object,
bool(T::*)(sxy::event_collector &)  _method 
)

◆ adapt() [8/8]

template<typename T , typename _event_type >
sxe::function< bool(const _event_type &, sxy::event_collector &)> sxy::adapt ( T *  _object,
bool(T::*)(const _event_type &, sxy::event_collector &)  _method 
)

◆ adapt_function() [1/8]

sxe::function<void( sxy::event_collector& )> sxy::adapt_function ( void(*)(sxy::event_collector &)  _function)

◆ adapt_function() [2/8]

sxe::function<bool( sxy::event_collector& )> sxy::adapt_function ( bool(*)(sxy::event_collector &)  _function)

◆ adapt_function() [3/8]

sxe::function<void()> sxy::adapt_function ( void(*)()  _function)

◆ adapt_function() [4/8]

template<typename _event_type >
sxe::function<void( const _event_type& )> sxy::adapt_function ( void(*)(const _event_type &)  _function)

◆ adapt_function() [5/8]

template<typename _event_type >
sxe::function<void( const _event_type&, sxy::event_collector& )> sxy::adapt_function ( void(*)(const _event_type &, sxy::event_collector &)  _function)

◆ adapt_function() [6/8]

sxe::function<bool()> sxy::adapt_function ( bool(*)()  _function)

◆ adapt_function() [7/8]

template<typename _event_type >
sxe::function<bool( const _event_type& )> sxy::adapt_function ( bool(*)(const _event_type &)  _function)

◆ adapt_function() [8/8]

template<typename _event_type >
sxe::function<bool( const _event_type&, sxy::event_collector& )> sxy::adapt_function ( bool(*)(const _event_type &, sxy::event_collector &)  _function)

◆ adjust_event_type()

template<typename _event_type >
const _event_type& sxy::adjust_event_type ( const event &  _event)

◆ behavior_caller() [1/13]

void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void()> &  _function 
)

◆ behavior_caller() [2/13]

void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(event_collector &)> &  _function 
)

◆ behavior_caller() [3/13]

template<typename _event_type >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type &)> &  _function 
)

◆ behavior_caller() [4/13]

template<typename _event_type >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type &, sxy::event_collector &_event_collector)> &  _function 
)

◆ behavior_caller() [5/13]

template<typename _event_type1 , typename _event_type2 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2 
)

◆ behavior_caller() [6/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3 
)

◆ behavior_caller() [7/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &  _function4 
)

◆ behavior_caller() [8/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &  _function5 
)

◆ behavior_caller() [9/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &  _function6 
)

◆ behavior_caller() [10/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &  _function7 
)

◆ behavior_caller() [11/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &  _function7,
const sxe::function< void(const _event_type8 &, sxy::event_collector &)> &  _function8 
)

◆ behavior_caller() [12/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &  _function7,
const sxe::function< void(const _event_type8 &, sxy::event_collector &)> &  _function8,
const sxe::function< void(const _event_type9 &, sxy::event_collector &)> &  _function9 
)

◆ behavior_caller() [13/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 , typename _event_type10 >
void sxy::behavior_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< void(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< void(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< void(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< void(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< void(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< void(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< void(const _event_type7 &, sxy::event_collector &)> &  _function7,
const sxe::function< void(const _event_type8 &, sxy::event_collector &)> &  _function8,
const sxe::function< void(const _event_type9 &, sxy::event_collector &)> &  _function9,
const sxe::function< void(const _event_type10 &, sxy::event_collector &)> &  _function10 
)

◆ build_compound_transition()

compound_transition_uptr sxy::build_compound_transition ( transition &  _first_transition,
const event &  _event,
event_collector &  _event_collector 
)

◆ create_behavior_function()

template<typename ... Args>
sxy::behavior_function sxy::create_behavior_function ( Args...  args)

◆ create_guard_function()

template<typename ... Args>
sxy::constraint_function sxy::create_guard_function ( Args...  args)

◆ dummy_to_silence_linker_warning_in_adapter_cpp03()

void sxy::dummy_to_silence_linker_warning_in_adapter_cpp03 ( )

◆ dummy_to_silence_linker_warning_in_create_behavior_function()

void sxy::dummy_to_silence_linker_warning_in_create_behavior_function ( )

◆ dummy_to_silence_linker_warning_in_create_guard_function()

void sxy::dummy_to_silence_linker_warning_in_create_guard_function ( )

◆ guard_caller() [1/13]

bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool()> &  _function 
)

◆ guard_caller() [2/13]

bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(sxy::event_collector &_event_collector)> &  _function 
)

◆ guard_caller() [3/13]

template<typename _event_type >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type &)> &  _function 
)

◆ guard_caller() [4/13]

template<typename _event_type >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type &, sxy::event_collector &_event_collector)> &  _function 
)

◆ guard_caller() [5/13]

template<typename _event_type1 , typename _event_type2 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2 
)

◆ guard_caller() [6/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3 
)

◆ guard_caller() [7/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &  _function4 
)

◆ guard_caller() [8/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &  _function5 
)

◆ guard_caller() [9/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &  _function6 
)

◆ guard_caller() [10/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &  _function7 
)

◆ guard_caller() [11/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &  _function7,
const sxe::function< bool(const _event_type8 &, sxy::event_collector &)> &  _function8 
)

◆ guard_caller() [12/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &  _function7,
const sxe::function< bool(const _event_type8 &, sxy::event_collector &)> &  _function8,
const sxe::function< bool(const _event_type9 &, sxy::event_collector &)> &  _function9 
)

◆ guard_caller() [13/13]

template<typename _event_type1 , typename _event_type2 , typename _event_type3 , typename _event_type4 , typename _event_type5 , typename _event_type6 , typename _event_type7 , typename _event_type8 , typename _event_type9 , typename _event_type10 >
bool sxy::guard_caller ( const sxy::event &  _event,
sxy::event_collector &  _event_collector,
const sxe::function< bool(const _event_type1 &, sxy::event_collector &)> &  _function1,
const sxe::function< bool(const _event_type2 &, sxy::event_collector &)> &  _function2,
const sxe::function< bool(const _event_type3 &, sxy::event_collector &)> &  _function3,
const sxe::function< bool(const _event_type4 &, sxy::event_collector &)> &  _function4,
const sxe::function< bool(const _event_type5 &, sxy::event_collector &)> &  _function5,
const sxe::function< bool(const _event_type6 &, sxy::event_collector &)> &  _function6,
const sxe::function< bool(const _event_type7 &, sxy::event_collector &)> &  _function7,
const sxe::function< bool(const _event_type8 &, sxy::event_collector &)> &  _function8,
const sxe::function< bool(const _event_type9 &, sxy::event_collector &)> &  _function9,
const sxe::function< bool(const _event_type10 &, sxy::event_collector &)> &  _function10 
)

◆ to_string()

std::string sxy::to_string ( const transition_kind  _kind)

◆ try_to_build_compound_transition()

bool sxy::try_to_build_compound_transition ( transition &  _enabled_transition,
compound_transitions &  _enabled_compound_transitions,
const event &  _event,
event_collector &  _event_collector 
)

◆ write_defects_to_log()

void sxy::write_defects_to_log ( const state_machine_defects &  _defects)

Variable Documentation

◆ ACTIVE_STATE_CONFIGRATION_VECTOR_SIZE

const int sxy::ACTIVE_STATE_CONFIGRATION_VECTOR_SIZE = 32

◆ adapt_function

sxe::function< bool()> sxy::adapt_function

◆ ANCESTORS_REGION_VECTOR_SIZE

const int sxy::ANCESTORS_REGION_VECTOR_SIZE = 64

◆ ANCESTORS_VECTOR_SIZE

const int sxy::ANCESTORS_VECTOR_SIZE = 64

◆ ASCENDING_PATH_ANCESTORS_VECTOR_SIZE

const int sxy::ASCENDING_PATH_ANCESTORS_VECTOR_SIZE = 64

◆ CHOICES_VECTOR_SIZE

const int sxy::CHOICES_VECTOR_SIZE = 8

◆ COMPOUND_TRANSITIONS_VECTOR_SIZE

const int sxy::COMPOUND_TRANSITIONS_VECTOR_SIZE = 8

◆ DEFAULT_EVENT_PRIORITY

constexpr event_priority sxy::DEFAULT_EVENT_PRIORITY = 0

yasmine's predefined default event priority.

◆ DEFAULT_TRANSITIONS_OF_HISTORY_VECTORS_SIZE

const int sxy::DEFAULT_TRANSITIONS_OF_HISTORY_VECTORS_SIZE = 8

◆ DEFERRED_EVENTS_VECTOR_SIZE

const int sxy::DEFERRED_EVENTS_VECTOR_SIZE = 16

◆ ENABLED_COMPOUND_TRANSITION_VECTOR_SIZE

const int sxy::ENABLED_COMPOUND_TRANSITION_VECTOR_SIZE = 16

◆ ENTRY_POINTS_VECTOR_SIZE

const int sxy::ENTRY_POINTS_VECTOR_SIZE = 8

◆ EXCEPTION_EVENTS_VECTOR_SIZE

const int sxy::EXCEPTION_EVENTS_VECTOR_SIZE = 8

◆ EXECUTION_STEPS_VECTOR_SIZE

const int sxy::EXECUTION_STEPS_VECTOR_SIZE = 128

◆ EXIT_POINTS_VECTOR_SIZE

const int sxy::EXIT_POINTS_VECTOR_SIZE = 8

◆ PSEUDOSTETS_IN_REGION_VECTOR_SIZE

const int sxy::PSEUDOSTETS_IN_REGION_VECTOR_SIZE = 16

◆ REGIONS_OF_FINAL_STATE

const int sxy::REGIONS_OF_FINAL_STATE = 0

◆ REGIONS_OF_SIMPLE_STATE

const int sxy::REGIONS_OF_SIMPLE_STATE = 0

◆ STATE_MACHINE_INTERNAL_EVENT_PRIORITY

constexpr event_priority sxy::STATE_MACHINE_INTERNAL_EVENT_PRIORITY = 127

yasmine's predefined event priority for the internal use.

◆ STATES_TO_EXIT_VECTOR_SIZE

const int sxy::STATES_TO_EXIT_VECTOR_SIZE

◆ TRANSITION_PRIORITIES_VECTOR_SIZE

const int sxy::TRANSITION_PRIORITIES_VECTOR_SIZE = 16

◆ TRANSITION_STEPS_VECTOR_SIZE

const int sxy::TRANSITION_STEPS_VECTOR_SIZE = 128

◆ Y_COMPLETION_EVENT_ID

constexpr event_id sxy::Y_COMPLETION_EVENT_ID = std::numeric_limits<sxy::event_id>::max()

◆ Y_DEFAULT_HANDLE

const handle_type sxy::Y_DEFAULT_HANDLE = 0

◆ Y_INVALID_EVENT_CREATION_REQUEST_HANDLE

const handle_type sxy::Y_INVALID_EVENT_CREATION_REQUEST_HANDLE = std::numeric_limits< handle_type >::max()