Loading...
Searching...
No Matches
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:

## 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 class | message_category { ordinary , internal , skipped }
| Categorizes incoming messages. More...
enum class | activation_result { success , terminated , skipped , 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 | 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 | upstream_queue = intrusive::drr_queue<policy::upstream_messages>
| Stores upstream messages.
using | downstream_queue
| 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
| 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.
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
mailbox_element * | peek_at_next_mailbox_element () 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.
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.
virtual proxy_registry * | proxy_registry_ptr ()
| Returns a factory for proxies created and managed by this actor or nullptr.
void | quit (error x=error{})
| Finishes execution of this actor after any currently running message handler is done.
mailbox_type & | mailbox () noexcept
| Returns the queue for storing incoming messages.
stream_manager_map & | stream_managers () noexcept
| Returns map for all active streams.
stream_manager_map & | pending_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.
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.
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={})
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 >={})
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<!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< 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 >={})
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< 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={})
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={})
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 >={})
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)
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

## 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)
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 constexpr size_t | upstream_queue_index = 2
static constexpr size_t | downstream_queue_index = 3
Protected Member Functions inherited from caf::event_based_actor
virtual behavior | make_behavior ()
| Returns the initial actor behavior.
Related Symbols inherited from caf::scheduled_actor
result< message > | reflect (scheduled_actor *, message_view &)
| Default handler function that sends the message back to the sender.
result< message > | reflect_and_quit (scheduled_actor *, message_view &)
| Default handler function that sends the message back to the sender and then quits.
result< message > | print_and_drop (scheduled_actor *, message_view &)
| Default handler function that prints messages message via aout and drops them afterwards.
result< message > | drop (scheduled_actor *, message_view &)
| Default handler function that simply drops messages.

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

- /build/actor-framework-Z9pIPl/actor-framework-0.17.6/libcaf_core/caf/raw_event_based_actor.hpp