libcaf  0.16.0
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:
caf::scheduled_actor caf::resumable caf::raw_event_based_actor caf::raw_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 stream_manager_map = std::map< stream_slot, stream_manager_ptr >
 Maps slot IDs to stream managers.
 
using default_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< result< message >(pointer, message_view &)>
 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 exit_handler = std::function< void(pointer, exit_msg &)>
 Function object for handling exit messages.
 
using exception_handler = std::function< error(pointer, std::exception_ptr &)>
 Function object for handling exit messages.
 
- 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)
 
void enqueue (mailbox_element_ptr ptr, execution_unit *eu) override
 
const char * name () const override
 
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.
 
stream_manager_mapstream_managers () noexcept
 Returns map for all active streams.
 
stream_manager_mappending_stream_managers () noexcept
 Returns map for all pending streams.
 
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< result< message >type_erased_tuple &)> >::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_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.
 
void set_exception_handler (exception_handler fun)
 Sets a custom exception handler for this actor. More...
 
template<class F >
std::enable_if< std::is_convertible< F, std::function< error(std::exception_ptr &)> >::value >::type set_exception_handler (F f)
 Sets a custom exception handler for this actor. More...
 
template<class Driver , class... Ts, class Init , class Pull , class Done , class Finalize = unit_t>
make_source_result_t< typename Driver::downstream_manager_type, Ts... > make_source (std::tuple< Ts... > xs, Init init, Pull pull, Done done, Finalize fin={})
 Creates a new stream source by instantiating the default source implementation with Driver. More...
 
template<class... Ts, class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = broadcast_downstream_manager< typename stream_source_trait_t<Pull>::output>>
make_source_result_t< DownstreamManager, Ts... > make_source (std::tuple< Ts... > xs, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
 Creates a new stream source from given arguments. More...
 
template<class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t<!detail::is_actor_handle< Init >::value &&Trait::valid, make_source_result_t< DownstreamManager > > make_source (Init init, Pull pull, Done done, Finalize finalize={}, policy::arg< DownstreamManager > token={})
 
template<class ActorHandle , class... Ts, class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t< detail::is_actor_handle< ActorHandle >::value, make_source_result_t< DownstreamManager > > make_source (const ActorHandle &dest, std::tuple< Ts... > xs, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
 Creates a new stream source and adds dest as first outbound path to it.
 
template<class ActorHandle , class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t< detail::is_actor_handle< ActorHandle >::value &&Trait::valid, make_source_result_t< DownstreamManager > > make_source (const ActorHandle &dest, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager > token={})
 Creates a new stream source and adds dest as first outbound path to it.
 
template<class Driver , class Init , class Pull , class Done , class Finalize = unit_t>
Driver::source_ptr_type make_continuous_source (Init init, Pull pull, Done done, Finalize fin={})
 Creates a new continuous stream source by instantiating the default source implementation with `Driver. More...
 
template<class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = broadcast_downstream_manager< typename stream_source_trait_t<Pull>::output>>
stream_source_ptr< DownstreamManager > make_continuous_source (Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
 Creates a new continuous stream source by instantiating the default source implementation with `Driver. More...
 
template<class Driver , class... Ts>
make_sink_result< typename Driver::input_type > make_sink (const stream< typename Driver::input_type > &src, Ts &&... xs)
 
template<class In , class Init , class Fun , class Finalize = unit_t, class Trait = stream_sink_trait_t<Fun>>
make_sink_result< In > make_sink (const stream< In > &in, Init init, Fun fun, Finalize fin={})
 
template<class Driver , class In , class... Ts, class... Us>
make_stage_result_t< In, typename Driver::downstream_manager_type, Ts... > make_stage (const stream< In > &src, std::tuple< Ts... > xs, Us &&... ys)
 
template<class In , class... Ts, class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t< In, DownstreamManager, Ts... > make_stage (const stream< In > &in, std::tuple< Ts... > xs, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
 
template<class In , class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t< In, DownstreamManager > make_stage (const stream< In > &in, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
 
template<class Driver , class... Ts>
Driver::stage_ptr_type make_continuous_stage (Ts &&... xs)
 Returns a stream manager (implementing a continuous stage) without in- or outbound path. More...
 
template<class Init , class Fun , class Cleanup , class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
stream_stage_ptr< typename Trait::input, DownstreamManager > make_continuous_stage (Init init, Fun fun, Cleanup cleanup, policy::arg< DownstreamManager > token={})
 
void enqueue (strong_actor_ptr sender, message_id mid, message msg, execution_unit *host) override
 
virtual void enqueue (mailbox_element_ptr what, execution_unit *host)=0
 Enqueues a new message wrapped in a mailbox_element to the actor. More...
 

Protected Member Functions

virtual behavior make_behavior ()
 Returns the initial actor behavior.
 

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_exit_handler (pointer ptr, exit_msg &x)
 
static error default_exception_handler (pointer ptr, std::exception_ptr &x)
 
- 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_responseawaited_responses_
 Stores callbacks for awaited responses.
 
detail::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.
 
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...
 
detail::tick_emitter stream_ticks_
 Controls batch and credit timeouts.
 
size_t max_batch_delay_ticks_
 Number of ticks per batch delay.
 
size_t credit_round_ticks_
 Number of ticks of each credit round.
 
detail::private_thread * private_thread_
 Pointer to a private thread object associated with a detached actor.
 
exception_handler exception_handler_
 Customization point for setting a default exception callback.
 

Detailed Description

A cooperatively scheduled, event-based actor implementation.

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


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