| ►Nso_5 | Private part of message limit implementation |
| ►Nanonymous_namespace{environment.cpp} | |
| Cautoshutdown_guard_t | |
| Ccore_data_sources_t | A bunch of data sources for core objects |
| Cdefault_event_queue_hook_t | Default implementation of event_queue_hook |
| ►Nanonymous_namespace{event_exception_logger.cpp} | |
| Cstd_event_exception_logger_t | Standard exception logger implementation |
| ►Nanonymous_namespace{queue_locks_defaults_manager.cpp} | |
| Cmanager_for_combined_locks_t | |
| Cmanager_for_simple_locks_t | |
| ►Nanonymous_namespace{wrapped_env.cpp} | |
| Cactual_environment_t | Implementation of environment to be used inside wrapped_env |
| ►Nas_msink_impl | |
| Cmbox_as_sink_t | Implementation of abstract_message_sink for a case when the destination is a mbox |
| ►Ncustom_mbox_details | |
| Ccreator_iface_t | Interface for creator of new mbox in OOP style |
| Ccreator_template_t | Template-based implementation of creator interface |
| ►Ndetails | Some reusable and low-level classes/functions which can be used in public header files |
| ►Nagent_method_pointer_details | |
| Cno_arg | |
| Cwith_arg | |
| ►Nevent_subscription_helpers | Various helpers for event subscription |
| Cevent_handler_arg_maker | A helper template for create an argument for event handler in the case when argument is passed as value or const reference |
| Cevent_handler_arg_maker< immutable_msg< Msg > > | |
| Cevent_handler_arg_maker< mhood_t< immutable_msg< Msg > > > | A helper template for create an argument for event handler in the case when argument is passed as message hood |
| Cevent_handler_arg_maker< mhood_t< Msg > > | A helper template for create an argument for event handler in the case when argument is passed as message hood |
| Cevent_handler_arg_maker< mhood_t< mutable_msg< Msg > > > | A helper template for create an argument for event handler in the case when argument is passed as message hood |
| Cevent_handler_arg_maker< mutable_msg< Msg > > | |
| ►Nios_helpers | Helpers for manipulation with standard C++ I/O streams |
| Clength_limited_string | Helper for showing only part of long string |
| Cpointer | Helper for showing pointer value |
| ►Nlambda_traits | Helper templates for detection of lambda-type traits |
| ►Nimpl | Internal implementation details |
| Cargument_if_lambda | A detector of lambda argument type if the checked type is lambda |
| Cargument_if_lambda< true, L > | A specialization of lambda argument detector for the case when the checked type is a lambda |
| Chas_func_call_operator | A checker for lambda likeness |
| Chas_func_call_operator< L, std::void_t< decltype(&L::operator()) > > | |
| Cis_lambda | A detector that type is a lambda or functional object |
| Cplain_argument_type | Detector of plain type without const/volatile modifiers |
| Ctraits | Detector of lambda result and argument type |
| Ctraits< R(&)(M) > | Specialization of lambda traits for reference to ordinary function |
| Ctraits< R(*)(M) > | Specialization of lambda traits for ordinary function pointer |
| Ctraits< R(L::*)() > | Specialization of lambda traits for mutable lambda without argument |
| Ctraits< R(L::*)() const > | Specialization of lambda traits for const-lambda without argument |
| Ctraits< R(L::*)(M) > | Specialization of lambda traits for mutable lambda |
| Ctraits< R(L::*)(M) const > | Specialization of lambda traits for const-lambda |
| ►Nmessage_holder_details | |
| Caccessor_selector | A meta-function for selection of type of accessors mixin |
| Cbasic_message_holder_impl_t | Basic part of message_holder implementations |
| Cimpl_selector | A meta-function for selection a base of message_holder implementation in compile-time |
| Cmsg_accessors_t | An of mixin with getters for message_holder |
| Cshared_message_holder_impl_t | A part of implementation of message_holder to be used for shared ownership of message instances |
| Cunique_message_holder_impl_t | A part of implementation of message_holder to be used for unique ownership of message instances |
| ►Nrollback_on_exception_details | Implementation details for implementation of rollback on exception helper |
| Cexecutor | |
| Cexecutor< void, Main_Action, Rollback_Action > | |
| Crollbacker_t | Helper template class for do rollback actions automatically in the destructor |
| ►Nscope_exit_details | |
| Cat_exit_t | Helper class for scope exit implementation |
| Cactual_lock_holder_t | A class to be used as mixin with actual std::mutex instance inside |
| Calways_false | A simple metafunction that always "returns" false |
| Chandlers_bunch_basics_t | Basic part of handlers_bunch implementation |
| Chandlers_bunch_t | Template class for storing bunch of message handlers |
| Chandlers_bunch_t< 0 > | A specialization of handlers_bunch_t for the case when there is no any handlers |
| Cintroduce_coop_helper_t | Helper class for building and registering new cooperation |
| Cis_agent_method_pointer | Check whether T is a non-static member function pointer |
| Cis_agent_method_pointer< method_arity::nullary, Result(Agent::*)() > | |
| Cis_agent_method_pointer< method_arity::nullary, Result(Agent::*)() const > | |
| Cis_agent_method_pointer< method_arity::nullary, Result(Agent::*)() const noexcept > | |
| Cis_agent_method_pointer< method_arity::nullary, Result(Agent::*)() noexcept > | |
| Cis_agent_method_pointer< method_arity::unary, Result(Agent::*)(Handler_Argument) const > | |
| Cis_agent_method_pointer< method_arity::unary, Result(Agent::*)(Handler_Argument) const noexcept > | |
| Cis_agent_method_pointer< method_arity::unary, Result(Agent::*)(Handler_Argument) noexcept > | |
| Cis_agent_method_pointer< method_arity::unary, Result(Agent::*)(Handler_Argument)> | |
| Clock_holder_detector | A selector of actual lock_holder type in dependency of lock type |
| Clock_holder_detector< null_mutex_t > | |
| Cmake_message_instance_impl | |
| Cmake_message_instance_impl< true, Msg > | |
| Cmessage_handler_format_detector | A helper template to detect type of message from the format of an event handler |
| Cmessage_handler_format_detector< const MESSAGE & > | |
| Cmessage_handler_format_detector< const mhood_t< MESSAGE > & > | |
| Cmessage_handler_format_detector< mhood_t< MESSAGE > > | |
| Cmessage_mutability_traits | Detector of message type traits in dependency of message immutability or mutability |
| Cmessage_mutability_traits< immutable_msg< T > > | |
| Cmessage_mutability_traits< mutable_msg< T > > | |
| Cmhood_base_t | A type to be used as a base for mhood_t implementation |
| Cmhood_base_t< M, mhood_type_t::classical_message, message_mutability_t::immutable_message > | A special base for the case when message type is derived from message_t |
| Cmhood_base_t< M, mhood_type_t::classical_message, message_mutability_t::mutable_message > | A special base for the case when message type is derived from message_t |
| Cmhood_base_t< M, mhood_type_t::classical_signal, message_mutability_t::immutable_message > | A special base for the case when message type is derived from message_t |
| Cmhood_base_t< M, mhood_type_t::classical_signal, message_mutability_t::mutable_message > | A special base for the case when message type is derived from message_t |
| Cmhood_base_t< M, mhood_type_t::user_type_message, message_mutability_t::immutable_message > | A special base for the case when message type is not related to message_t |
| Cmhood_base_t< M, mhood_type_t::user_type_message, message_mutability_t::mutable_message > | A special base for the case when message type is not related to message_t |
| Cmhood_mutability_detector | A special detector of message immutability/mutability |
| Cmhood_type_detector | A special selector of message hood type |
| Cmsg_state_timeout | A signal to be used for switching to another state by timeout |
| Cmsg_type_and_handler_pair_t | Description of an event handler |
| Cno_lock_holder_t | A class to be used as mixin without any real mutex instance inside |
| Cremaining_time_counter_t | Helper class for calculating remaining time |
| Cshould_terminate_if_throws_t | Metafunction that tells is exceptions enabled or not |
| Cshould_terminate_if_throws_t< exceptions_enabled_t > | |
| Cshould_terminate_if_throws_t< terminate_if_throws_t > | |
| ►Ndisp | Event dispatchers |
| ►Nactive_group | Active groups dispatcher |
| ►Nimpl | Active groups dispatcher implemetation details |
| Cactual_binder_t | Implementation of binder interface for active_group dispatcher |
| Cactual_dispatcher_iface_t | An actual interface of active group dispatcher |
| Cbasic_dispatcher_iface_t | The very basic interface of active_group dispatcher |
| Cdispatcher_handle_maker_t | |
| ►Cdispatcher_template_t | Implementation of active object dispatcher in form of template class |
| Cdisp_data_source_t | Data source for run-time monitoring of whole dispatcher |
| Cthread_with_refcounter_t | Auxiliary class for the working agent counting |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for active_group dispatcher |
| ►Nactive_obj | Active objects dispatcher |
| ►Nimpl | Active objects dispatcher implemetation details |
| Cdispatcher_handle_maker_t | |
| ►Cdispatcher_template_t | Implementation of active object dispatcher in form of template class |
| Cdisp_data_source_t | Data source for run-time monitoring of whole dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for active_obj dispatcher |
| ►Nadv_thread_pool | Advanced thread pool dispatcher |
| ►Nimpl | Internal implementation details of advanced thread pool dispatcher |
| ►Nwork_thread_details | |
| Ccommon_data_t | Main data for work_thread |
| Cno_activity_tracking_impl_t | Part of implementation of work thread without activity tracing |
| Cwith_activity_tracking_impl_t | Part of implementation of work thread with activity tracing |
| Cwork_thread_template_t | Implementation of work_thread in form of template class |
| Cactual_binder_t | Actual implementation of binder for adv_thread_pool dispatcher |
| Cactual_dispatcher_iface_t | An actual interface of thread-pool dispatcher |
| Cactual_dispatcher_implementation_t | Actual implementation of adv_thread_pool dispatcher |
| Cadaptation_t | Adaptation of common implementation of thread-pool-like dispatcher to the specific of this thread-pool dispatcher |
| ►Cagent_queue_t | Event queue for the agent (or cooperation) |
| Cdemand_t | Actual demand in event queue |
| Cbasic_dispatcher_iface_t | The very basic interface of adv_thread_pool dispatcher |
| Cdispatcher_handle_maker_t | |
| Cbind_params_t | Parameters for binding agents to adv_thread_pool dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for adv_thread_pool dispatcher |
| ►Nmpmc_queue_traits | Various stuff related to MPMC event queue implementation and tuning |
| ►Ncombined_lock | Implementation of combined lock for MPMC event queue |
| Cactual_cond_t | Impementation of condition object for the case of combined lock |
| Cactual_lock_t | Actual implementation of combined lock object |
| ►Nsimple_lock | Implementation of simple lock for MPMC event queue |
| Cactual_cond_t | Actual implementation of condition object for the case of simple locking on mutex and condition_variable |
| Cactual_lock_t | Actual implementation of lock object for simple locking on mutex and condition variables |
| Ccondition_t | An interface for somethine like condition variable for waiting on MPMC queue lock |
| Clock_t | An interface for lock for MPMC queue |
| Cqueue_params_t | Container for storing parameters for MPMC queue |
| ►Nmpsc_queue_traits | Various stuff related to MPSC event queue implementation and tuning |
| ►Nimpl | Implementation details for MPSC event queue stuff |
| Ccombined_lock_t | A special combined lock for queue protection |
| Csimple_lock_t | A very simple lock based on usage of std::mutex and std::condition_variable |
| Clock_guard_t | An analog of std::lock_guard for MPSC queue lock |
| Clock_t | An interface for lock for MPSC queue |
| Cqueue_params_t | Container for storing parameters for MPSC queue |
| Cunique_lock_t | An analog of std::unique_lock for MPSC queue lock |
| ►Nnef_one_thread | |
| ►Nimpl | |
| ►Nwork_thread_details | |
| Ccommon_data_t | A common data for all work thread implementations |
| Cno_activity_tracking_impl_t | A part of implementation of work thread without activity tracking |
| Cwith_activity_tracking_impl_t | A part of implementation of work thread with activity tracking |
| Cagent_queue_t | |
| Cdemand_queue_t | |
| Cdemand_t | A single execution demand |
| Cdispatcher_handle_maker_t | |
| ►Cdispatcher_template_t | An implementation of dispatcher with one working thread and guarantee that evt_finish demands will be added to the queue without exceptions |
| Cdisp_data_source_t | Data source for run-time monitoring of whole dispatcher |
| Cwork_thread_template_t | A worker thread for nef_one_thread dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for nef_one_thread dispatcher |
| ►Nnef_thread_pool | |
| ►Nimpl | |
| Cactual_binder_t | Actual implementation of dispatcher binder for nef_thread_pool dispatcher |
| Cactual_dispatcher_iface_t | An actual interface of nef-thread-pool dispatcher |
| Cactual_dispatcher_implementation_t | Actual implementation of binder for nef_thread_pool dispatcher |
| Cadaptation_t | Adaptation of common implementation of thread-pool-like dispatcher to the specific of this thread-pool dispatcher |
| Cagent_queue_with_preallocated_finish_demand_t | Specail implementation of event queue for nef-thread-pool dispatcher |
| Cbasic_dispatcher_iface_t | The very basic interface of thread_pool dispatcher |
| Cdispatcher_handle_maker_t | |
| Cbind_params_t | Parameters for binding agents to nef_thread_pool dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for nef_thread_pool dispatcher |
| ►None_thread | Dispatcher with single working thread |
| ►Nimpl | Implementation details for dispatcher with single working thread |
| ►Ndata_source_details | |
| Ccommon_data_t | |
| Cactual_dispatcher_t | A dispatcher with the single working thread and an event queue |
| Cdata_source_t | Data source for one-thread dispatcher |
| Cdispatcher_handle_maker_t | |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for one_thread dispatcher |
| ►Nprio_dedicated_threads | Dispatchers with dedicated threads for every priority |
| ►None_per_prio | Dispatcher which creates exactly one thread per priority |
| ►Nimpl | Implementation details for dispatcher with one thread per priority |
| Cdispatcher_handle_maker_t | |
| ►Cdispatcher_template_t | An actual implementation of dispatcher with dedicated thread for every priority in form of a template class |
| Cdisp_data_source_t | Data source for run-time monitoring of whole dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for prio_dedicated_threads::one_per_prio dispatcher |
| ►Nprio_one_thread | Dispatcher with one working thread for events of all priorities |
| ►Nquoted_round_robin | Dispatcher which handles events of different priorities in round-robin maner |
| ►Nimpl | Implementation details for dispatcher with round-robin policy of handling prioritized events |
| ►Cdemand_queue_t | A demand queue for dispatcher with one common working thread and round-robin processing of prioritised demand on quoted basic |
| Cqueue_for_one_priority_t | Description of queue for one priority |
| Cqueue_stats_t | Statistic about one subqueue |
| Cshutdown_ex_t | This exception is thrown when pop is called after stop |
| Cdemand_t | A single execution demand |
| Cdispatcher_handle_maker_t | |
| ►Cdispatcher_template_t | An implementation of dispatcher with one working thread and support of demand priorities (quoted round robin policy) in form of template class |
| Cdisp_data_source_t | Data source for run-time monitoring of whole dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for prio_one_thread::strictly_ordered dispatcher |
| Cquotes_t | A storage of quotes for priorities |
| ►Nreuse | Reusable code for dispatchers with one working thread for events of all priorities |
| ►Nwork_thread_details | |
| Ccommon_data_t | A common data for all work thread implementations |
| Cno_activity_tracking_impl_t | A part of implementation of work thread without activity tracking |
| Cwith_activity_tracking_impl_t | A part of implementation of work thread with activity tracking |
| Cwork_thread_template_t | A working thread for dispatcher with one common working thread and support of demands priority |
| ►Nstrictly_ordered | Dispatcher which handles events in strict order (from highest priority to lowest) |
| ►Nimpl | Implementation details for dispatcher which handles prioritized events in strict order |
| ►Cdemand_queue_t | A demand queue with support of demands priorities |
| Cqueue_for_one_priority_t | Description of queue for one priority |
| Cqueue_stats_t | Statistic about one subqueue |
| Cshutdown_ex_t | This exception is thrown when pop is called after stop |
| Cdemand_t | A single execution demand |
| Cdispatcher_handle_maker_t | |
| ►Cdispatcher_template_t | An implementation of dispatcher with one working thread and support of demand priorities in form of template class |
| Cdisp_data_source_t | Data source for run-time monitoring of whole dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for prio_one_thread::strictly_ordered dispatcher |
| ►Nreuse | Reusable components for dispatchers |
| ►Nthread_pool_stats | Helper tools for implementation of run-time monitoring for thread-pool-like dispatchers |
| ►Cdata_source_t | Type of data source for thread-pool-like dispatchers |
| Ccollector_t | Actual type of statical information collector |
| Cwt_activity_info_t | Activity stats for a particular work thread |
| Cqueue_description_holder_t | A holder of one event queue information block |
| Cqueue_description_t | Description of one event queue |
| Cstats_consumer_t | An interface of collector of information about thread-pool-like dispatcher state |
| Cstats_supplier_t | An interface of supplier of information about thread-pool-like dispatcher state |
| ►Nwork_thread | Implemetation details of dispatcher's working thread |
| ►Ndemand_queue_details | |
| Ccommon_data_t | Common data for all implementations of demand_queue |
| Cno_activity_tracking_impl_t | A part of demand queue implementation for the case when activity tracking is not used |
| Cqueue_template_t | Implementation of demand_queue in form of a template |
| Cwith_activity_tracking_impl_t | A part of demand queue implementation for the case when activity tracking is used |
| ►Ndetails | |
| Cactivity_tracking_impl_t | Part of implementation of work thread with activity tracking |
| Ccommon_data_t | Common data for all work thread implementations |
| Cno_activity_tracking_impl_t | Part of implementation of work thread without activity tracking |
| Cwork_thread_template_t | Implementation of work thread in form of template |
| Cqueue_of_queues_t | Multi-producer/Multi-consumer queue of pointers to event queues |
| Cwork_thread_activity_tracking_flag_mixin_t | Mixin with thread activity tracking flag |
| Cwork_thread_factory_mixin_t | Mixin that holds optional work thread factory |
| ►Nstd_work_thread_impl | |
| Cstd_work_thread_factory_t | The standard implementation of abstract_work_thread_factory interface |
| Cstd_work_thread_t | The standard implementation of abstract_work_thread interface |
| ►Nthread_pool | Thread pool dispatcher |
| ►Ncommon_implementation | Reusable implementation of some thread pool dispatcher functionality which can be used in other thread-pool-like dispatchers |
| ►Cdispatcher_t | Reusable common implementation for thread-pool-like dispatchers |
| Cagent_data_t | Data for one agent |
| Ccooperation_data_t | Data for one cooperation |
| ►Nimpl | Internal implementation details of thread pool dispatcher |
| ►Nwork_thread_details | |
| Ccommon_data_t | Main data for work_thread |
| Ccommon_data_template_dependent_t | Part of common_data_t that depends on a template parameter |
| Ccommon_data_template_independent_t | Part of common_data_t that doesn't depend on a template parameter |
| Cno_activity_tracking_impl_t | Part of implementation of work thread without activity tracing |
| Cwith_activity_tracking_impl_t | Part of implementation of work thread with activity tracing |
| Cwork_thread_template_t | Implementation of work_thread in form of template class |
| Cactual_binder_t | Actual implementation of dispatcher binder for thread_pool dispatcher |
| Cactual_dispatcher_iface_t | An actual interface of thread-pool dispatcher |
| Cactual_dispatcher_implementation_t | Actual implementation of binder for thread_pool dispatcher |
| Cadaptation_t | Adaptation of common implementation of thread-pool-like dispatcher to the specific of this thread-pool dispatcher |
| Cagent_queue_t | Event queue for the agent (or cooperation) |
| Cbasic_dispatcher_iface_t | The very basic interface of thread_pool dispatcher |
| ►Cbasic_event_queue_t | |
| Cdemand_t | Actual demand in event queue |
| Cpop_result_t | A result of erasing of the front demand from queue |
| Cdispatcher_handle_maker_t | |
| Cbind_params_t | Parameters for binding agents to thread_pool dispatcher |
| Cdisp_params_t | Alias for namespace with traits of event queue |
| Cdispatcher_handle_t | A handle for thread_pool dispatcher |
| Cabstract_work_thread_factory_t | An interface of factory for management of worker threads |
| Cabstract_work_thread_t | An interface for one worker thread |
| Cwork_thread_holder_t | An analog of unique_ptr for abstract_work_thread |
| ►Nenv_infrastructures | Various implementations of environment_infrastructure |
| ►Ndefault_mt | Default multi-threaded environment infrastructure |
| ►Nimpl | Implementation details |
| ►Nanonymous_namespace{mt_env_infrastructure.cpp} | |
| Cbinder_getter_t | Helper class to be used with std::visit |
| Cdispatcher_maker_t | Helper class to be used with std::visit |
| Chandle_reseter_t | Helper class to be used with std::visit |
| Ccoop_repo_t | Implementation of coop_repository for multithreaded environment infrastructure |
| Cmt_env_infrastructure_t | Default implementation of multithreaded environment infrastructure |
| ►Nsimple_mtsafe | Simple single-threaded environment infrastructure with thread safety |
| ►Nimpl | Implementation details |
| Cdisp_ds_name_parts_t | A special class for generation of names for dispatcher data sources |
| Cenv_infrastructure_t | Default implementation of multithreaded environment infrastructure |
| ►Cevent_queue_impl_t | Implementation of event_queue interface for this type of environment infrastructure |
| Cstats_t | Type for representation of statistical data for this event queue |
| Cmain_thread_sync_objects_t | A bunch of sync objects which need to be shared between various parts of env_infrastructure |
| Cparams_t | Parameters for simple thread-safe single-thread environment |
| ►Nsimple_not_mtsafe | Simple single-threaded environment infrastructure without thread safety |
| ►Nimpl | Implementation details |
| Cdisp_ds_name_parts_t | A special class for generation of names for dispatcher data sources |
| Cenv_infrastructure_t | Default implementation of not-thread safe single-threaded environment infrastructure |
| ►Cevent_queue_impl_t | Implementation of event_queue interface for this type of environment infrastructure |
| Cstats_t | Type for representation of statistical data for this event queue |
| Cparams_t | Parameters for simple not-thread-safe single-thread environment |
| ►Nst_reusable_stuff | Various reusable stuff which can be used in implementation of single-threaded environment infrastructures |
| ►Cactual_elapsed_timers_collector_t | Implementation of elapsed_timers_collector interface |
| Cdemand_t | Type of demand created from elapsed timer |
| Ccoop_repo_t | Implementation of coop_repository for single-threaded environment infrastructure |
| Cdefault_dispatcher_basis_t | A basic part of implementation of dispatcher to be used in places where default dispatcher is needed |
| ►Cdefault_dispatcher_t | An implementation of dispatcher to be used in places where default dispatcher is needed |
| Cdisp_data_source_t | Data source for run-time monitoring of whole dispatcher |
| Cdirect_delivery_elapsed_timers_collector_t | Implementation of elapsed_timers_collector interface which is not multi-thread safe |
| Cfake_activity_tracker_t | An implementation of work thread activity tracking stuff for the case when activity tracking is not used |
| Creal_activity_tracker_t | An implementation of work thread activity tracking stuff for the case when activity tracking is used |
| Cstats_controller_t | Implementation of stats_controller for that type of single-threaded environment |
| ►Nenveloped_msg | |
| ►Nanonymous_namespace{enveloped_msg.cpp} | |
| Cpayload_access_handler_invoker_t | An implementation of handler_invoker interface for extraction of payload because of various reasons |
| ►Nimpl | |
| Cagent_demand_handler_invoker_t | An implementation of handler_invoker interface |
| Cmchain_demand_handler_invoker_t | An implementation of handler_invoker interface for the case when a mesage was sent to mchain |
| Cenvelope_t | An interface of envelope with some message/signal inside |
| Chandler_invoker_t | An extended version of handling_context which can be used for calling event handler |
| Cpayload_info_t | An information about payload inside envelope |
| ►Nexperimental | |
| ►Ntesting | |
| ►Ndetails | |
| ►Nmbox_receives_msg_impl | |
| Ca_msg_catcher_t | Agent that receives a message/signal from specified mbox |
| ►Cmsg_catcher_map_layer_t | Special layer that holds a map of catcher agents |
| Ccatcher_info_t | |
| ►Cabstract_scenario_step_t | An interface of testing scenario step |
| Ctoken_t | Type of token returned from pre-handler-hook |
| ►Cabstract_scenario_t | An interface of testing scenario |
| Ctoken_t | Type of token returned by pre-event-handler hook |
| Cagent_unfreezer_t | An interface for object that will unfreeze all registered agents when testing scenario starts |
| Cconstraint_t | An interface of step's constraints |
| Cincident_info_t | A description of an event for testing scenario |
| Cnot_after_constraint_t | Implementation of 'not_after' constraint |
| Cnot_before_constraint_t | Implementation of 'not_before' constraint |
| Creal_scenario_step_t | An actual implementation of step of testing scenario |
| Creal_scenario_t | The actual implementation of testing scenario |
| Creceives_indicator_t | Special indicator to be used in implementation of receives trigger |
| Cscenario_in_progress_accessor_t | A special objects that allows to call some specific methods of a testing scenario |
| Cstore_agent_state_name_t | A special data object for case of store-state-name completion action |
| Cstore_msg_inspection_result_t | A special data object for case when a message inspector has to be used on an incoming message |
| Ctrigger_activation_context_t | Description of context on that an attempt to activate a trigger is performing |
| Ctrigger_completion_context_t | Description of context on that a trigger is completed |
| Ctrigger_holder_t | A helper class for holding unique_ptr to a trigger while trigger is being configured |
| Ctrigger_source_t | A special data class with partial info for a new trigger |
| Ctrigger_t | An implementation of trigger for scenario's step |
| Cwait_event_handler_completion_t | A special data object for case when a step should be completed only after returning from the event handler |
| ►Nimpl | |
| Cinit_completed_data_t | A helper object for synchronization between helper worker where testing environment is launched and user thread |
| ►Cspecial_envelope_t | A special envelope that is necessary for testing scenarios |
| Cinvoker_for_message_extraction_t | |
| Cno_handler_invoker_t | A special invoker to be used to call no_handler_hook |
| Cpre_handler_hook_invoker_t | A special invoker to be used to call pre_handler_hook |
| Cspecial_event_queue_hook_t | A special event_queue_hook that creates instances of special event_queue for testing scenario |
| Cspecial_event_queue_t | A special event_queue to be used for testing scenarios |
| Cstop_guard_for_unfreezer_t | A special stop guard that unfreezes all agents if this is not done yet |
| ►Nv1 | |
| ►Ndetails | |
| ►Nmbox_receives_msg_impl | |
| Ca_msg_catcher_t | Agent that receives a message/signal from specified mbox |
| ►Cmsg_catcher_map_layer_t | Special layer that holds a map of catcher agents |
| Ccatcher_info_t | |
| ►Cabstract_scenario_step_t | An interface of testing scenario step |
| Ctoken_t | Type of token returned from pre-handler-hook |
| ►Cabstract_scenario_t | An interface of testing scenario |
| Ctoken_t | Type of token returned by pre-event-handler hook |
| Cagent_unfreezer_t | An interface for object that will unfreeze all registered agents when testing scenario starts |
| Cconstraint_t | An interface of step's constraints |
| Cincident_info_t | A description of an event for testing scenario |
| Cnot_after_constraint_t | Implementation of 'not_after' constraint |
| Cnot_before_constraint_t | Implementation of 'not_before' constraint |
| Creal_scenario_step_t | An actual implementation of step of testing scenario |
| Creal_scenario_t | The actual implementation of testing scenario |
| Creceives_indicator_t | Special indicator to be used in implementation of receives trigger |
| Cscenario_in_progress_accessor_t | A special objects that allows to call some specific methods of a testing scenario |
| Cstore_agent_state_name_t | A special data object for case of store-state-name completion action |
| Cstore_msg_inspection_result_t | A special data object for case when a message inspector has to be used on an incoming message |
| Ctrigger_activation_context_t | Description of context on that an attempt to activate a trigger is performing |
| Ctrigger_completion_context_t | Description of context on that a trigger is completed |
| Ctrigger_holder_t | A helper class for holding unique_ptr to a trigger while trigger is being configured |
| Ctrigger_source_t | A special data class with partial info for a new trigger |
| Ctrigger_t | An implementation of trigger for scenario's step |
| Cwait_event_handler_completion_t | A special data object for case when a step should be completed only after returning from the event handler |
| ►Nimpl | |
| Cinit_completed_data_t | A helper object for synchronization between helper worker where testing environment is launched and user thread |
| ►Cspecial_envelope_t | A special envelope that is necessary for testing scenarios |
| Cinvoker_for_message_extraction_t | |
| Cno_handler_invoker_t | A special invoker to be used to call no_handler_hook |
| Cpre_handler_hook_invoker_t | A special invoker to be used to call pre_handler_hook |
| Cspecial_event_queue_hook_t | A special event_queue_hook that creates instances of special event_queue for testing scenario |
| Cspecial_event_queue_t | A special event_queue to be used for testing scenarios |
| Cstop_guard_for_unfreezer_t | A special stop guard that unfreezes all agents if this is not done yet |
| Cscenario_proxy_t | A special wrapper around scenario object |
| Cscenario_result_t | The result of run of testing scenario |
| Cstep_definition_proxy_t | A special object that should be used for definition of a step of a testing scenario |
| ►Ctesting_env_t | A special testing environment that should be used for testing of agents |
| Cinternals_t | Internal data for testing environment |
| Cscenario_proxy_t | A special wrapper around scenario object |
| Cscenario_result_t | The result of run of testing scenario |
| Cstep_definition_proxy_t | A special object that should be used for definition of a step of a testing scenario |
| ►Ctesting_env_t | A special testing environment that should be used for testing of agents |
| Cinternals_t | Internal data for testing environment |
| ►Nimpl | Details of SObjectizer run-time implementations |
| ►Nadaptive_subscr_storage | An adaptive storage for agent's subscriptions information |
| Cstorage_t | An adaptive storage for agent's subscriptions information |
| ►Nagent_impl | Internal namespace with details of agent_t implementation |
| Cworking_thread_id_sentinel_t | A helper class for temporary setting and then dropping the ID of the current working thread |
| ►Nanonymous_namespace{coop_repository_basis.cpp} | |
| Ccoop_usage_counter_guard_t | Special guard to increment and decrement cooperation usage counters |
| ►Nflat_set_based_subscr_storage | A flat-set storage for agent's subscriptions information |
| ►Cstorage_t | A flat-set based storage for agent's subscriptions information |
| Cis_same_mbox_msg_t | A helper predicate for searching the same mbox and message type pairs |
| Ckey_info_comparator_t | A helper predicate for searching specific subscription |
| Ckey_info_t | Helper type for storing only key information about a subscription |
| ►Nhash_table_subscr_storage | A hash_table-based storage for agent's subscriptions information |
| Cequal_to_t | A special class for checking equality via pointer to key |
| Chash_t | A special class for calculating hash value via pointer to key |
| Ckey_t | Subscription key type |
| ►Cstorage_t | A storage for agent's subscriptions information |
| Cmbox_with_sink_info_t | |
| ►Nlocal_mbox_details | Implementation details for MPMC mboxes |
| Cdata_t | A coolection of data required for local mbox implementation |
| ►Csubscriber_adaptive_container_t | A special container for holding subscriber_info objects |
| Cconst_iterator | Const iterator type |
| Citerator | Iterator type |
| Csize_limits | |
| Csubscriber_ptr_compare_type | Predicate to be used for comparing keys in subscriber map |
| Csubscribers_vector_item_comparator | Predicate to be used for searching information in the vector |
| Csubscribers_vector_item_t | Information about one subscriber to be stored in a vector |
| Csubscription_info_with_sink_t | An information block about one subscription to one message type with presence of message_sink |
| ►Csubscription_info_without_sink_t | An information block about one subscription to one message type |
| Csubscription_present_t | Helper type that tells that subscription is present |
| ►Nmap_based_subscr_storage | A map-based storage for agent's subscriptions information |
| ►Nanonymous_namespace{subscr_storage_map_based.cpp} | |
| Cis_same_mbox_msg | |
| ►Cstorage_t | A map-based storage for agent's subscriptions information |
| Ckey_t | Type of key in subscription's map |
| Cvalue_t | Type of value for subscription map's item |
| ►Nmsg_tracing_helpers | Various helpers for message delivery tracing mechanism |
| ►Ndetails | Low-level details of message delivery tracing implementation |
| Cactual_trace_data_t | An actual implementation of trace data interface |
| Cchain_size | |
| Ccomposed_action_name | |
| Cmbox_as_msg_destination | |
| Cmbox_as_msg_source | |
| Cmbox_identification | |
| Cmchain_as_msg_source | |
| Cmchain_identification | |
| Coriginal_msg_type | |
| Credirection_deep | |
| Ctext_separator | |
| Ctype_of_removed_msg | |
| Ctype_of_transformed_msg | |
| ►Cmchain_tracing_disabled_base | Base class for a mchain for the case when message delivery tracing is disabled |
| Cdeliver_op_tracer | |
| ►Cmchain_tracing_enabled_base | Base class for a mchain for the case when message delivery tracing is enabled |
| Cdeliver_op_tracer | |
| ►Ctracing_disabled_base | Base class for a mbox for the case when message delivery tracing is disabled |
| Cdeliver_op_tracer | |
| ►Ctracing_enabled_base | Base class for a mbox for the case when message delivery tracing is enabled |
| Cdeliver_op_tracer | |
| ►Npush_event_impl | |
| Cdecrement_on_exception_t | Helper class to rollback message count change in case of an exception |
| ►Nsubscription_storage_common | Common stuff for various subscription storage implementations |
| Csubscr_info_t | An information about one subscription |
| ►Ntransformed_message_impl | |
| Cmessage_maker | A helper function to call appropriate constructor of resulting type in dependence of message or signal |
| Cmessage_maker< true, Result, Msg > | A specialization of signal |
| ►Nvector_based_subscr_storage | A vector-based storage for agent's subscriptions information |
| ►Cstorage_t | A vector-based storage for agent's subscriptions information |
| Cis_same_mbox_msg | |
| ►Ccoop_impl_t | An internal class with real implementation of coop's logic |
| Cderegistration_performer_t | A helper for coop's deregistration procedure |
| Cregistration_performer_t | |
| Ccoop_private_iface_t | A special class for accessing private members of agent_coop |
| ►Ccoop_repository_basis_t | A basic part for various implementations of coop_repository |
| Cfinal_deregistration_result_t | |
| Croot_coop_t | A type of special coop that will be used as the root coop |
| ►Cdelivery_filter_storage_t | Storage for message delivery filters |
| Ckey_t | Type of key for filters map |
| Cvalue_t | Type of value for filters map |
| Cevent_handler_data_t | Information about event_handler and its properties |
| Cfinal_dereg_chain_holder_t | Helper class for holding the current chain of coops for the final deregistration |
| Cfixed_sinks_storage_t | A fixed-capacity storage for message sinks with message limits for one agent |
| Cfull_named_mbox_id_t | Full name for a named mbox |
| Cgrowable_sinks_storage_t | A storage of growable capacity for message limits for one agent |
| Cinstantiator_and_sender | |
| Cinstantiator_and_sender_base | |
| Cinstantiator_and_sender_base< Message, true > | |
| Cinternal_agent_iface_t | A special class for access to private/protected members of agent class |
| Cinternal_env_iface_t | A helper class for accessing the functionality of environment-class which is specific for SObjectizer internals only |
| Clayer_core_t | An utility class for working with layers |
| Climitful_mpsc_mbox_mixin_t | Mixin to be used in implementation of MPSC mbox with message limits |
| Climitless_mpsc_mbox_mixin_t | Mixin to be used in implementation of MPSC mbox without message limits |
| Clocal_mbox_template | A template with implementation of local mbox |
| Cmbox_core_stats_t | Statistics from mbox_core for run-time monitoring |
| ►Cmbox_core_t | A utility class for the work with mboxes |
| Cnamed_mbox_info_t | Named mbox information |
| Cmbox_iface_for_timers_t | Helper class for accessing protected members from mbox interface |
| Cmessage_sink_for_agent_t | A base class for message sinks to be used by agents |
| Cmessage_sink_with_message_limit_t | Implementation of message_sink that handles message limits |
| Cmessage_sink_without_message_limit_t | Implementation of message_sink that has no message limits |
| Cmessage_sinks_with_limits_holder_t | Type that holds message_sink_with_message_limit objects |
| Cmpsc_mbox_template_t | A multi-producer/single-consumer mbox definition |
| Cmsink_less_comparator_t | Helper class to be used as a comparator for msinks |
| Cnamed_local_mbox_t | A class for the named local mbox |
| Csinks_storage_t | An interface for storage of message_sinks for one agent |
| Cso_quick_environment_t | Auxiliary class for the SObjectizer launching |
| Cstate_listener_controller_t | |
| Cstate_switch_guard_t | |
| Cstop_guard_repository_t | Repository of stop_guards |
| Cstorage_without_limits_t | Implementation of message sink storage for a case when message limits are not used |
| Csubscription_storage_t | An interface of subscription storage |
| Ctyped_layer_ref_t | A special wrapper to store a layer with its type |
| ►Nlog_msg_details | Implementation details of error_logging facility |
| Cconductor_t | |
| ►Nlow_level_api | |
| Clambda_as_filter_t | An implementation of delivery filter represented by lambda-function like object |
| Cschedule_timer_params_t | |
| Csingle_timer_params_t | |
| ►Nmchain_auto_close_details | |
| Cauto_closer_t | Main class for auto close operation |
| ►Nmchain_props | Various properties and parameters of message chains |
| ►Ndetails | Implementation details |
| Cactual_receive_select_case_t | Actual implementation of one multi chain select case |
| Cactual_select_notificator_t | Actual implementation of notificator for multi chain select |
| Cactual_send_select_case_t | The actual implementation of select_case for the case of sending a message |
| Cadv_receive_data_t | Container of parameters for receive() function |
| Cbulk_processing_basic_data_t | |
| ►Cextensible_select_cases_holder_t | A holder for serie of select_cases for the case of extensible select |
| Cconst_iterator | Iterator class for accessing select_cases |
| ►Cextensible_select_data_t | A data for extensible-select instance |
| Cactivation_locker_t | Special class for locking extensible-select instance for activation inside select() call |
| Cmodification_locker_t | Special class for locking extensible-select instance for modification |
| Climited_dynamic_demand_queue | Implementation of demands queue for size-limited message chain with dynamically allocated storage |
| Climited_preallocated_demand_queue | Implementation of demands queue for size-limited message chain with preallocated storage |
| Cmchain_bulk_processing_basic_params_t | |
| ►Cprepared_select_data_t | A data for prepared-select instance |
| Cactivation_locker_t | Special class for locking prepared-select instance for activation inside select() call |
| Creceive_actions_performer_t | Helper class with implementation of main actions of advanced receive operation |
| Creceive_select_case_t | A base class for implementations of select_case for the case of receiving messages |
| ►Cselect_actions_performer_t | Helper class for performing select-specific operations |
| Cselect_result_handler_t | |
| ►Cselect_cases_holder_t | A holder for serie of select_cases |
| Cconst_iterator | Iterator class for accessing select_cases |
| Csend_select_case_t | A base class for implementations of select_case for the case of sending messages |
| Cunlimited_demand_queue | Implementation of demands queue for size-unlimited message chain |
| Ccapacity_t | Parameters for defining chain size |
| Cdemand_t | Description of one demand in message chain |
| Cmchain_template | Template-based implementation of message chain |
| Cselect_case_t | Base class for representation of one case in multi chain select |
| Cselect_notificator_t | An interface of select_case notificator |
| ►Nmessage_limit | All stuff related to message limits |
| ►Nimpl | Internal implementation of message limits related stuff |
| Caction_msg_tracer_t | An interface of tracer for message delivery tracing |
| Ccall_pre_abort_action | Helper class for calling pre-abort action |
| Ccall_pre_abort_action_impl | Helper class for calling pre-abort action |
| Ccall_pre_abort_action_impl< false, M, L > | Specialization for the case of signal |
| Cabort_app_indicator_t | Message limit with reaction 'abort the application' |
| Cany_unspecified_message | A special mark to be used for default limits |
| Ccontrol_block_t | A control block for one message limit |
| Cdescription_t | A description of one message limit |
| Cdrop_indicator_t | Message limit with reaction 'drop new message' |
| Clog_then_abort_app_indicator_t | Message limit with reaction 'abort the application' and the possibility to call additional lambda before aborting the app |
| Cmessage_limit_methods_mixin_t | A mixin with message limit definition methods |
| Coverlimit_context_t | Description of context for overlimit action |
| Credirect_indicator_t | Indication that a message must be redirected on overlimit |
| Ctransform_indicator_t | An indicator of transform reaction on message overlimit |
| ►Nmsg_tracing | Public part of message delivery tracing mechanism |
| ►Nimpl | Implementation details of message delivery tracing mechanism |
| Cfilter_from_lambda_t | A type of implementation of filters created from lambda function |
| Cindividual_tracing_envelope_t | Special envelope that just holds an original message/signal |
| Cspecial_enveloping_mbox_t | A special mbox that wraps all incoming messages/signals into a special envelope |
| Cstd_holder_t | Standard implementation of message tracer holder |
| Cstd_stream_tracer_t | A simple implementation of tracer which uses one of standard streams |
| Ccompound_action_description_t | An information about compound description of message-related action |
| Cfilter_t | An interface of filter for trace messages |
| Cholder_t | Interface of holder of message tracer and message trace filter objects |
| Cmessage_instance_info_t | An information about a message instance |
| Cmsg_source_t | An information about message source |
| Ctrace_data_t | An interface of object for accessing trace details |
| Ctracer_t | Interface of tracer object |
| ►Nmsinks | |
| ►Ntransform_then_redirect_impl | |
| Cbasic_transform_then_redirect_sink_t | Base class for all implementation of transform_then_redirect sinks |
| Cmsg_transform_then_redirect_sink_t | Implementation of tranformation sink for a case when a message has to be transformed |
| Csignal_transform_then_redirect_sink_t | Implementation of tranformation sink for a case when a message has to be transformed |
| ►Nmulti_sink_binding_impl | |
| Cactual_binding_handler_t | Class that actually holds multiple sinks bindings |
| Cinsertion_it_with_auto_erase_if_not_committed_t | Helper type for insertion into a std::map with automatic rollback |
| ►Nsink_bindings_details | |
| Clambda_with_detectable_arg_type_t | Helper metafunction to check delivery filter lambda |
| Clambda_with_detectable_arg_type_t< Lambda, typename std::void_t< typename so_5::details::lambda_traits::argument_type_if_lambda< Lambda >::type > > | Specialization for a case when delivery filter lambda has an argument with explicitly specified type |
| ►Nstats | All stuff related to run-time monitoring and statistics |
| ►Nactivity_tracking_stuff | |
| Cdefault_lock_policy | Default locking policy for stats_collector_t |
| Cexternal_lock | Base for the case of externals stats lock |
| Cinternal_lock | Base for the case of internal stats lock |
| Cno_actual_lock | An analog of std::lock_guard but without actual locking actions |
| Cno_lock_at_start_stop_policy | A custom locking policy for stats_collector_t |
| Cnull_lock | A special class for cases where lock is not needed at all |
| Cstats_collector_t | Helper for collecting activity stats |
| Ctraits | Various traits of activity tracking implementation |
| ►Nimpl | Internal implementation of run-time monitoring and statistics related stuff |
| ►Nst_env_stuff | |
| ►Cnext_turn_handler_t | An interface for initiation of next turn in stats distribution |
| Cnext_turn | |
| Cnext_turn_mbox_t | |
| Cds_agent_core_stats_t | A data source for distributing information about agent_core |
| Cds_mbox_core_stats_t | A data source for distributing information about mbox_core |
| Cds_timer_thread_stats_t | A data source for distributing information about timer_thread |
| Cstd_controller_t | A standard implementation of controller for run-time monitoring |
| ►Nmessages | Declarations of messages used by run-time monitoring and statistics |
| Cdistribution_finished | Notification about finish of stats distribution |
| Cdistribution_started | Notification about start of new stats distribution |
| Cquantity | A message with value of some quantity |
| Cwork_thread_activity | Information about one work thread activity |
| Cactivity_stats_t | Statistics of some activity |
| Cauto_registered_source_holder_t | A holder for data-souce that should be automatically registered and deregistered in registry |
| Ccontroller_t | A public interface for control SObjectizer monitoring options |
| Cmanually_registered_source_holder_t | An addition to auto_registered_source_holder for the cases where manual registration of data_source should be used instead of automatic one |
| Cprefix_t | A type for storing prefix of data_source name |
| Crepository_t | An interface of data sources repository |
| Csource_t | An interface of data source |
| Csuffix_t | A type for representing the suffix of data_source name |
| Cwork_thread_activity_stats_t | Stats for a work thread activity |
| ►Nthread_auto_join_details | |
| Cauto_joiner_t | Main class for auto join operation |
| ►Ntimers_details | Timers implementation details |
| Cactual_manager_t | An actual implementation of timer_manager |
| Cactual_thread_t | An actual implementation of timer thread |
| Cactual_timer_t | An actual implementation of timer interface |
| Ctimer_action_for_timer_manager_t | A functor to be used as timer action in implementation of timer thread |
| Ctimer_action_for_timer_thread_t | A functor to be used as timer action in implementation of timer thread |
| ►Nunique_subscribers_mbox_impl | |
| Cactual_mbox_t | Actual implementation of unique_subscribers mbox |
| Cdata_t | A coolection of data required for local mbox implementation |
| Cabstract_message_box_t | Mail box class |
| Cabstract_message_chain_t | An interace of message chain |
| Cabstract_message_sink_t | Interface for message sink |
| Cabstract_sink_owner_t | Interface for holders of message_sink instances |
| Cagent_context_t | A context for agent construction and tuning |
| ►Cagent_identity_t | Helper class for holding agent's identity (name or pointer) |
| Cactual_name_t | Type for case when agent has user-provided name |
| Cpointer_only_t | Type for case when agent has no user-provided name |
| Cto_ostream_visitor_t | |
| Cto_string_visitor_t | |
| Cagent_state_listener_t | Interface of the agent state listener |
| Cagent_t | A base class for agents |
| Cagent_tuning_options_t | A collector for agent tuning options |
| Catomic_refcounted_t | The base class for the object with a reference counting |
| Ccoop_dereg_notificators_container_t | Container for cooperation deregistration notificators |
| Ccoop_dereg_reason_t | It's a kind of strong typedef for coop's deregistration reason |
| Ccoop_handle_t | Type of smart handle for a cooperation |
| Ccoop_listener_t | Interface for the cooperation listener |
| Ccoop_reg_notificators_container_t | Container for cooperation registration notificators |
| ►Ccoop_t | Agent cooperation |
| Cresource_deleter_t | Type of user resource deleter |
| Ccoop_unique_holder_t | A special type that plays role of unique_ptr for coop |
| Cdelivery_filter_t | An interface of delivery filter object |
| Cdisp_binder_t | Interface for dispatcher binders |
| ►Cenvironment_infrastructure_t | An interface for environment_infrastructure entity |
| Ccoop_repository_stats_t | Statistical data for run-time monitoring of coop repository content |
| Cenvironment_params_t | Parameters for the SObjectizer Environment initialization |
| ►Cenvironment_t | SObjectizer Environment |
| Cinternals_t | Internal details of SObjectizer Environment object |
| Cerror_logger_t | An interface for logging error messages |
| Cevent_exception_logger_t | An interface for the exception logging |
| Cevent_queue_hook_t | Interface of event_queue_hook object |
| Cevent_queue_t | An interface of event queue for agent |
| Cexception_t | The base class for all SObjectizer exceptions |
| Cexceptions_enabled_t | Type that indicates that exceptions are enabled |
| Cexecution_demand_t | A description of event execution demand |
| Cexecution_hint_t | A hint for a dispatcher for execution of event for the concrete execution_demand |
| Cextensible_select_t | Special container for holding select parameters and select cases |
| Cimmutable_msg | A special marker for immutable message |
| Cinitial_substate_of | Helper for marking initial substate of composite state |
| Cintrusive_ptr_t | Template class for smart reference wrapper on the atomic_refcounted_t |
| Cis_classical_message | A helper class for checking that message is a classical message derived from message_t class |
| Cis_mutable_message | A helper class for checking that message is a mutable message |
| Cis_mutable_message< mutable_msg< T > > | |
| Cis_signal | A helper class for checking that message is a signal |
| Cis_user_type_message | A helper for detection presence of message of user type |
| Cis_user_type_message< user_type_message_t< M > > | |
| Clayer_t | An interface of the additional SObjectizer Environment layer |
| Cmbox_creation_data_t | An information which is necessary for creation of a new mbox |
| Cmbox_namespace_name_t | A class for the name of mbox_namespace |
| Cmchain_bulk_processing_params_t | Basic parameters for advanced receive from mchain and for multi chain select |
| Cmchain_master_handle_t | Helper class for automatic close of a mchain at the destruction of master handle instance |
| Cmchain_params_t | Parameters for message chain |
| Cmchain_receive_params_t | Parameters for advanced receive from mchain |
| Cmchain_receive_result_t | A result of receive from mchain |
| Cmchain_select_params_t | Parameters for advanced select from multiple mchains |
| Cmchain_select_result_t | A result of select from several mchains |
| Cmchain_send_result_t | A result of attempt of sending messages to a message chain |
| Cmessage_holder_t | A class for holding an instance of a message |
| Cmessage_payload_type | A helper class for detection of payload type of message |
| Cmessage_payload_type< user_type_message_t< T > > | |
| Cmessage_payload_type_impl | Implementation details for message_payload_type |
| Cmessage_payload_type_impl< T, false > | Implementation details for message_payload_type |
| Cmessage_t | A base class for agent messages |
| Cmhood_t | A message wrapped to be used as type of argument for event handlers |
| Cmsg_coop_deregistered | Message about cooperation deregistration completion |
| Cmsg_coop_registered | Message about cooperation registration completion |
| Cmulti_sink_binding_t | Helper class for managing multiple sink bindings |
| Cmutable_msg | A special marker for mutable message |
| Cname_for_agent_methods_mixin_t | Helper type with method to be mixed into agent class |
| Cname_for_agent_t | Type for holding agent name |
| Cnonempty_name_t | A class for the name which cannot be empty |
| Cnull_mutex_t | A class which is like std::mutex but does not do any real actions |
| Coutliving_reference_t | Helper class for indication of long-lived reference via its type |
| Cpartially_constructed_agent_ptr_t | Wrapper around a pointer to partially constructed agent |
| Cpause_backoff_t | An implementation of backoff object using assembly instruction |
| Cprepared_receive_t | Special container for holding receive parameters and receive cases |
| Cprepared_select_t | Special container for holding select parameters and select cases |
| Cqueue_locks_defaults_manager_t | A base class for manager of default locks for event queues |
| Cread_lock_guard_t | Scoped guard for shared locks |
| Crw_spinlock_t | A simple multi-readers/single-writer spinlock (analog of std::shared_mutex) |
| Csignal_t | A base class for agent signals |
| Csimple_sink_owner_t | Implementation of abstract_sink_owner that owns an instance of message sink |
| ►Csingle_sink_binding_t | Helper class for managing single sink bindings |
| Cbinding_info_t | |
| Cspinlock_t | A simple spinlock (analog of std::mutex) |
| ►Cstate_t | Class for the representing agent state |
| Ctime_limit_t | |
| Cstderr_logger_t | A standard implementation of error_logger interface |
| Cstop_guard_t | An interface of stop_guard entity |
| Csubscription_bind_t | A class for creating a subscription to messages from the mbox |
| Csubstate_of | Helper for marking a substate of composite state |
| Cterminate_if_throws_t | Type that indicates that an exception leads to the termination of the whole application |
| Ctimer_id_t | An indentificator for the timer |
| ►Ctimer_manager_t | Timer manager interface |
| Celapsed_timers_collector_t | An interface for collector of elapsed timers |
| Ctimer_t | A base class for timer identificator |
| Ctimer_thread_stats_t | Statistics for run-time monitoring |
| Ctimer_thread_t | Timer thread interface |
| Ctransformed_message_t | A result of message transformation |
| Cuser_type_message_t | Template class for representing object of user type as a message |
| ►Cwrapped_env_t | A wrapped environment |
| Cdetails_t | Implementation details for wrapped_env |
| Cyield_backoff_t | An implementation of backoff object with usage of std::yield |
| ►Ntimertt | Top-level project's namespace |
| ►Ndetails | An internal namespace with implementation details |
| Cbasic_methods_impl_mixin | A implementation of basic methods for timer managers and timer threads |
| Cbuffer_allocated_object | A special storage to be used for holding non-default constructible objects which are created by demand |
| ►Cconsumer_type | A type-container for types of engine-consumers |
| Cmanager | Indicator that an engine will be owned by timer manager |
| Cthread | Indicator that an engine will be owned by timer thread |
| Cengine_common | A common part for all timer engines |
| Cmanager_impl_template | Template-based implementation of timer manager |
| Cmixin_selector | A selector of actual mixin type for timer manager or timer thread |
| Cmixin_selector< thread_safety::safe, consumer_type::manager > | A selector of actual mixin type for thread-safe timer manager |
| Cmixin_selector< thread_safety::safe, consumer_type::thread > | A selector of actual mixin type for timer thread |
| Cmixin_selector< thread_safety::unsafe, consumer_type::manager > | A selector of actual mixin type for not-thread-safe timer manager |
| Cthread_impl_template | Template-based implementation of timer thread |
| ►Cthread_mixin | A mixin which must be used as base class for timer threads |
| Clock_guard | A special wrapper around actual std::unique_lock |
| ►Cthread_safe_manager_mixin | A mixin which must be used as base class for thread-safe timer managers |
| Clock_guard | A special wrapper around actual std::unique_lock |
| ►Cthread_unsafe_manager_mixin | A mixin which must be used as base class for not-thread-safe timer managers |
| Clock_guard | A empty class for an object's lock emulation |
| Ctimer_action_holder | A special storage for holding timer actions |
| Ctimer_action_holder< default_timer_action_type > | |
| ►Ctimer_heap_engine | An engine for timer heap mechanism |
| Ctimer_type | Type of heap timer |
| Ctimer_heap_engine_defaults | Container for static method with default values for timer_heap engine |
| ►Ctimer_list_engine | An engine for timer list mechanism |
| Ctimer_type | Type of list timer |
| Ctimer_list_engine_defaults | Container for static method with default values for timer_list engine |
| ►Ctimer_wheel_engine | A engine for timer wheel mechanism |
| Ctimer_type | Type of wheel timer |
| Cwheel_item | Type of wheel's item |
| Ctimer_wheel_engine_defaults | Container for static method with default values for timer_wheel engine |
| Cdefault_actor_exception_handler | Class of default handler for exceptions thrown from timer actors |
| Cdefault_error_logger | Class of default error logger |
| Cscoped_timer_object_holder | A special wrapper to be used to hold an actual timer object which is not allocated dynamically |
| ►Cthread_safety | Container for thread safety flags |
| Csafe | Indicator for thread-safe implemetation |
| Cunsafe | Indicator for not-thread-safe implementation |
| Cthreading_traits | Container for thread-safety-specific type declarations |
| Cthreading_traits< thread_safety::safe > | Specialization for thread-safe case |
| Cthreading_traits< thread_safety::unsafe > | Specialization for not-thread-safe case |
| Ctimer_heap_manager_template | A timer heap manager template |
| Ctimer_heap_thread_template | A timer heap thread template |
| Ctimer_list_manager_template | A timer list thread template |
| Ctimer_list_thread_template | A timer list thread template |
| Ctimer_object | Base type for timer demands |
| Ctimer_object_holder | An intrusive smart pointer to timer demand |
| Ctimer_quantities | Information about quantities of various timer types |
| Ctimer_wheel_manager_template | A timer wheel manager template |
| Ctimer_wheel_thread_template | A timer wheel thread template |