caf::event_based_actor Class Reference

A cooperatively scheduled, event-based actor implementation. More...

#include <event_based_actor.hpp>

Inheritance diagram for caf::event_based_actor:

Collaboration diagram for caf::event_based_actor:

Public Types
using	signatures = none_t
	Required by spawn for type deduction.
using	behavior_type = behavior
	Required by spawn for type deduction.
Public Types inherited from caf::scheduled_actor
enum	message_category {   message_category::ordinary,   message_category::internal,   message_category::skipped }
	Categorizes incoming messages. More...
enum	activation_result {   activation_result::success,   activation_result::terminated,   activation_result::skipped,   activation_result::dropped }
	Result of one-shot activations. More...
using	super = local_actor
	Base type.
using	inbound_stream_metrics_map = std::unordered_map< type_id_t, inbound_stream_metrics_t >
	Maps types to metric objects for inbound stream traffic.
using	outbound_stream_metrics_map = std::unordered_map< type_id_t, outbound_stream_metrics_t >
	Maps types to metric objects for outbound stream traffic.
using	stream_manager_map = std::map< stream_slot, stream_manager_ptr >
	Maps slot IDs to stream managers.
using	normal_queue = intrusive::drr_cached_queue< policy::normal_messages >
	Stores asynchronous messages with default priority.
using	urgent_queue = intrusive::drr_cached_queue< policy::urgent_messages >
	Stores asynchronous messages with hifh priority.
using	upstream_queue = intrusive::drr_queue< policy::upstream_messages >
	Stores upstream messages.
using	downstream_queue = intrusive::wdrr_dynamic_multiplexed_queue< policy::downstream_messages >
	Stores downstream messages.
using	mailbox_type = intrusive::fifo_inbox< mailbox_policy >
	A queue optimized for single-reader-many-writers.
using	pending_response = std::pair< const message_id, behavior >
	The message ID of an outstanding response with its callback.
using	pointer = scheduled_actor *
	A pointer to a scheduled actor.
using	default_handler = std::function< skippable_result(pointer, message &)>
	Function object for handling unmatched messages.
using	error_handler = std::function< void(pointer, error &)>
	Function object for handling error messages.
using	down_handler = std::function< void(pointer, down_msg &)>
	Function object for handling down messages.
using	node_down_handler = std::function< void(pointer, node_down_msg &)>
	Function object for handling node down messages.
using	exit_handler = std::function< void(pointer, exit_msg &)>
	Function object for handling exit messages.
Public Types inherited from caf::local_actor
using	clock_type = std::chrono::steady_clock
	Defines a monotonic clock suitable for measuring intervals.
Public Types inherited from caf::resumable
enum	resume_result {   resume_later,   awaiting_message,   done,   shutdown_execution_unit }
	Denotes the state in which a resumable returned from its last call to resume. More...
enum	subtype_t {   unspecified,   scheduled_actor,   io_actor,   function_object }
	Denotes common subtypes of resumable. More...

Public Member Functions
	event_based_actor (actor_config &cfg)
void	initialize () override
Public Member Functions inherited from caf::scheduled_actor
	scheduled_actor (actor_config &cfg)
	scheduled_actor (scheduled_actor &&)=delete
	scheduled_actor (const scheduled_actor &)=delete
scheduled_actor &	operator= (scheduled_actor &&)=delete
scheduled_actor &	operator= (const scheduled_actor &)=delete
void	enqueue (mailbox_element_ptr ptr, execution_unit *eu) override
	Enqueues a new message wrapped in a mailbox_element to the actor. More...
mailbox_element *	peek_at_next_mailbox_element () override
const char *	name () const override
	Returns an implementation-dependent name for logging purposes, which is only valid as long as the actor is running. More...
void	launch (execution_unit *eu, bool lazy, bool hide) override
bool	cleanup (error &&fail_state, execution_unit *host) override
subtype_t	subtype () const override
	Returns a subtype hint for this object. More...
void	intrusive_ptr_add_ref_impl () override
	Add a strong reference count to this object.
void	intrusive_ptr_release_impl () override
	Remove a strong reference count from this object.
resume_result	resume (execution_unit *, size_t) override
	Resume any pending computation until it is either finished or needs to be re-scheduled later. More...
virtual proxy_registry *	proxy_registry_ptr ()
	Returns a factory for proxies created and managed by this actor or nullptr. More...
