yasmine
sxy Namespace Reference

Namespaces

 impl
 
 model
 
 utils
 
 version
 

Classes

class  async_behavior
 
class  async_event_handler
 
class  behavior
 
struct  behavior_struct
 
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
 
struct  config
 
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. 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_behaviorasync_behavior_uptr
 
typedef sxe::SX_UNIQUE_PTR< behavior_exception > behavior_exception_uptr
 
typedef std::vector< behavior_exception_uptrbehavior_exceptions
 
typedef sxe::SX_UNIQUE_PTR< behaviorbehavior_uptr
 
typedef sxe::function< void(const event &, event_collector &) > behavior_function
 
typedef sxe::SX_UNIQUE_PTR< choicechoice_uptr
 
typedef std::vector< choice_uptrchoices
 
typedef std::vector< const choice *> raw_const_choices
 
typedef sxe::SX_UNIQUE_PTR< composite_statecomposite_state_uptr
 
typedef std::vector< composite_state *> raw_composite_states
 
typedef sxe::SX_UNIQUE_PTR< constraintconstraint_uptr
 
typedef sxe::function< bool(const event &, event_collector &) > constraint_function
 
typedef sxe::SX_UNIQUE_PTR< deep_historydeep_history_uptr
 
typedef sxe::SX_UNIQUE_PTR< entry_pointentry_point_uptr
 
typedef std::vector< entry_point_uptrentry_points
 
typedef std::vector< const entry_point *> raw_const_entry_points
 
typedef sxe::shared_ptr< eventevent_sptr
 
typedef std::vector< event_sptrevents
 
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_idevent_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_priorityevent_prioritys
 The type alias for yasmine's event priority list. More...
 
typedef sxe::SX_UNIQUE_PTR< exit_pointexit_point_uptr
 
typedef std::vector< exit_point_uptrexit_points
 
typedef std::vector< const exit_point *> raw_const_exit_points
 
typedef sxe::SX_UNIQUE_PTR< forkfork_uptr
 
typedef std::vector< fork_uptrforks
 
typedef std::vector< const fork *> raw_const_forks
 
typedef sxe::SX_UNIQUE_PTR< initial_pseudostateinitial_pseudostate_uptr
 
typedef sxe::SX_UNIQUE_PTR< joinjoin_uptr
 
typedef std::vector< join_uptrjoins
 
typedef std::vector< const join *> raw_const_joins
 
typedef sxe::SX_UNIQUE_PTR< junctionjunction_uptr
 
typedef std::vector< junction_uptrjunctions
 
typedef std::vector< const junction *> raw_const_junctions
 
typedef sxe::SX_UNIQUE_PTR< pseudostatepseudostate_uptr
 
typedef std::vector< pseudostate_uptrpseudostates
 
typedef std::vector< const pseudostate *> raw_const_pseudostates
 
typedef sxe::SX_UNIQUE_PTR< regionregion_uptr
 
typedef std::vector< region_uptrregions
 
typedef std::vector< region *> raw_regions
 
typedef std::set< const region *> raw_const_region_set
 
typedef sxe::SX_UNIQUE_PTR< shallow_historyshallow_history_uptr
 
typedef sxe::SX_UNIQUE_PTR< statestate_uptr
 
typedef std::vector< const state *> raw_const_states
 
typedef std::vector< state_uptrstates
 
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_pseudostateterminate_pseudostate_uptr
 
typedef std::vector< terminate_pseudostate_uptrterminate_pseudostates
 
typedef std::vector< const terminate_pseudostate *> raw_const_terminate_pseudostates
 
typedef std::set< event_creation_request, event_creation_request_time_comparerevent_queue
 
typedef sxe::SX_UNIQUE_PTR< transitiontransition_uptr
 
typedef std::vector< const transition *> raw_const_transitions
 
typedef std::vector< transition *> raw_transitions
 
typedef std::vector< transition_uptrtransitions
 
typedef sxe::SX_UNIQUE_PTR< vertexvertex_uptr
 
typedef std::vector< const vertex *> raw_const_vertices
 
typedef std::vector< vertex_uptrvertices
 
typedef sxe::SX_UNIQUE_PTR< compound_transitioncompound_transition_uptr
 
typedef std::vector< compound_transition *> raw_compound_transitions
 
typedef std::vector< compound_transition_uptrcompound_transitions
 
