libcaf  0.16.0
Public Types | Public Member Functions | List of all members
caf::raw_event_based_actor Class Reference

A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages. More...

#include <raw_event_based_actor.hpp>

Inheritance diagram for caf::raw_event_based_actor:
caf::event_based_actor caf::event_based_actor caf::scheduled_actor caf::scheduled_actor caf::resumable caf::resumable

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::event_based_actor
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

 raw_event_based_actor (actor_config &cfg)
 
invoke_message_result consume (mailbox_element &x) override
 
- Public Member Functions inherited from caf::event_based_actor
 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...
 

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 Member Functions inherited from caf::event_based_actor
virtual behavior make_behavior ()
 Returns the initial actor behavior.
 
- 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 raw scheduled actor is a dynamically typed actor that does not handle any system messages.

All handler for system messages as well as the default handler are ignored. This actor type is for testing and system-level actors.


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