caf::abstract_scheduled_actor Class Reference

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

#include <abstract_scheduled_actor.hpp>

Inheritance diagram for caf::abstract_scheduled_actor:

Public Types
using	super = local_actor
Public Types inherited from caf::local_actor
using	clock_type = std::chrono::steady_clock
	Defines a monotonic clock suitable for measuring intervals.

Public Member Functions
virtual void	add_awaited_response_handler (message_id response_id, behavior bhvr, disposable pending_timeout={})=0
	Adds a callback for an awaited response.
virtual void	add_multiplexed_response_handler (message_id response_id, behavior bhvr, disposable pending_timeout={})=0
	Adds a callback for a multiplexed response.
virtual void	call_error_handler (error &what)=0
	Calls the default error handler.
virtual void	run_actions ()=0
	Runs all pending actions.
template<class... Ts>
auto	response_to_flow_cell (message_id response_id, disposable pending_timeout={})
	Lifts a response message into a flow cell in order to allow the actor to turn a response into an observable or single.
Public Member Functions inherited from caf::local_actor
	local_actor (actor_config &cfg)
void	on_cleanup (const error &) override
	Called from cleanup to perform extra cleanup actions for this actor.
void	setup_metrics ()
virtual void	launch (scheduler *sched, bool lazy, bool hide)=0
clock_type::time_point	now () const noexcept
	Returns the current time.
disposable	request_response_timeout (timespan d, message_id mid)
	Requests a new timeout for mid.
template<class... Args>
void	println (std::string_view fmt, Args &&... args)
	Adds a new line to stdout.
template<class... Args>
void	println (term color, std::string_view fmt, Args &&... args)
	Adds a new line to stdout.
template<class T , spawn_options Os = no_spawn_options, class... Ts>
infer_handle_from_class_t< T >	spawn (Ts &&... xs)
template<spawn_options Options = no_spawn_options, class CustomSpawn , class... Args>
CustomSpawn::handle_type	spawn (CustomSpawn, Args &&... args)
template<spawn_options Os = no_spawn_options, class F , class... Ts>
infer_handle_from_fun_t< F >	spawn (F fun, Ts &&... xs)
void	send_exit (const actor_addr &receiver, error reason)
	Sends an exit message to receiver.
void	send_exit (const strong_actor_ptr &receiver, error reason)
	Sends an exit message to receiver.
template<class Handle >
void	send_exit (const Handle &receiver, error reason)
	Sends an exit message to receiver.
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
void	anon_send (const Handle &receiver, T &&arg, Ts &&... args)
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
disposable	scheduled_anon_send (const Handle &receiver, actor_clock::time_point timeout, T &&arg, Ts &&... args)
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
disposable	delayed_anon_send (const Handle &receiver, actor_clock::duration_type timeout, T &&arg, Ts &&... args)
scheduler *	context () const noexcept
	Returns the execution unit currently used by this actor.
void	context (scheduler *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.
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.
void	drop_current_message_id () noexcept
	Marks the current message ID as answered.
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.
void	demonitor (const node_id &node)
	Removes a monitor from node.
virtual void	on_exit ()
	Can be overridden to perform cleanup code after an actor finished execution.
template<class... Ts>
detail::response_promise_t< Ts... >	make_response_promise ()
	Creates a typed_response_promise to respond to a request later on.
response_promise	make_response_promise ()
	Creates a response_promise to respond to a request later on.
const char *	name () const override
	Returns an implementation-dependent name for logging purposes, which is only valid as long as the actor is running.
virtual error	save_state (serializer &sink, unsigned int version)
	Serializes the state of this actor to sink.
virtual error	load_state (deserializer &source, unsigned int version)
	Deserializes the state of this actor from source.
const error &	fail_state () const noexcept
	Returns the currently defined fail state.
Public Member Functions inherited from caf::abstract_actor
	abstract_actor (const abstract_actor &)=delete
abstract_actor &	operator= (const abstract_actor &)=delete
void	attach (attachable_ptr ptr)
	Attaches ptr to this actor.
template<class F >
void	attach_functor (F f)
	Convenience function that attaches the functor f to this actor.
size_t	detach (const attachable::token &what)
	Detaches the first attached object that matches what.
void	link_to (const actor_addr &other)
	Links this actor to other.
template<class ActorHandle >
void	link_to (const ActorHandle &other)
	Links this actor to other.
void	unlink_from (const actor_addr &other)
	Unlinks this actor from addr.
template<class ActorHandle >
void	unlink_from (const ActorHandle &other)
	Links this actor to hdl.
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.
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).
actor_control_block *	ctrl () const
	Returns the control block for this actor.