void	quit (error x=error{})
	Finishes execution of this actor after any currently running message handler is done. More...
mailbox_type &	mailbox () noexcept
	Returns the queue for storing incoming messages.
stream_manager_map &	stream_managers () noexcept
	Returns map for all active streams.
stream_manager_map &	pending_stream_managers () noexcept
	Returns map for all pending streams.
inbound_stream_metrics_t	inbound_stream_metrics (type_id_t type)
outbound_stream_metrics_t	outbound_stream_metrics (type_id_t type)
void	set_default_handler (default_handler fun)
	Sets a custom handler for unexpected messages.
template<class F >
std::enable_if< std::is_convertible< F, std::function< skippable_result(message &)> >::value >::type	set_default_handler (F fun)
	Sets a custom handler for unexpected messages.
void	set_error_handler (error_handler fun)
	Sets a custom handler for error messages.
template<class T >
auto	set_error_handler (T fun) -> decltype(fun(std::declval< error &>()))
	Sets a custom handler for error messages.
void	set_down_handler (down_handler fun)
	Sets a custom handler for down messages.
template<class T >
auto	set_down_handler (T fun) -> decltype(fun(std::declval< down_msg &>()))
	Sets a custom handler for down messages.
void	set_node_down_handler (node_down_handler fun)
	Sets a custom handler for node down messages.
template<class T >
auto	set_node_down_handler (T fun) -> decltype(fun(std::declval< node_down_msg &>()))
	Sets a custom handler for down messages.
void	set_exit_handler (exit_handler fun)
	Sets a custom handler for error messages.
template<class T >
auto	set_exit_handler (T fun) -> decltype(fun(std::declval< exit_msg &>()))
	Sets a custom handler for exit messages.
Public Member Functions inherited from caf::local_actor
	local_actor (actor_config &cfg)
void	on_destroy () override
	Cleans up any remaining state before the destructor is called. More...
void	setup_metrics ()
clock_type::time_point	now () const noexcept
	Returns the current time.
void	request_response_timeout (timespan d, message_id mid)
	Requests a new timeout for mid. More...
template<class T , spawn_options Os = no_spawn_options, class... Ts>
infer_handle_from_class_t< T >	spawn (Ts &&... xs)
template<spawn_options Os = no_spawn_options, class F , class... Ts>
infer_handle_from_fun_t< F >	spawn (F fun, Ts &&... xs)
template<class T , spawn_options Os = no_spawn_options, class Groups , class... Ts>
actor	spawn_in_groups (const Groups &gs, Ts &&... xs)
template<class T , spawn_options Os = no_spawn_options, class... Ts>
actor	spawn_in_groups (std::initializer_list< group > gs, Ts &&... xs)
template<class T , spawn_options Os = no_spawn_options, class... Ts>
actor	spawn_in_group (const group &grp, Ts &&... xs)
template<spawn_options Os = no_spawn_options, class Groups , class F , class... Ts>
actor	spawn_in_groups (const Groups &gs, F fun, Ts &&... xs)
template<spawn_options Os = no_spawn_options, class F , class... Ts>
actor	spawn_in_groups (std::initializer_list< group > gs, F fun, Ts &&... xs)
template<spawn_options Os = no_spawn_options, class F , class... Ts>
actor	spawn_in_group (const group &grp, F fun, Ts &&... xs)
void	send_exit (const actor_addr &whom, error reason)
	Sends an exit message to whom.
void	send_exit (const strong_actor_ptr &whom, error reason)
	Sends an exit message to whom.
template<class ActorHandle >
void	send_exit (const ActorHandle &whom, error reason)
	Sends an exit message to whom.
execution_unit *	context () const noexcept
	Returns the execution unit currently used by this actor.
void	context (execution_unit *x) noexcept
	Sets the execution unit for this actor.
actor_system &	system () const noexcept
	Returns the hosting actor system.
const actor_system_config &	config () const noexcept
	Returns the config of the hosting actor system.
actor_clock &	clock () const noexcept
	Returns the clock of the actor system.
strong_actor_ptr &	current_sender () noexcept
	Returns a pointer to the sender of the current message. More...
message_id	current_message_id () noexcept
	Returns the ID of the current message.
message_id	take_current_message_id () noexcept
	Returns the ID of the current message and marks the ID stored in the current mailbox element as answered. More...
void	drop_current_message_id () noexcept
	Marks the current message ID as answered.
