C++ Actor Framework  0.18
Public Types | Public Member Functions | Protected Member Functions | List of all members
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:
Inheritance graph
Collaboration diagram for caf::event_based_actor:
Collaboration graph

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
 
- 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 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 >
 
- 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 Types inherited from caf::flow::coordinator
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
 
- 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_actoroperator= (scheduled_actor &&)=delete
 
scheduled_actoroperator= (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_registryproxy_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_typemailbox () 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.
 
- 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.
 
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_unitcontext () 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_systemsystem () const noexcept
 Returns the hosting actor system.
 
const actor_system_configconfig () const noexcept
 Returns the config of the hosting actor system.
 
actor_clockclock () const noexcept
 Returns the clock of the actor system.
 
strong_actor_ptrcurrent_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 errorfail_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
actor_control_blockctrl () const
 
 abstract_actor (const abstract_actor &)=delete
 
abstract_actoroperator= (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_systemhome_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
 
- Public Member Functions inherited from caf::flow::coordinator
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...
 
- Public Member Functions inherited from caf::async::execution_context
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.
 
- 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)
 
- 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 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.
 
disposable pending_timeout_
 Allows us to cancel our current in-flight timeout.
 
std::forward_list< pending_responseawaited_responses_
 Stores callbacks for awaited responses.
 
unordered_flat_map< message_id, behaviormultiplexed_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.
 
- Protected Attributes inherited from caf::local_actor
execution_unitcontext_
 
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_
 

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: