▶Ccaf::abstract_channel | Interface for all message receivers |
▶Ccaf::abstract_actor | Base class for all actor implementations |
▶Ccaf::monitorable_actor | Base class for all actor implementations |
Ccaf::actor_pool | An actor poool is a lightweight abstraction for a set of workers |
▶Ccaf::actor_proxy | Represents an actor running on a remote machine, or different hardware, or in a separate process |
Ccaf::forwarding_actor_proxy | Implements a simple proxy forwarding all operations to a manager |
Ccaf::abstract_group | A multicast group |
Ccaf::abstract_composable_behavior | Marker type that allows CAF to spawn actors from composable states |
Ccaf::actor | Identifies an untyped actor |
Ccaf::actor_addr | Stores the address of typed as well as untyped actors |
Ccaf::actor_clock | A monotonic clock for scheduling timeouts and delayed messages |
Ccaf::actor_companion | An co-existing actor forwarding all messages through a user-defined callback to another object, thus serving as gateway to allow any object to interact with other actors |
Ccaf::actor_config | Stores spawn-time flags and groups |
Ccaf::actor_control_block | Actors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it |
Ccaf::actor_ostream | Provides support for thread-safe output operations on character streams |
Ccaf::actor_registry | A registry is used to associate actors to IDs or atoms (names) |
Ccaf::actor_system | Actor environment including scheduler, registry, and optional components such as a middleman |
▶Ccaf::actor_system::module | An (optional) component of the actor system |
Ccaf::io::middleman | Manages brokers and network backends |
▶Ccaf::scheduler::abstract_coordinator | A coordinator creates the workers, manages delayed sends and the central printer instance for aout |
▶Ccaf::scheduler::coordinator< Policy > | Policy-based implementation of the abstract coordinator base class |
Ccaf::scheduler::profiled_coordinator< Policy > | A coordinator which keeps fine-grained profiling state about its workers and their jobs |
Ccaf::scheduler::test_coordinator | A schedule coordinator for testing purposes |
Ccaf::actor_system_config | Configures an actor_system on startup |
Ccaf::allowed_unsafe_message_type< T > | Template specializations can whitelist individual types for unsafe message passing operations |
Ccaf::atom_constant< V > | Lifts an atom_value to a compile-time constant |
Ccaf::attachable | Callback utility class |
Ccaf::attachable::token | Represents a pointer to a value with its subtype as type ID number |
Ccaf::behavior | Describes the behavior of an actor, i.e., provides a message handler and an optional timeout |
Ccaf::blocking_actor | A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing |
Ccaf::blocking_actor::do_receive_helper | Implementation helper for blocking_actor::do_receive |
▶Ccaf::blocking_actor::receive_cond | Represents pre- and postconditions for receive loops |
Ccaf::blocking_actor::accept_one_cond | Pseudo receive condition modeling a single receive |
Ccaf::blocking_actor::receive_for_helper< T > | Implementation helper for blocking_actor::receive_for |
Ccaf::blocking_actor::receive_while_helper | Implementation helper for blocking_actor::receive_while |
Ccaf::callback< Ts > | Describes a simple callback, usually implemented via lambda expression |
Ccaf::composable_behavior< TypedActor > | Base type for composable actor states |
Ccaf::composable_behavior_base< MPI > | Generates an interface class that provides operator() |
Ccaf::composed_type< Xs, Ys, Zs, Rs > | Computes the type for f*g (actor composition) |
Ccaf::config_option | Helper class to generate config readers for different input types |
Ccaf::config_option::type_name_visitor | Returns a human-readable type name for the visited type |
Ccaf::data_processor< Derived > | A data processor translates an object into a format that can be stored or vice versa |
Ccaf::delegated< Ts > | Helper class to indicate that a request has been forwarded |
Ccaf::down_msg | Sent to all actors monitoring an actor when it is terminated |
Ccaf::downstream< T > | Grants access to an output stream buffer |
Ccaf::duration | Time duration consisting of a time_unit and a 64 bit unsigned integer |
Ccaf::error | A serializable type for storing error codes with category and optional, human-readable context information |
▶Ccaf::event_based_actor | A cooperatively scheduled, event-based actor implementation |
Ccaf::raw_event_based_actor | A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages |
Ccaf::raw_event_based_actor | A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages |
▶Ccaf::execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler |
▶Ccaf::io::network::multiplexer | Low-level backend for IO multiplexing |
Ccaf::io::network::asio_multiplexer | A wrapper for the boost::asio multiplexer |
Ccaf::scheduler::worker< Policy > | Policy-based implementation of the abstract worker base class |
Ccaf::scoped_execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler |
Ccaf::exit_msg | Sent to all links when an actor is terminated |
Ccaf::expected< T > | Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error |
Ccaf::expected< void > | The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool |
Ccaf::extend< Base, Derived > | Allows convenient definition of types using mixins |
Ccaf::function_view< Actor > | A function view for an actor hides any messaging from the caller |
Ccaf::group_down_msg | Sent to all members of a group when it goes offline |
Ccaf::group_module | Interface for user-defined multicast implementations |
Ccaf::handle< Subtype, InvalidType, InvalidId > | Base class for IO handles such as accept_handle or connection_handle |
Ccaf::has_make_error< T > | Evaluates to true if T is an enum with a free function make_error for converting it to an error |
Ccaf::illegal_message_element | Marker class identifying classes in CAF that are not allowed to be used as message element |
Ccaf::inbound_path | State for a path to an upstream actor (source) |
Ccaf::index_mapping | Marker for representing placeholders at runtime |
Ccaf::infer_handle_from_class< T, bool > | Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced |
Ccaf::infer_handle_from_fun< F, Trait > | Deduces an actor handle type from a function or function object |
Ccaf::infinite_t | Represents an infinite amount of timeout for specifying "invalid" timeouts |
Ccaf::intrusive_ptr< T > | An intrusive, reference counting smart pointer implementation |
Ccaf::invalid_stream_t | Marker type for constructing invalid stream objects |
Ccaf::io::acceptor_closed_msg | Signalizes that a broker acceptor has been closed |
Ccaf::io::acceptor_passivated_msg | Signalizes that an acceptor has entered passive mode |
▶Ccaf::io::broker_servant< Base, Handle, SysMsgType > | Base class for scribe and doorman |
▶Ccaf::io::datagram_servant | Manages writing to a datagram sink |
Ccaf::io::network::datagram_servant_impl | Default datagram servant implementation |
▶Ccaf::io::doorman | Manages incoming connections |
Ccaf::io::network::doorman_impl | Default doorman implementation |
▶Ccaf::io::scribe | Manages a stream |
Ccaf::io::network::scribe_impl | Default scribe implementation |
Ccaf::io::connection_closed_msg | Signalizes that a broker connection has been closed |
Ccaf::io::connection_passivated_msg | Signalizes that a connection has entered passive mode |
Ccaf::io::data_transferred_msg | Signalizes that a certain amount of bytes has been written |
Ccaf::io::datagram_sent_msg | Signalizes that a datagram with a certain size has been sent |
Ccaf::io::datagram_servant_closed_msg | Signalizes that a datagram endpoint has entered passive mode |
Ccaf::io::datagram_servant_passivated_msg | Signalizes that a datagram sink has entered passive mode |
Ccaf::io::hook | Interface to define hooks into the IO layer |
Ccaf::io::middleman_actor_impl | Default implementation of the middleman_actor interface |
Ccaf::io::network::asio_acceptor< SocketAcceptor > | An acceptor is responsible for accepting incoming connections |
Ccaf::io::network::asio_stream< Socket > | A stream capable of both reading and writing |
Ccaf::io::network::datagram_handler_impl< ProtocolPolicy > | A concrete datagram_handler with a technology-dependent policy |
▶Ccaf::io::network::event_handler | A socket I/O event handler |
▶Ccaf::io::network::acceptor | An acceptor is responsible for accepting incoming connections |
Ccaf::io::network::acceptor_impl< caf::io::network::tcp_policy > | |
Ccaf::io::network::acceptor_impl< ProtocolPolicy > | A concrete acceptor with a technology-dependent policy |
Ccaf::io::network::pipe_reader | An event handler for the internal event pipe |
▶Ccaf::io::network::stream | A stream capable of both reading and writing |
Ccaf::io::network::stream_impl< ProtocolPolicy > | A concrete stream with a technology-dependent policy for sending and receiving data from a socket |
Ccaf::io::network::stream_impl< caf::io::network::tcp_policy > | |
Ccaf::io::network::interfaces | Utility class bundling access to network interface names and addresses |
Ccaf::io::network::ip_endpoint | A hashable wrapper for a sockaddr storage |
Ccaf::io::network::multiplexer::supervisor | Makes sure the multipler does not exit its event loop until the destructor of supervisor has been called |
Ccaf::io::network::protocol | Bundles protocol information for network and transport layer communication |
Ccaf::io::network::receive_buffer | A container that does not call constructors and destructors for its values |
Ccaf::io::network::tcp_policy | Policy object for wrapping default TCP operations |
Ccaf::io::network::udp_policy | Policy object for wrapping default UDP operations |
Ccaf::io::new_connection_msg | Signalizes a newly accepted connection from a broker |
Ccaf::io::new_data_msg | Signalizes newly arrived data for a broker |
Ccaf::io::new_datagram_msg | Signalizes that a datagram with a certain size has been sent |
Ccaf::is_same_ish< T, U > | Compares T to U und evaluates to true_type if either `T == U or if T and U are both integral types of the same size and signedness |
Ccaf::is_typed_actor< T > | Evaluates to true if T is a typed_actor<...> |
Ccaf::logger::arg_wrapper< T > | Enables automagical string conversion for CAF_ARG |
Ccaf::logger::event | Encapsulates a single logging event |
Ccaf::logger::field | Represents a single format string field |
Ccaf::logger::line_builder | Utility class for building user-defined log messages with CAF_ARG |
Ccaf::mailbox_element_vals< Ts > | Encapsulates arbitrary data in a message element |
Ccaf::mailbox_element_view< Ts > | Provides a view for treating arbitrary data as message element |
▶Ccaf::memory_managed | This base enables derived classes to enforce a different allocation strategy than new/delete by providing a virtual protected request_deletion() function and non-public destructor |
▶Ccaf::ref_counted | Base class for reference counted objects with an atomic reference count |
Ccaf::abstract_group | A multicast group |
▶Ccaf::io::network::manager | A manager configures an I/O device and provides callbacks for various I/O operations |
Ccaf::io::network::acceptor_manager | An acceptor manager configures an acceptor and provides callbacks for incoming connections as well as for error handling |
Ccaf::io::network::datagram_manager | A datagram manager provides callbacks for outgoing datagrams as well as for error handling |
Ccaf::io::network::stream_manager | A stream manager configures an IO stream and provides callbacks for incoming data as well as for error handling |
Ccaf::io::network::multiplexer::runnable | Simple wrapper for runnables |
Ccaf::logger | Centrally logs events from all actors in an actor system |
Ccaf::stream_manager | Manages a single stream with any number of down- and upstream actors |
Ccaf::message | Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type |
Ccaf::message::cli_arg | Stores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback |
Ccaf::message::cli_res | Stores the result of message::extract_opts |
Ccaf::message_builder | Provides a convenient interface for createing message objects from a series of values using the member function append |
Ccaf::message_handler | A partial function implementation used to process a message |
Ccaf::message_id | Denotes whether a message is asynchronous or synchronous |
Ccaf::message_view | Represents an object pointing to a type_erased_tuple that is convertible to a message |
Ccaf::meta::annotation | Type tag for all meta annotations in CAF |
Ccaf::mixin::behavior_changer< Base, Subtype > | A behavior_changer is an actor that supports self->become(...) and self->unbecome() |
Ccaf::mixin::requester< Base, Subtype > | A requester is an actor that supports `self->request(...) |
Ccaf::mixin::sender< Base, Subtype > | A sender is an actor that supports self->send(...) |
▶Ccaf::mixin::subscriber_base | Marker for subscriber |
Ccaf::mixin::subscriber< Base, Subtype > | A subscriber is an actor that can subscribe to a group via self->join(...) |
Ccaf::named_actor_config | Stores a flow-control configuration |
Ccaf::no_error_t | Helper class to construct an expected<T> that represents no error |
Ccaf::no_stages_t | Convenience tag type for producing empty forwarding stacks |
Ccaf::node_id | A node ID consists of a host ID and process ID |
Ccaf::none_t | Represents "nothing", e.g., for clearing an optional by assigning none |
Ccaf::optional< T > | A C++17 compatible optional implementation |
Ccaf::optional< T & > | Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead |
Ccaf::outbound_path | State for a single path to a sink on a stream_scatterer |
Ccaf::outbound_path::client_data | Stores information about the initiator of the steam |
Ccaf::param< T > | Represents a message handler parameter of type T and guarantees copy-on-write semantics |
Ccaf::param_decay< T > | Convenience struct for remove_param<std::decay<T>> |
Ccaf::policy::arg< Ts > | Provides a wrapper to pass policy types as values to functions |
Ccaf::policy::profiled< Policy > | An enhancement of CAF's scheduling policy which records fine-grained resource utiliziation for worker threads and actors in the parent coordinator of the workers |
▶Ccaf::policy::scheduler_policy | This concept class describes a policy for worker and coordinator of the scheduler |
Ccaf::policy::work_sharing | Implements scheduling of actors via work sharing (central job queue) |
Ccaf::policy::work_stealing | Implements scheduling of actors via work stealing |
Ccaf::policy::scheduler_policy::coordinator_data | Policy-specific data fields for the coordinator |
Ccaf::policy::scheduler_policy::worker_data | Policy-specific data fields for the worker |
▶Ccaf::policy::unprofiled | This class is intended to be used as a base class for actual polices |
Ccaf::policy::work_sharing | Implements scheduling of actors via work sharing (central job queue) |
Ccaf::policy::work_stealing | Implements scheduling of actors via work stealing |
Ccaf::proxy_registry | Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages |
Ccaf::proxy_registry::backend | Responsible for creating proxy actors |
Ccaf::ratio_to_time_unit_helper< Num, Denom > | Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes |
Ccaf::remove_param< T > | Unpacks param<T> to T |
Ccaf::response_handle< Self, Output, IsBlocking > | This helper class identifies an expected response message and enables request(...).then(...) |
Ccaf::response_promise | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e |
Ccaf::response_type< Ts, Xs > | Defines: |
Ccaf::response_type_unbox< Ts, Xs > | Unboxes Xs and calls response_type |
▶Ccaf::resumable | A cooperatively executed task managed by one or more instances of execution_unit |
Ccaf::io::network::multiplexer::runnable | Simple wrapper for runnables |
▶Ccaf::scheduled_actor | A cooperatively scheduled, event-based actor implementation |
▶Ccaf::io::abstract_broker | A broker mediates between actor systems and other components in the network |
Ccaf::io::broker | Describes a dynamically typed broker |
Ccaf::scoped_actor | A scoped handle to a blocking actor |
Ccaf::select_callback< F, Args > | Utility class for selecting a callback_impl |
Ccaf::skip_t | |
Ccaf::spawn_options | Stores options passed to the spawn function family |
▶Ccaf::stateful_actor< State, Base > | An event-based actor with managed state |
Ccaf::composable_behavior_based_actor< State, Base > | Implementation class for spawning composable states directly as actors |
▶Ccaf::stream< T > | Identifies an unbound sequence of messages |
Ccaf::annotated_stream< T, Ts > | Identifies an unbound sequence of messages annotated with the additional handshake arguments emitted to the next stage |
▶Ccaf::stream_buffer< CharT, Traits > | The base class for all stream buffer implementations |
Ccaf::arraybuf< CharT, Traits > | A streambuffer abstraction over a fixed array of bytes |
Ccaf::stream_edge_impl< Base > | Provides a common scaffold for implementations of the stream_gatherer and stream_scatterer interfaces |
▶Ccaf::stream_gatherer | Type-erased policy for receiving data from sources |
Ccaf::invalid_stream_gatherer | Type-erased policy for receiving data from sources |
▶Ccaf::stream_edge_impl< stream_gatherer > | |
▶Ccaf::stream_gatherer_impl | Type-erased policy for receiving data from sources |
Ccaf::random_gatherer | Pulls data from sources in arbitrary order |
Ccaf::stream_msg | Stream communication messages for handshaking, ACKing, data transmission, etc |
Ccaf::stream_msg::ack_batch | Cumulatively acknowledges received batches and signalizes new demand from a sink to its source |
Ccaf::stream_msg::ack_open | Acknowledges a previous open message and finalizes a stream handshake |
Ccaf::stream_msg::batch | Transmits stream data |
Ccaf::stream_msg::close | Orderly shuts down a stream after receiving an ACK for the last batch |
Ccaf::stream_msg::drop | Informs a source that a sink orderly drops out of a stream |
Ccaf::stream_msg::forced_close | Propagates a fatal error from sources to sinks |
Ccaf::stream_msg::forced_drop | Propagates a fatal error from sinks to sources |
Ccaf::stream_msg::open | Initiates a stream handshake |
Ccaf::stream_result< T > | Terminates a stream by reducing it to a single value |
▶Ccaf::stream_scatterer | Type-erased policy for dispatching data to sinks |
Ccaf::fused_scatterer< T, Ts > | A scatterer that delegates to any number of sub-scatterers |
Ccaf::invalid_stream_scatterer | Type-erased policy for dispatching data to sinks |
Ccaf::terminal_stream_scatterer | Special-purpose scatterer for sinks that terminate a stream |
▶Ccaf::stream_edge_impl< stream_scatterer > | |
▶Ccaf::stream_scatterer_impl | Type-erased policy for dispatching data to sinks |
▶Ccaf::buffered_scatterer< T > | Mixin for streams with any number of downstreams |
▶Ccaf::topic_scatterer< T, Filter, Select > | A topic scatterer allows stream nodes to fork into multiple lanes, where each lane carries only a subset of the data |
Ccaf::broadcast_topic_scatterer< T, Filter, Select > | A topic scatterer that delivers data in broadcast fashion to all sinks |
Ccaf::random_topic_scatterer< T, Filter, Select > | A topic scatterer that delivers data to sinks in random order |
Ccaf::thread_hook | Interface to define thread hooks |
Ccaf::timeout_msg | Signalizes a timeout event |
▶Ccaf::type_erased_tuple | Represents a tuple of type-erased values |
Ccaf::empty_type_erased_tuple | |
Ccaf::type_erased_value | Represents a single type-erased value |
Ccaf::type_erased_value_factory | |
Ccaf::type_nr< T, IsIntegral > | Computes the type number for T |
Ccaf::typed_actor< Sigs > | Identifies a statically typed actor |
Ccaf::typed_behavior< Sigs >::unsafe_init | Empty struct tag for constructing from an untyped behavior |
Ccaf::typed_event_based_actor< Sigs > | A cooperatively scheduled, event-based actor implementation with static type-checking |
Ccaf::typed_response_promise< Ts > | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e |
Ccaf::unbox_message_element< T, IsPlaceholderRes > | Unboxes atom constants, i.e., converts atom_constant<V> to V |
Ccaf::unit_t | Unit is analogous to void , but can be safely returned, stored, etc |
Ccaf::unsafe_actor_handle_init_t | Tag type to select the unsafe constructor of actor handles |
Ccaf::variant< Ts > | A variant represents always a valid value of one of the types Ts... |
Ccaf::variant_compare_helper< T > | |
Ccaf::variant_reader< T > | |
Ccaf::variant_writer< T > | |
Ccaf::weak_intrusive_ptr< T > | An intrusive, reference counting smart pointer implementation |
▶Ccaf::callback< Ts... > | |
Ccaf::callback_impl< F, Ts > | Utility class for wrapping a function object of type Base |
Ccaf::composable_behavior_base< Clauses > | |
Ccaf::composed_type< detail::type_list< typed_mpi< In, Out >, Xs... >, Ys, detail::type_list< Zs... >, Rs > | |
Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, detail::type_list< Rs..., typed_mpi< detail::type_list< In... >, output_stream< MapsTo... > > > > | |
Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, detail::type_list< Rs..., typed_mpi< detail::type_list< In... >, output_tuple< MapsTo... > > > > | |
Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, Rs > | |
▶Ccaf::data_processor< deserializer > | |
▶Ccaf::deserializer | Technology-independent deserialization interface |
Ccaf::stream_deserializer< Streambuf > | Implements the deserializer interface with a binary serialization protocol |
▶Ccaf::data_processor< serializer > | |
▶Ccaf::serializer | Technology-independent serialization interface |
Ccaf::stream_serializer< Streambuf > | Implements the serializer interface with a binary serialization protocol |
Ccaf::io::network::datagram_handler_impl< caf::io::network::udp_policy > | |
▶Ccaf::handle< accept_handle, invalid_accept_handle_t > | |
Ccaf::io::accept_handle | Generic handle type for managing incoming connections |
▶Ccaf::handle< connection_handle, invalid_connection_handle_t > | |
Ccaf::io::connection_handle | Generic handle type for identifying connections |
▶Ccaf::handle< datagram_handle, invalid_datagram_handle_t > | |
Ccaf::io::datagram_handle | Generic handle type for identifying datagram endpoints |
Ccaf::intrusive_ptr< abstract_group > | |
Ccaf::intrusive_ptr< actor_control_block > | |
Ccaf::intrusive_ptr< caf::io::scribe > | |
Ccaf::intrusive_ptr< caf::logger > | |
Ccaf::intrusive_ptr< caf::ref_counted > | |
Ccaf::intrusive_ptr< caf::resumable > | |
Ccaf::intrusive_ptr< data > | |
Ccaf::intrusive_ptr< datagram_manager > | |
Ccaf::intrusive_ptr< datagram_servant > | |
Ccaf::intrusive_ptr< detail::behavior_impl > | |
Ccaf::intrusive_ptr< doorman > | |
Ccaf::intrusive_ptr< manager_type > | |
Ccaf::intrusive_ptr< scribe > | |
Ccaf::intrusive_ptr< stream_manager > | |
Ccaf::mailbox_element_vals< SysMsgType > | |
Ccaf::optional< size_t > | |
Ccaf::response_type< detail::type_list< Ts... >, Xs... > | |
Ccaf::response_type< Ts, message > | |
Ccaf::response_type< Ts, Xs... > | |
▶Ccaf::stateful_actor< basp_broker_state, broker > | |
Ccaf::io::basp_broker | A broker implementation for the Binary Actor System Protocol (BASP) |
▶Ccaf::stream_buffer< Container::value_type, std::char_traits< Container::value_type > > | |
Ccaf::containerbuf< Container > | A streambuffer abstraction over a contiguous container |
Ccaf::typed_actor< replies_to< publish_atom, uint16_t, strong_actor_ptr, std::set< std::string >, std::string, bool > ::with< uint16_t >, replies_to< publish_udp_atom, uint16_t, strong_actor_ptr, std::set< std::string >, std::string, bool > ::with< uint16_t >, replies_to< open_atom, uint16_t, std::string, bool > ::with< uint16_t >, replies_to< connect_atom, std::string, uint16_t > ::with< node_id, strong_actor_ptr, std::set< std::string > >, replies_to< contact_atom, std::string, uint16_t > ::with< node_id, strong_actor_ptr, std::set< std::string > >, reacts_to< unpublish_atom, actor_addr, uint16_t >, reacts_to< unpublish_udp_atom, actor_addr, uint16_t >, reacts_to< close_atom, uint16_t >, replies_to< spawn_atom, node_id, std::string, message, std::set< std::string > > ::with< strong_actor_ptr >, replies_to< get_atom, node_id >::with< node_id, std::string, uint16_t > > | |
Ccaf::typed_actor< Ts... > | |
Ccaf::variant< open, ack_open, batch, ack_batch, close, drop, forced_close, forced_drop > | |
Ccaf::weak_intrusive_ptr< actor_control_block > | |