typedef sxe::SX_UNIQUE_PTR< execution_stepexecution_step_uptr
 
typedef std::vector< execution_step_uptrexecution_steps
 
typedef sxe::SX_UNIQUE_PTR< transition_steptransition_step_uptr
 
typedef std::vector< transition_step_uptrtransition_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 }
 
enum  access_operator {
  access_operator::AO_NO_ACCESS_OPERATOR = 0, access_operator::AO_THIS_ACCESS = 1, access_operator::AO_POINTER_ACCESS = 2, access_operator::AO_REFERENCE_ACCESS = 3,
  access_operator::AO_FUNCTION_ACCESS = 4
}
 Enumeration for predefined access operator. More...
 
enum  state_machine_type { state_machine_type::SMT_SYNC = 0, state_machine_type::SMT_ASYNC = 1 }
 Enumeration for state machine types. More...
 

Functions

void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< void()> _method)
 
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< void(event_collector &)> _method)
 
template<typename _event_type >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< void(const _event_type &)> _method)
 
template<typename _event_type >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< void(const _event_type &, sxy::event_collector &_event_collector)> _method)
 
template<typename _event_type1 , typename _event_type2 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 >
void behavior_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3)
 
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, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< void(const _event_type4 &, sxy::event_collector &)> _method4)
 
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, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< void(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< void(const _event_type5 &, sxy::event_collector &)> _method5)
 
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, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< void(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< void(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< void(const _event_type6 &, sxy::event_collector &)> _method6)
 
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, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< void(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< void(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< void(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< void(const _event_type7 &, sxy::event_collector &)> _method7)
 
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, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< void(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< void(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< void(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< void(const _event_type7 &, sxy::event_collector &)> _method7, sxe::function< void(const _event_type8 &, sxy::event_collector &)> _method8)
 
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, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< void(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< void(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< void(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< void(const _event_type7 &, sxy::event_collector &)> _method7, sxe::function< void(const _event_type8 &, sxy::event_collector &)> _method8, sxe::function< void(const _event_type9 &, sxy::event_collector &)> _method9)
 
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, sxe::function< void(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< void(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< void(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< void(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< void(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< void(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< void(const _event_type7 &, sxy::event_collector &)> _method7, sxe::function< void(const _event_type8 &, sxy::event_collector &)> _method8, sxe::function< void(const _event_type9 &, sxy::event_collector &)> _method9, sxe::function< void(const _event_type10 &, sxy::event_collector &)> _method10)
 
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, sxe::function< bool()> _method)
 
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< bool(sxy::event_collector &_event_collector)> _method)
 
template<typename _event_type >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< bool(const _event_type &)> _method)
 
template<typename _event_type >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< bool(const _event_type &, sxy::event_collector &_event_collector)> _method)
 
template<typename _event_type1 , typename _event_type2 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2)
 
template<typename _event_type1 , typename _event_type2 , typename _event_type3 >
bool guard_caller (const sxy::event &_event, sxy::event_collector &_event_collector, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3)
 
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, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< bool(const _event_type4 &, sxy::event_collector &)> _method4)
 
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, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< bool(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< bool(const _event_type5 &, sxy::event_collector &)> _method5)
 
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, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< bool(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< bool(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< bool(const _event_type6 &, sxy::event_collector &)> _method6)
 
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, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< bool(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< bool(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< bool(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< bool(const _event_type7 &, sxy::event_collector &)> _method7)
 
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, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< bool(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< bool(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< bool(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< bool(const _event_type7 &, sxy::event_collector &)> _method7, sxe::function< bool(const _event_type8 &, sxy::event_collector &)> _method8)
 
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, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< bool(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< bool(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< bool(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< bool(const _event_type7 &, sxy::event_collector &)> _method7, sxe::function< bool(const _event_type8 &, sxy::event_collector &)> _method8, sxe::function< bool(const _event_type9 &, sxy::event_collector &)> _method9)
 
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, sxe::function< bool(const _event_type1 &, sxy::event_collector &)> _method1, sxe::function< bool(const _event_type2 &, sxy::event_collector &)> _method2, sxe::function< bool(const _event_type3 &, sxy::event_collector &)> _method3, sxe::function< bool(const _event_type4 &, sxy::event_collector &)> _method4, sxe::function< bool(const _event_type5 &, sxy::event_collector &)> _method5, sxe::function< bool(const _event_type6 &, sxy::event_collector &)> _method6, sxe::function< bool(const _event_type7 &, sxy::event_collector &)> _method7, sxe::function< bool(const _event_type8 &, sxy::event_collector &)> _method8, sxe::function< bool(const _event_type9 &, sxy::event_collector &)> _method9, sxe::function< bool(const _event_type10 &, sxy::event_collector &)> _method10)
 
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 generate (const sxy::config &_config)
 
state_machine_type sm_type_from_string (const std::string &_type)
 
const std::string sm_type_to_string (const state_machine_type &_type)
 
const std::string get_state_machine_class_as_string (const state_machine_type &_type)
 
std::istream & operator>> (std::istream &_in_stream, sxy::state_machine_type &_sm_type)
 
const unsigned int YEAR_1900 (1900)
 
const unsigned int WIDTH_YEAR (4)
 
const unsigned int WIDTH_CLOCK (2)
 
const char FILL_VALUE ( '0')
 
std::string get_object_member_string (const rapidjson::Value &_obj, const char *const _name_of_member)
 
sxe::int64_t get_object_member_int (const rapidjson::Value &_obj, const char *const _name_of_member)
 
const rapidjson::Value & get_object_member_array (const rapidjson::Value &_obj, const char *const _name_of_member)
 
std::vector< const rapidjson::Value *> extract_members_from_array (const rapidjson::Value &_array)
 
void string_to_json (const char *const _json_as_string, rapidjson::Document &_document)
 
const rapidjson::Value & find_member (const rapidjson::Value &_member, const char *const _name)
 
const rapidjson::Value & find_object_member (const rapidjson::Value &_document, const char *const _name)
 

Variables

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...
 
const std::string VARIABLE_STATE_MACHINE_NAME_CAPS = "state_machine_name_caps"
 
const std::string VARIABLE_STATE_MACHINE_NAME = "state_machine_name"
 
const std::string VARIABLE_STATE_MACHINE_TYPE = "state_machine_type"
 
const std::string VARIABLE_NAMESPACE_NAME = "namespace_name"
 
const std::string LOOP_NAMESPACE_OPEN = "namespace_open"
 
const std::string VARIABLE_NAMESPACE_CLOSE = "namespace_close"
 
const std::string VARIABLE_BEHAVIOR_CLASS_NAME = "behavior_class_name"
 
const std::string LOOP_BEHAVIOR_CLASSES = "behavior_classes"
 
const std::string VARIABLE_LAST_BEHAVIOR_CLASS = "last_behavior_class"
 
const std::string LOOP_TRANSITIONS = "transitions"
 
const std::string VARIABLE_EVENT_ID = "event_id"
 
const std::string VARIABLE_EVENT_NAME = "event_name"
 
const std::string VARIABLE_EVENT_PRIORITY = "priority"
 
const std::string TRANSITION_EVENT_ID = "transition_event_id"
 
const std::string VARIABLE_SOURCE_VERTEX = "source_vertex"
 
const std::string VARIABLE_TARGET_VERTEX = "target_vertex"
 
const std::string VARIABLE_TRANSITION_KIND = "transition_kind"
 
const std::string VARIABLE_TRANSITION_KIND_NAMESPACE = "sxy::transition_kind::"
 
const std::string VARIABLE_EMPTY_BEHAVIOR = "Y_EMPTY_BEHAVIOR"
 
const std::string VARIABLE_EMPTY_GUARD = "Y_EMPTY_GUARD"
 
const std::string LOOP_REGIONS = "regions"
 
const std::string VARIABLE_VERTICES = "vertices"
 
const std::string LOOP_PSEUDOSTATES = "pseudostates"
 
const std::string LOOP_STATE_PSEUDOSTATES = "state_pseudostates"
 
const std::string LOOP_STATES = "states"
 
const std::string VARIABLE_REGION_NAME = "region_name"
 
const std::string VARIABLE_ROOT_NAME = "root_name"
 
const std::string VARIABLE_CURRENT_STATE_NAME = "current_state_name"
 
const std::string VARIABLE_DATE_TIME = "datetime"
 
const unsigned int YEAR_1900
 
const unsigned int WIDTH_YEAR
 
const unsigned int WIDTH_CLOCK
 
const char FILL_VALUE
 
const char SLASH_CHAR = '/'
 
const char COLON_CHAR = ':'
 
const std::string DOUBLE_COLON = "::"
 
const char OPEN_BRACE_CHAR = '{'
 
const char CLOSE_BRACE_CHAR = '}'
 
const char COMMA_CHAR = ','
 
const char AND_CHAR = '&'
 
const char DOT_CHAR = '.'
 
const char UNDERSCORE_CHAR = '_'
 
const std::string VARIABLE_COMPLETION_EVENT_ID = "sxy::Y_COMPLETION_EVENT_ID"
 
const std::string CONDITION_IS_COMPOSITE_STATE = "is_composite_state"
 
const std::string CONDITION_IS_STATE = "is_state"
 
const std::string LOOP_EVENTS = "events"
 
const std::string VARIABLE_STATE_NAME = "state_name"
 
const std::string VARIABLE_STATE_TYPE = "state_type"
 
const std::string VARIABLE_PSEUDOSTATE_NAME = "pseudostate_name"
 
const std::string VARIABLE_PSEUDOSTATE_TYPE = "pseudostate_type"
 
const std::string VARIABLE_STATE_PSEUDOSTATE_NAME = "state_pseudostate_name"
 
const std::string VARIABLE_STATE_PSEUDOSTATE_TYPE = "state_pseudostate_type"
 
const std::string SWITCH_ENTER_BEHAVIOR = "enter_behavior"
 
const std::string SWITCH_DO_BEHAVIOR = "do_behavior"
 
const std::string SWITCH_EXIT_BEHAVIOR = "exit_behavior"
 
const std::string SWITCH_TRANSITION_GUARD = "transition_guard"
 
const std::string SWITCH_TRANSITION_BEHAVIOR = "transition_behavior"
 
const std::string THIS_ACCESS = "this->"
 
const std::string POINTER_ACCESS = "->"
 
const std::string REFERENCE_ACCESS = "."
 
const std::string VARIABLE_GUARD_FUNCTION2 = "Y_GUARD_FUNCTION2"
 
const std::string VARIABLE_GUARD_METHOD2 = "Y_GUARD_METHOD2"
 
const std::string VARIABLE_BEHAVIOR_FUNCTION2 = "Y_BEHAVIOR_FUNCTION2"
 
const std::string VARIABLE_BEHAVIOR_METHOD2 = "Y_BEHAVIOR_METHOD2"
 
const std::string VARIABLE_METHOD_NAME = "behavior_method_name"
 
const std::string VARIABLE_CLASS_INSTANCE_NAME = "class_instance_name"
 
const std::string VARIABLE_SM_SYNC = "sync"
 
const std::string VARIABLE_SM_ASYNC = "async"
 
const std::string VARIABLE_SYNC_SM_CLASS = "sxy::sync_state_machine"
 
const std::string VARIABLE_ASYNC_SM_CLASS = "sxy::async_state_machine"
 
const char VARIABLE_CLOSE_PARENTHESIS = ')'
 
const char VARIABLE_OPEN_PARENTHESIS = '('
 
const std::string CONDITION_LAST_PSEUDOSTATE = "last_pseudostate"
 
const int SWITCH_DEFAULT_INDEX = -1
 

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

◆ 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

◆ 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

◆ 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

◆ 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

◆ 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

◆ terminate_pseudostates

◆ transition_step_uptr

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

◆ 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

◆ access_operator

enum sxy::access_operator
strong

Enumeration for predefined access operator.

Enumerator
AO_NO_ACCESS_OPERATOR 
AO_THIS_ACCESS 
AO_POINTER_ACCESS 
AO_REFERENCE_ACCESS 
AO_FUNCTION_ACCESS 

◆ state_machine_status

Enumerator
NEW 
STARTED 
STOP_REQUESTED 
TERMINATED 
STOPPED 

◆ state_machine_type

Enumeration for state machine types.

Enumerator
SMT_SYNC 
SMT_ASYNC 

◆ transition_kind

enum sxy::transition_kind
strong
Enumerator
EXTERNAL 
INTERNAL 
LOCAL 

Function Documentation

◆ 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,
sxe::function< void()>  _method 
)

◆ behavior_caller() [2/13]

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

◆ behavior_caller() [3/13]

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

◆ behavior_caller() [4/13]

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

◆ behavior_caller() [5/13]

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

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3 
)

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< void(const _event_type4 &, sxy::event_collector &)>  _method4 
)

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< void(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< void(const _event_type5 &, sxy::event_collector &)>  _method5 
)

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< void(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< void(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< void(const _event_type6 &, sxy::event_collector &)>  _method6 
)

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< void(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< void(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< void(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< void(const _event_type7 &, sxy::event_collector &)>  _method7 
)

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< void(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< void(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< void(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< void(const _event_type7 &, sxy::event_collector &)>  _method7,
sxe::function< void(const _event_type8 &, sxy::event_collector &)>  _method8 
)

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< void(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< void(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< void(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< void(const _event_type7 &, sxy::event_collector &)>  _method7,
sxe::function< void(const _event_type8 &, sxy::event_collector &)>  _method8,
sxe::function< void(const _event_type9 &, sxy::event_collector &)>  _method9 
)

◆ 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,
sxe::function< void(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< void(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< void(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< void(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< void(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< void(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< void(const _event_type7 &, sxy::event_collector &)>  _method7,
sxe::function< void(const _event_type8 &, sxy::event_collector &)>  _method8,
sxe::function< void(const _event_type9 &, sxy::event_collector &)>  _method9,
sxe::function< void(const _event_type10 &, sxy::event_collector &)>  _method10 
)

◆ build_compound_transition()

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

◆ extract_members_from_array()

std::vector< const rapidjson::Value *> sxy::extract_members_from_array ( const rapidjson::Value &  _array)

◆ FILL_VALUE()

const char sxy::FILL_VALUE ( '0'  )

◆ find_member()

const rapidjson::Value & sxy::find_member ( const rapidjson::Value &  _member,
const char *const  _name 
)

◆ find_object_member()

const rapidjson::Value & sxy::find_object_member ( const rapidjson::Value &  _document,
const char *const  _name 
)

◆ generate()

void sxy::generate ( const sxy::config _config)

◆ get_object_member_array()

const rapidjson::Value & sxy::get_object_member_array ( const rapidjson::Value &  _obj,
const char *const  _name_of_member 
)

◆ get_object_member_int()

sxe::int64_t sxy::get_object_member_int ( const rapidjson::Value &  _obj,
const char *const  _name_of_member 
)

◆ get_object_member_string()

std::string sxy::get_object_member_string ( const rapidjson::Value &  _obj,
const char *const  _name_of_member 
)

◆ get_state_machine_class_as_string()

const std::string sxy::get_state_machine_class_as_string ( const state_machine_type _type)

◆ guard_caller() [1/13]

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

◆ guard_caller() [2/13]

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

◆ guard_caller() [3/13]

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

◆ guard_caller() [4/13]

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

◆ guard_caller() [5/13]

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

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3 
)

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< bool(const _event_type4 &, sxy::event_collector &)>  _method4 
)

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< bool(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< bool(const _event_type5 &, sxy::event_collector &)>  _method5 
)

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< bool(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< bool(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< bool(const _event_type6 &, sxy::event_collector &)>  _method6 
)

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< bool(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< bool(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< bool(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< bool(const _event_type7 &, sxy::event_collector &)>  _method7 
)

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< bool(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< bool(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< bool(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< bool(const _event_type7 &, sxy::event_collector &)>  _method7,
sxe::function< bool(const _event_type8 &, sxy::event_collector &)>  _method8 
)

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< bool(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< bool(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< bool(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< bool(const _event_type7 &, sxy::event_collector &)>  _method7,
sxe::function< bool(const _event_type8 &, sxy::event_collector &)>  _method8,
sxe::function< bool(const _event_type9 &, sxy::event_collector &)>  _method9 
)

◆ 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,
sxe::function< bool(const _event_type1 &, sxy::event_collector &)>  _method1,
sxe::function< bool(const _event_type2 &, sxy::event_collector &)>  _method2,
sxe::function< bool(const _event_type3 &, sxy::event_collector &)>  _method3,
sxe::function< bool(const _event_type4 &, sxy::event_collector &)>  _method4,
sxe::function< bool(const _event_type5 &, sxy::event_collector &)>  _method5,
sxe::function< bool(const _event_type6 &, sxy::event_collector &)>  _method6,
sxe::function< bool(const _event_type7 &, sxy::event_collector &)>  _method7,
sxe::function< bool(const _event_type8 &, sxy::event_collector &)>  _method8,
sxe::function< bool(const _event_type9 &, sxy::event_collector &)>  _method9,
sxe::function< bool(const _event_type10 &, sxy::event_collector &)>  _method10 
)

◆ operator>>()

std::istream & sxy::operator>> ( std::istream &  _in_stream,
sxy::state_machine_type _sm_type 
)

◆ sm_type_from_string()

state_machine_type sxy::sm_type_from_string ( const std::string &  _type)

◆ sm_type_to_string()

const std::string sxy::sm_type_to_string ( const state_machine_type _type)

◆ string_to_json()

void sxy::string_to_json ( const char *const  _json_as_string,
rapidjson::Document &  _document 
)

◆ 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 
)

◆ WIDTH_CLOCK()

const unsigned int sxy::WIDTH_CLOCK ( )

◆ WIDTH_YEAR()

const unsigned int sxy::WIDTH_YEAR ( )

◆ write_defects_to_log()

void sxy::write_defects_to_log ( const state_machine_defects _defects)

◆ YEAR_1900()

const unsigned int sxy::YEAR_1900 ( 1900  )

Variable Documentation

◆ ACTIVE_STATE_CONFIGRATION_VECTOR_SIZE

const int sxy::ACTIVE_STATE_CONFIGRATION_VECTOR_SIZE = 32

◆ ANCESTORS_REGION_VECTOR_SIZE

const int sxy::ANCESTORS_REGION_VECTOR_SIZE = 64

◆ ANCESTORS_VECTOR_SIZE

const int sxy::ANCESTORS_VECTOR_SIZE = 64

◆ AND_CHAR

const char sxy::AND_CHAR = '&'

◆ ASCENDING_PATH_ANCESTORS_VECTOR_SIZE

const int sxy::ASCENDING_PATH_ANCESTORS_VECTOR_SIZE = 64

◆ CHOICES_VECTOR_SIZE

const int sxy::CHOICES_VECTOR_SIZE = 8

◆ CLOSE_BRACE_CHAR

const char sxy::CLOSE_BRACE_CHAR = '}'

◆ COLON_CHAR

const char sxy::COLON_CHAR = ':'

◆ COMMA_CHAR

const char sxy::COMMA_CHAR = ','

◆ COMPOUND_TRANSITIONS_VECTOR_SIZE

const int sxy::COMPOUND_TRANSITIONS_VECTOR_SIZE = 8

◆ CONDITION_IS_COMPOSITE_STATE

const std::string sxy::CONDITION_IS_COMPOSITE_STATE = "is_composite_state"

◆ CONDITION_IS_STATE

const std::string sxy::CONDITION_IS_STATE = "is_state"

◆ CONDITION_LAST_PSEUDOSTATE

const std::string sxy::CONDITION_LAST_PSEUDOSTATE = "last_pseudostate"

◆ 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

◆ DOT_CHAR

const char sxy::DOT_CHAR = '.'

◆ DOUBLE_COLON

const std::string sxy::DOUBLE_COLON = "::"

◆ 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

◆ FILL_VALUE

const char sxy::FILL_VALUE

◆ LOOP_BEHAVIOR_CLASSES

const std::string sxy::LOOP_BEHAVIOR_CLASSES = "behavior_classes"

◆ LOOP_EVENTS

const std::string sxy::LOOP_EVENTS = "events"

◆ LOOP_NAMESPACE_OPEN

const std::string sxy::LOOP_NAMESPACE_OPEN = "namespace_open"

◆ LOOP_PSEUDOSTATES

const std::string sxy::LOOP_PSEUDOSTATES = "pseudostates"

◆ LOOP_REGIONS

const std::string sxy::LOOP_REGIONS = "regions"

◆ LOOP_STATE_PSEUDOSTATES

const std::string sxy::LOOP_STATE_PSEUDOSTATES = "state_pseudostates"

◆ LOOP_STATES

const std::string sxy::LOOP_STATES = "states"

◆ LOOP_TRANSITIONS

const std::string sxy::LOOP_TRANSITIONS = "transitions"

◆ OPEN_BRACE_CHAR

const char sxy::OPEN_BRACE_CHAR = '{'

◆ POINTER_ACCESS

const std::string sxy::POINTER_ACCESS = "->"

◆ PSEUDOSTETS_IN_REGION_VECTOR_SIZE

const int sxy::PSEUDOSTETS_IN_REGION_VECTOR_SIZE = 16

◆ REFERENCE_ACCESS

const std::string sxy::REFERENCE_ACCESS = "."

◆ REGIONS_OF_FINAL_STATE

const int sxy::REGIONS_OF_FINAL_STATE = 0

◆ REGIONS_OF_SIMPLE_STATE

const int sxy::REGIONS_OF_SIMPLE_STATE = 0

◆ SLASH_CHAR

const char sxy::SLASH_CHAR = '/'

◆ 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

◆ SWITCH_DEFAULT_INDEX

const int sxy::SWITCH_DEFAULT_INDEX = -1

◆ SWITCH_DO_BEHAVIOR

const std::string sxy::SWITCH_DO_BEHAVIOR = "do_behavior"

◆ SWITCH_ENTER_BEHAVIOR

const std::string sxy::SWITCH_ENTER_BEHAVIOR = "enter_behavior"

◆ SWITCH_EXIT_BEHAVIOR

const std::string sxy::SWITCH_EXIT_BEHAVIOR = "exit_behavior"

◆ SWITCH_TRANSITION_BEHAVIOR

const std::string sxy::SWITCH_TRANSITION_BEHAVIOR = "transition_behavior"

◆ SWITCH_TRANSITION_GUARD

const std::string sxy::SWITCH_TRANSITION_GUARD = "transition_guard"

◆ THIS_ACCESS

const std::string sxy::THIS_ACCESS = "this->"

◆ TRANSITION_EVENT_ID

const std::string sxy::TRANSITION_EVENT_ID = "transition_event_id"

◆ TRANSITION_PRIORITIES_VECTOR_SIZE

const int sxy::TRANSITION_PRIORITIES_VECTOR_SIZE = 16

◆ TRANSITION_STEPS_VECTOR_SIZE

const int sxy::TRANSITION_STEPS_VECTOR_SIZE = 128

◆ UNDERSCORE_CHAR

const char sxy::UNDERSCORE_CHAR = '_'

◆ VARIABLE_ASYNC_SM_CLASS

const std::string sxy::VARIABLE_ASYNC_SM_CLASS = "sxy::async_state_machine"

◆ VARIABLE_BEHAVIOR_CLASS_NAME

const std::string sxy::VARIABLE_BEHAVIOR_CLASS_NAME = "behavior_class_name"

◆ VARIABLE_BEHAVIOR_FUNCTION2

const std::string sxy::VARIABLE_BEHAVIOR_FUNCTION2 = "Y_BEHAVIOR_FUNCTION2"

◆ VARIABLE_BEHAVIOR_METHOD2

const std::string sxy::VARIABLE_BEHAVIOR_METHOD2 = "Y_BEHAVIOR_METHOD2"

◆ VARIABLE_CLASS_INSTANCE_NAME

const std::string sxy::VARIABLE_CLASS_INSTANCE_NAME = "class_instance_name"

◆ VARIABLE_CLOSE_PARENTHESIS

const char sxy::VARIABLE_CLOSE_PARENTHESIS = ')'

◆ VARIABLE_COMPLETION_EVENT_ID

const std::string sxy::VARIABLE_COMPLETION_EVENT_ID = "sxy::Y_COMPLETION_EVENT_ID"

◆ VARIABLE_CURRENT_STATE_NAME

const std::string sxy::VARIABLE_CURRENT_STATE_NAME = "current_state_name"

◆ VARIABLE_DATE_TIME

const std::string sxy::VARIABLE_DATE_TIME = "datetime"

◆ VARIABLE_EMPTY_BEHAVIOR

const std::string sxy::VARIABLE_EMPTY_BEHAVIOR = "Y_EMPTY_BEHAVIOR"

◆ VARIABLE_EMPTY_GUARD

const std::string sxy::VARIABLE_EMPTY_GUARD = "Y_EMPTY_GUARD"

◆ VARIABLE_EVENT_ID

const std::string sxy::VARIABLE_EVENT_ID = "event_id"

◆ VARIABLE_EVENT_NAME

const std::string sxy::VARIABLE_EVENT_NAME = "event_name"

◆ VARIABLE_EVENT_PRIORITY

const std::string sxy::VARIABLE_EVENT_PRIORITY = "priority"

◆ VARIABLE_GUARD_FUNCTION2

const std::string sxy::VARIABLE_GUARD_FUNCTION2 = "Y_GUARD_FUNCTION2"

◆ VARIABLE_GUARD_METHOD2

const std::string sxy::VARIABLE_GUARD_METHOD2 = "Y_GUARD_METHOD2"

◆ VARIABLE_LAST_BEHAVIOR_CLASS

const std::string sxy::VARIABLE_LAST_BEHAVIOR_CLASS = "last_behavior_class"

◆ VARIABLE_METHOD_NAME

const std::string sxy::VARIABLE_METHOD_NAME = "behavior_method_name"

◆ VARIABLE_NAMESPACE_CLOSE

const std::string sxy::VARIABLE_NAMESPACE_CLOSE = "namespace_close"

◆ VARIABLE_NAMESPACE_NAME

const std::string sxy::VARIABLE_NAMESPACE_NAME = "namespace_name"

◆ VARIABLE_OPEN_PARENTHESIS

const char sxy::VARIABLE_OPEN_PARENTHESIS = '('

◆ VARIABLE_PSEUDOSTATE_NAME

const std::string sxy::VARIABLE_PSEUDOSTATE_NAME = "pseudostate_name"

◆ VARIABLE_PSEUDOSTATE_TYPE

const std::string sxy::VARIABLE_PSEUDOSTATE_TYPE = "pseudostate_type"

◆ VARIABLE_REGION_NAME

const std::string sxy::VARIABLE_REGION_NAME = "region_name"

◆ VARIABLE_ROOT_NAME

const std::string sxy::VARIABLE_ROOT_NAME = "root_name"

◆ VARIABLE_SM_ASYNC

const std::string sxy::VARIABLE_SM_ASYNC = "async"

◆ VARIABLE_SM_SYNC

const std::string sxy::VARIABLE_SM_SYNC = "sync"

◆ VARIABLE_SOURCE_VERTEX

const std::string sxy::VARIABLE_SOURCE_VERTEX = "source_vertex"

◆ VARIABLE_STATE_MACHINE_NAME

const std::string sxy::VARIABLE_STATE_MACHINE_NAME = "state_machine_name"

◆ VARIABLE_STATE_MACHINE_NAME_CAPS

const std::string sxy::VARIABLE_STATE_MACHINE_NAME_CAPS = "state_machine_name_caps"

◆ VARIABLE_STATE_MACHINE_TYPE

const std::string sxy::VARIABLE_STATE_MACHINE_TYPE = "state_machine_type"

◆ VARIABLE_STATE_NAME

const std::string sxy::VARIABLE_STATE_NAME = "state_name"

◆ VARIABLE_STATE_PSEUDOSTATE_NAME

const std::string sxy::VARIABLE_STATE_PSEUDOSTATE_NAME = "state_pseudostate_name"

◆ VARIABLE_STATE_PSEUDOSTATE_TYPE

const std::string sxy::VARIABLE_STATE_PSEUDOSTATE_TYPE = "state_pseudostate_type"

◆ VARIABLE_STATE_TYPE

const std::string sxy::VARIABLE_STATE_TYPE = "state_type"

◆ VARIABLE_SYNC_SM_CLASS

const std::string sxy::VARIABLE_SYNC_SM_CLASS = "sxy::sync_state_machine"

◆ VARIABLE_TARGET_VERTEX

const std::string sxy::VARIABLE_TARGET_VERTEX = "target_vertex"

◆ VARIABLE_TRANSITION_KIND

const std::string sxy::VARIABLE_TRANSITION_KIND = "transition_kind"

◆ VARIABLE_TRANSITION_KIND_NAMESPACE

const std::string sxy::VARIABLE_TRANSITION_KIND_NAMESPACE = "sxy::transition_kind::"

◆ VARIABLE_VERTICES

const std::string sxy::VARIABLE_VERTICES = "vertices"

◆ WIDTH_CLOCK

const unsigned int sxy::WIDTH_CLOCK

◆ WIDTH_YEAR

const unsigned int sxy::WIDTH_YEAR

◆ 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()

◆ YEAR_1900

const unsigned int sxy::YEAR_1900