actor_addr	address () const noexcept
	Returns the logical actor address.
virtual bool	enqueue (mailbox_element_ptr what, scheduler *sched)=0
	Enqueues a new message wrapped in a mailbox_element to the actor.
virtual mailbox_element *	peek_at_next_mailbox_element ()
	Called by the testing DSL to peek at the next element in the mailbox.
bool	cleanup (error &&reason, scheduler *sched)
	Called by the runtime system to perform cleanup actions for this actor.

Friends
template<class... >
class	event_based_response_handle
template<class... >
struct	detail::response_to_flow_cell_helper

Additional Inherited Members
Protected Member Functions inherited from caf::local_actor
void	do_send (abstract_actor *receiver, message_priority priority, message &&msg)
	Sends msg as an asynchronous message to receiver.
disposable	do_scheduled_send (strong_actor_ptr receiver, message_priority priority, actor_clock::time_point timeout, message &&msg)
	Sends msg as an asynchronous message to receiver after the timeout.
void	do_anon_send (abstract_actor *receiver, message_priority priority, message &&msg)
	Sends msg as an asynchronous message to receiver without sender information.
disposable	do_scheduled_anon_send (strong_actor_ptr receiver, message_priority priority, actor_clock::time_point timeout, message &&msg)
	Sends msg as an asynchronous message to receiver after the timeout without sender information.
void	do_monitor (abstract_actor *ptr, message_priority prio)
void	do_demonitor (const strong_actor_ptr &whom)
Protected Member Functions inherited from caf::abstract_actor
virtual void	on_unreachable ()
	Called on actor if the last strong reference to it expired without a prior call to quit(exit_reason::not_exited).
int	flags () const
void	flags (int new_value)
bool	is_terminated () const noexcept
	Checks whether this actor has terminated.
	abstract_actor (actor_config &cfg)
void	attach_impl (attachable_ptr &ptr)
size_t	detach_impl (const attachable::token &what, bool stop_on_hit=false, bool dry_run=false)
void	add_link (abstract_actor *other)
	Causes the actor to establish a link to other.
void	remove_link (abstract_actor *other)
	Causes the actor to remove any established link to other.
virtual bool	add_backlink (abstract_actor *other)
	Adds an entry to other to the link table of this actor.
virtual bool	remove_backlink (abstract_actor *other)
	Removes an entry to other from the link table of this actor.
Protected Attributes inherited from caf::local_actor
scheduler *	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::abstract_actor
std::atomic< int >	flags_
	Holds several state and type flags.
std::mutex	mtx_
	Guards members that may be subject to concurrent access .
std::condition_variable	cv_
	Allows blocking actors to actively wait for incoming messages.
error	fail_state_
	Stores the user-defined exit reason if this actor has finished execution.
attachable_ptr	attachables_head_
	Points to the first attachable in the linked list of attachables (if any).
Related Symbols 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 Symbols inherited from caf::abstract_actor
using	actor_id = uint64_t
	A unique actor ID.

Detailed Description

A cooperatively scheduled, event-based actor implementation.

---

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

• libcaf_core/caf/abstract_scheduled_actor.hpp
• libcaf_core/caf/abstract_scheduled_actor.cpp