C++ Actor Framework
0.18
|
A cooperatively scheduled, event-based actor implementation. More...
#include <event_based_actor.hpp>
Public Types | |
using | signatures = none_t |
Required by spawn for type deduction. | |
using | behavior_type = behavior |
Required by spawn for type deduction. | |
using | handle_type = 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 | 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 | batch_op_ptr = intrusive_ptr< flow::op::base< async::batch > > |
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. | |
using | batch_publisher = flow::item_publisher< async::batch > |
using | batch_forwarder_ptr = intrusive_ptr< batch_forwarder > |
![]() | |
using | clock_type = std::chrono::steady_clock |
Defines a monotonic clock suitable for measuring intervals. | |
![]() | |
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... | |
![]() | |
using | steady_time_point = std::chrono::steady_clock::time_point |
A time point of the monotonic clock. | |
Public Member Functions | |
event_based_actor (actor_config &cfg) | |
void | initialize () override |
![]() | |
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 |
bool | 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. | |
void | set_default_handler (default_handler fun) |
Sets a custom handler for unexpected messages. | |
template<class F > | |
std::enable_if_t< std::is_invocable_r_v< skippable_result, F, message & > > | 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 F > | |
std::enable_if_t< std::is_invocable_v< F, error & > > | set_error_handler (F fun) |
Sets a custom handler for error messages. | |
void | set_down_handler (down_handler fun) |
Sets a custom handler for down messages. | |
template<class F > | |
std::enable_if_t< std::is_invocable_v< F, down_msg & > > | set_down_handler (F fun) |
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 F > | |
std::enable_if_t< std::is_invocable_v< F, node_down_msg & > > | set_node_down_handler (F fun) |
Sets a custom handler for down messages. | |
void | set_exit_handler (exit_handler fun) |
Sets a custom handler for error messages. | |
template<class F > | |
std::enable_if_t< std::is_invocable_v< F, exit_msg & > > | set_exit_handler (F fun) |
Sets a custom handler for exit messages. | |
![]() | |
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. | |
disposable | 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. | |
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... | |
![]() | |
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 . | |
![]() | |
actor_control_block * | ctrl () const |
abstract_actor (const abstract_actor &)=delete | |
abstract_actor & | operator= (const abstract_actor &)=delete |
bool | enqueue (strong_actor_ptr sender, message_id mid, message msg, execution_unit *host) override |
Enqueues a new message without forwarding stack to the channel. More... | |
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). | |
![]() | |
bool | is_abstract_actor () const |
bool | is_abstract_group () const |
bool | is_actor_decorator () const |
![]() | |
observable_builder | make_observable () |
Returns a factory object for new observable objects on this coordinator. | |
virtual steady_time_point | steady_time ()=0 |
Returns the current time on the monotonic clock of this coordinator. | |
virtual void | delay (action what)=0 |
Delays execution of an action until all pending actions were executed. More... | |
template<class F > | |
void | delay_fn (F &&what) |
Delays execution of an action until all pending actions were executed. More... | |
virtual disposable | delay_until (steady_time_point abs_time, action what)=0 |
Delays execution of an action with an absolute timeout. More... | |
template<class F > | |
disposable | delay_until_fn (steady_time_point abs_time, F &&what) |
Delays execution of an action until all pending actions were executed. More... | |
disposable | delay_for (timespan rel_time, action what) |
Delays execution of an action with a relative timeout. More... | |
template<class F > | |
void | delay_for_fn (timespan rel_time, F &&what) |
Delays execution of an action with a relative timeout. More... | |
![]() | |
virtual void | ref_execution_context () const noexcept=0 |
Increases the reference count of the execution_context. | |
virtual void | deref_execution_context () const noexcept=0 |
Decreases the reference count of the execution context and destroys the object if necessary. More... | |
virtual void | schedule (action what)=0 |
Schedules what to run on the event loop of the execution context. More... | |
template<class F > | |
void | schedule_fn (F &&what) |
Schedules what to run on the event loop of the execution context. More... | |
virtual void | watch (disposable what)=0 |
Asks the coordinator to keep its event loop running until what becomes disposed since it depends on external events or produces events that are visible to outside observers. More... | |
Protected Member Functions | |
virtual behavior | make_behavior () |
Returns the initial actor behavior. | |
![]() | |
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) |
![]() | |
abstract_actor (actor_config &cfg) | |
![]() | |
int | flags () const |
void | flags (int new_value) |
Additional Inherited Members | |
![]() | |
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 constexpr size_t | urgent_queue_index = 0 |
static constexpr size_t | normal_queue_index = 1 |
![]() | |
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 |
![]() | |
mailbox_type | mailbox_ |
Stores incoming messages. | |
detail::behavior_stack | bhvr_stack_ |
Stores user-defined callbacks for message handling. | |
disposable | pending_timeout_ |
Allows us to cancel our current in-flight timeout. | |
std::forward_list< pending_response > | awaited_responses_ |
Stores callbacks for awaited responses. | |
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. | |
detail::private_thread * | private_thread_ |
Pointer to a private thread object associated with a detached 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_ |
![]() | |
error | fail_state_ |
std::condition_variable | cv_ |
attachable_ptr | attachables_head_ |
![]() | |
std::mutex | mtx_ |
![]() | |
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 &) |
![]() | |
constexpr keep_behavior_t | keep_behavior = keep_behavior_t{} |
Policy tag that causes event_based_actor::become to keep the current behavior available. | |
![]() | |
using | actor_id = uint64_t |
A unique actor ID. | |
![]() | |
using | coordinator_ptr = intrusive_ptr< coordinator > |
![]() | |
using | execution_context_ptr = intrusive_ptr< execution_context > |
void | intrusive_ptr_add_ref (const execution_context *ptr) noexcept |
void | intrusive_ptr_release (const execution_context *ptr) noexcept |
A cooperatively scheduled, event-based actor implementation.
This is the recommended base class for user-defined actors.