strong_actor_ptr	current_next_stage () noexcept
	Returns a pointer to the next stage from the forwarding path of the current message or nullptr if the path is empty. More...
strong_actor_ptr	take_current_next_stage ()
	Returns a pointer to the next stage from the forwarding path of the current message and removes it from the path. More...
const mailbox_element::forwarding_stack &	current_forwarding_stack () noexcept
	Returns the forwarding stack from the current mailbox element.
mailbox_element::forwarding_stack	take_current_forwarding_stack () noexcept
	Moves the forwarding stack from the current mailbox element.
mailbox_element *	current_mailbox_element () noexcept
	Returns a pointer to the currently processed mailbox element.
void	monitor (const node_id &node)
	Adds a unidirectional monitor to node. More...
template<message_priority P = message_priority::normal, class Handle >
void	monitor (const Handle &whom)
	Adds a unidirectional monitor to whom. More...
void	demonitor (const actor_addr &whom)
	Removes a monitor from whom.
void	demonitor (const strong_actor_ptr &whom)
	Removes a monitor from whom.
void	demonitor (const node_id &node)
	Removes a monitor from node.
template<class Handle >
void	demonitor (const Handle &whom)
	Removes a monitor from whom.
virtual void	on_exit ()
	Can be overridden to perform cleanup code after an actor finished execution. More...
template<class... Ts>
detail::response_promise_t< Ts... >	make_response_promise ()
	Creates a typed_response_promise to respond to a request later on. More...
response_promise	make_response_promise ()
	Creates a response_promise to respond to a request later on.
template<class... Ts>
detail::response_promise_t< std::decay_t< Ts >... >	response (Ts &&... xs)
virtual error	save_state (serializer &sink, unsigned int version)
	Serializes the state of this actor to sink. More...
virtual error	load_state (deserializer &source, unsigned int version)
	Deserializes the state of this actor from source. More...
const error &	fail_state () const noexcept
	Returns the currently defined fail state. More...
Public Member Functions inherited from caf::monitorable_actor
void	attach (attachable_ptr ptr) override
	Attaches ptr to this actor. More...
size_t	detach (const attachable::token &what) override
	Detaches the first attached object that matches what.
void	link_to (const actor_addr &x)
	Links this actor to x.
template<class ActorHandle >
void	link_to (const ActorHandle &x)
	Links this actor to x.
void	unlink_from (const actor_addr &x)
	Unlinks this actor from x.
template<class ActorHandle >
void	unlink_from (const ActorHandle &x)
	Links this actor to x.
Public Member Functions inherited from caf::abstract_actor
void *	operator new (std::size_t, void *ptr)
actor_control_block *	ctrl () const
void	enqueue (strong_actor_ptr sender, message_id mid, message msg, execution_unit *host) override
	Enqueues a new message without forwarding stack to the channel.
template<class F >
void	attach_functor (F f)
	Convenience function that attaches the functor f to this actor. More...
actor_addr	address () const noexcept
	Returns the logical actor address.
virtual std::set< std::string >	message_types () const
	Returns the set of accepted messages types as strings or an empty set if this actor is untyped. More...
actor_id	id () const noexcept
	Returns the ID of this actor.
node_id	node () const noexcept
	Returns the node this actor is living on.
actor_system &	home_system () const noexcept
	Returns the system that created this actor (or proxy).
Public Member Functions inherited from caf::abstract_channel
bool	is_abstract_actor () const
bool	is_abstract_group () const
bool	is_actor_decorator () const

Protected Member Functions
virtual behavior	make_behavior ()
	Returns the initial actor behavior.
Protected Member Functions inherited from caf::monitorable_actor
virtual void	on_cleanup (const error &reason)
	Allows subclasses to add additional cleanup code to the critical section in cleanup. More...
void	bounce (mailbox_element_ptr &what)
	Sends a response message if what is a request.
void	bounce (mailbox_element_ptr &what, const error &err)
	Sends a response message if what is a request.
	monitorable_actor (actor_config &cfg)
	Creates a new actor instance.
void	attach_impl (attachable_ptr &ptr)
size_t	detach_impl (const attachable::token &what, bool stop_on_hit=false, bool dry_run=false)
bool	handle_system_message (mailbox_element &x, execution_unit *ctx, bool trap_exit)
template<class F >
bool	handle_system_message (mailbox_element &x, execution_unit *context, bool trap_exit, F &down_msg_handler)
Protected Member Functions inherited from caf::abstract_actor
	abstract_actor (actor_config &cfg)
	Creates a new actor instance.
Protected Member Functions inherited from caf::abstract_channel
int	flags () const
void	flags (int new_value)

Additional Inherited Members
Static Public Member Functions inherited from caf::scheduled_actor
static void	default_error_handler (pointer ptr, error &x)
static void	default_down_handler (pointer ptr, down_msg &x)
static void	default_node_down_handler (pointer ptr, node_down_msg &x)
static void	default_exit_handler (pointer ptr, exit_msg &x)
Static Public Attributes inherited from caf::scheduled_actor
static constexpr size_t	urgent_queue_index = 0
static constexpr size_t	normal_queue_index = 1
static constexpr size_t	upstream_queue_index = 2
static constexpr size_t	downstream_queue_index = 3
Static Public Attributes inherited from caf::abstract_channel
static constexpr int	is_abstract_actor_flag = 0x01000000
static constexpr int	is_abstract_group_flag = 0x02000000
static constexpr int	is_actor_bind_decorator_flag = 0x04000000
static constexpr int	is_actor_dot_decorator_flag = 0x08000000
static constexpr int	is_actor_decorator_mask = 0x0C000000
static constexpr int	is_hidden_flag = 0x10000000
Protected Attributes inherited from caf::scheduled_actor
mailbox_type	mailbox_
	Stores incoming messages.
detail::behavior_stack	bhvr_stack_
	Stores user-defined callbacks for message handling.
uint64_t	timeout_id_
	Identifies the timeout messages we are currently waiting for.
std::forward_list< pending_response >	awaited_responses_
	Stores callbacks for awaited responses.
detail::unordered_flat_map< message_id, behavior >	multiplexed_responses_
	Stores callbacks for multiplexed responses.
default_handler	default_handler_
	Customization point for setting a default message callback.
error_handler	error_handler_
	Customization point for setting a default error callback.
down_handler	down_handler_
	Customization point for setting a default down_msg callback.
node_down_handler	node_down_handler_
	Customization point for setting a default down_msg callback.
exit_handler	exit_handler_
	Customization point for setting a default exit_msg callback.
stream_manager_map	stream_managers_
	Stores stream managers for established streams.
stream_manager_map	pending_stream_managers_
	Stores stream managers for pending streams, i.e., streams that have not yet received an ACK. More...
timespan	max_batch_delay_
	Stores how long the actor should try to accumulate more items in order to send a full stream batch. More...
size_t	max_batch_delay_ticks_
	Number of ticks per batch delay.
detail::private_thread *	private_thread_
	Pointer to a private thread object associated with a detached actor.
inbound_stream_metrics_map	inbound_stream_metrics_
	Caches metric objects for inbound stream traffic.
outbound_stream_metrics_map	outbound_stream_metrics_
	Caches metric objects for outbound stream traffic.
Protected Attributes inherited from caf::local_actor
execution_unit *	context_
mailbox_element *	current_element_
message_id	last_request_id_
detail::unique_function< behavior(local_actor *)>	initial_behavior_fac_
	Factory function for returning initial behavior in function-based actors.
metrics_t	metrics_
Protected Attributes inherited from caf::monitorable_actor
error	fail_state_
std::condition_variable	cv_
attachable_ptr	attachables_head_
Protected Attributes inherited from caf::abstract_actor
std::mutex	mtx_
Related Functions inherited from caf::scheduled_actor
CAF_CORE_EXPORT skippable_result	reflect (scheduled_actor *, message &)
CAF_CORE_EXPORT skippable_result	reflect_and_quit (scheduled_actor *, message &)
CAF_CORE_EXPORT skippable_result	print_and_drop (scheduled_actor *, message &)
CAF_CORE_EXPORT skippable_result	drop (scheduled_actor *, message &)
Related Functions inherited from caf::local_actor
constexpr keep_behavior_t	keep_behavior = keep_behavior_t{}
	Policy tag that causes event_based_actor::become to keep the current behavior available.
Related Functions inherited from caf::abstract_actor
using	actor_id = uint64_t
	A unique actor ID.

Detailed Description

A cooperatively scheduled, event-based actor implementation.

This is the recommended base class for user-defined actors.

Examples:

dancing_kirby.cpp, dining_philosophers.cpp, and hello_world.cpp.

---

The documentation for this class was generated from the following file:

• libcaf_core/caf/event_based_actor.hpp