Loading...
Searching...
No Matches
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:

caf::abstract_channel | Interface for all message receivers
caf::abstract_actor | Base class for all actor implementations
caf::monitorable_actor | Base class for all actor implementations
caf::actor_pool | An actor poool is a lightweight abstraction for a set of workers
caf::actor_proxy | Represents an actor running on a remote machine, or different hardware, or in a separate process
caf::forwarding_actor_proxy | Implements a simple proxy forwarding all operations to a manager
caf::decorator::sequencer | An actor decorator implementing "dot operator"-like compositions, i.e., f.g(x) = f(g(x))
caf::decorator::splitter | An actor decorator implementing "dot operator"-like compositions, i.e., f.g(x) = f(g(x))
caf::abstract_group | A multicast group
caf::abstract_composable_behavior | Marker type that allows CAF to spawn actors from composable states
caf::actor_clock | A monotonic clock for scheduling timeouts and delayed messages
caf::actor_config | Stores spawn-time flags and groups
caf::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
caf::actor_ostream | Provides support for thread-safe output operations on character streams
caf::actor_profiler | A profiler which provides a set of callbacks for several actor operations in order to collect fine-grained profiling state about the system
caf::actor_registry | A registry is used to associate actors to IDs or atoms (names)
caf::actor_system | Actor environment including scheduler, registry, and optional components such as a middleman
caf::actor_system::module | An (optional) component of the actor system
caf::io::middleman | Manages brokers and network backends
caf::scheduler::abstract_coordinator | A coordinator creates the workers, manages delayed sends and the central printer instance for `aout`
caf::scheduler::coordinator< Policy > * |
caf::scheduler::coordinator< policy::profiled< policy::work_stealing > > |
caf::scheduler::coordinator< Policy > | Policy-based implementation of the abstract coordinator base class
caf::scheduler::profiled_coordinator< profiled< Policy > > |
caf::scheduler::profiled_coordinator< Policy > | A coordinator which keeps fine-grained profiling state about its workers and their jobs
caf::scheduler::test_coordinator | A schedule coordinator for testing purposes
caf::actor_system_config | Configures an actor_system on startup
caf::add_param< T > | Converts T to param<T> unless T is arithmetic, an atom constant, or a stream handshake
caf::allowed_unsafe_message_type< T > | Template specializations can whitelist individual types for unsafe message passing operations
caf::atom_constant< V > | Lifts an atom_value to a compile-time constant
caf::attachable | Callback utility class
caf::attachable::token | Represents a pointer to a value with its subtype as type ID number
caf::behavior | Describes the behavior of an actor, i.e., provides a message handler and an optional timeout
caf::blocking_actor::do_receive_helper | Implementation helper for blocking_actor::do_receive
caf::blocking_actor::mailbox_policy | Configures the FIFO inbox with two nested queues:
caf::blocking_actor::receive_cond | Represents pre- and postconditions for receive loops
caf::blocking_actor::accept_one_cond | Pseudo receive condition modeling a single receive
caf::blocking_actor::receive_for_helper< T > | Implementation helper for blocking_actor::receive_for
caf::blocking_actor::receive_while_helper | Implementation helper for blocking_actor::receive_while
caf::blocking_actor_base | Marker type for blocking actors
caf::blocking_actor | A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
caf::callback< Ts > | Describes a simple callback, usually implemented via lambda expression
caf::callback< Ts... > |
caf::callback_impl< F, Ts... > |
caf::callback_impl< F, Ts > | Utility class for wrapping a function object of type Base
caf::composable_behavior< TypedActor > | Base type for composable actor states
caf::composable_behavior_base< MPI > | Generates an interface class that provides operator()
caf::composable_behavior_base< Clauses > |
caf::composed_type< Xs, Ys, Zs, Rs > | Computes the type for f*g (actor composition)
caf::composed_type< detail::type_list< typed_mpi< In, Out >, Xs... >, Ys, detail::type_list< Zs... >, Rs > |
caf::composed_type< detail::type_list< Xs... >, Ys, Ys, detail::type_list< Rs..., typed_mpi< detail::type_list< In... >, output_tuple< MapsTo... > > > > |
caf::composed_type< detail::type_list< Xs... >, Ys, Ys, Rs > |
caf::config_option | Defines a configuration option for the application
caf::config_option::meta_state | Custom vtable-like struct for delegating to type-specific functions and storing type-specific information shared by several config options
caf::config_option_adder | Adds config options of the same category to a config_option_set
caf::config_option_set | A set of config_option objects that parses CLI arguments into a settings object
caf::config_value | A type for config parameters with similar interface to a variant
caf::config_value_access< std::tuple< Ts... > > | Implements automagic unboxing of std::tuple<Ts...> from a heterogeneous config_value::list
caf::config_value_adaptor< Ts > | Interfaces between a user-defined type and CAF config values by going through intermediate values
caf::config_value_adaptor_access< Trait > | Enables user-defined types in config files and on the CLI by converting them to and from tuples
caf::config_value_adaptor_field< T > | Describes a field of type T of an adaptor
caf::config_value_field< Object > | Describes a field of Object
caf::config_value_field< config_value_field_trait< Get >::object_type > |
caf::config_value_field< T > |
caf::config_value_object_access< Trait > | Enables user-defined types in config files and on the CLI by converting them to and from config_value::dictionary
caf::data_processor< Derived > | A data processor translates an object into a format that can be stored or vice versa
caf::data_processor< deserializer > |
caf::deserializer | Technology-independent deserialization interface
caf::binary_deserializer | Implements the deserializer interface with a binary serialization protocol
caf::stream_deserializer< Streambuf > | Implements the deserializer interface with a binary serialization protocol
caf::data_processor< serializer > |
caf::serializer | Technology-independent serialization interface
caf::serializer_impl< std::vector< char > > |
caf::serializer_impl< Container > | Implements the serializer interface with a binary serialization protocol
caf::stream_serializer< Streambuf > | Implements the serializer interface with a binary serialization protocol
caf::deep_to_string_t | Wrapper to deep_to_string for using the function as an inspector
caf::default_actor_traits< T, ExtendsAbstractActor > | Default implementation of actor_traits for non-actors (SFINAE-friendly)
caf::default_actor_traits< T, std::is_base_of< abstract_actor, T >::value > |
caf::actor_traits< T > | Provides uniform access to properties of actor types
caf::default_actor_traits< T, true > | Default implementation of actor_traits for regular actors
caf::default_downstream_manager< F > | Selects a downstream manager implementation based on the signature of various handlers
caf::default_sum_type_access< T > | Allows specializing the sum_type_access trait for any type that simply wraps a variant and exposes it with a get_data() member function
caf::default_sum_type_access< variant< Ts... > > |
caf::sum_type_access< variant< Ts... > > | Enable holds_alternative, get, get_if, and visit for variant
caf::delegated< Ts > | Helper class to indicate that a request has been forwarded
caf::delegated< stream< DownstreamManager::output_type >, Ts... > |
caf::make_source_result< DownstreamManager, detail::strip_and_convert_t< Ts >... > |
caf::make_stage_result< In, DownstreamManager, detail::strip_and_convert_t< Ts >... > |
caf::make_source_result< DownstreamManager, Ts > | Returns a stream source with the slot ID of its first outbound path
caf::make_stage_result< In, DownstreamManager, Ts > | Returns a stream stage with the slot IDs of its first in- and outbound paths
caf::delegated< void > |
caf::make_sink_result< In > | Returns a stream sink with the slot ID of its first inbound path
caf::detail::abstract_worker_hub | A central place where workers return to after finishing a task
caf::detail::always_false< class > | Utility for fallbacks calling static_assert
caf::detail::callable_trait< Functor > | Defines result_type, arg_types, and fun_type
caf::detail::comparable< Subclass, T > | Barton–Nackman trick implementation
caf::byte_address< ipv4_address > |
caf::byte_address< ipv6_address > |
caf::handle< accept_handle, invalid_accept_handle_t > |
caf::io::accept_handle | Generic handle type for managing incoming connections
caf::handle< accept_handle, invalid_accept_handle_t > |
caf::handle< connection_handle, invalid_connection_handle_t > |
caf::io::connection_handle | Generic handle type for identifying connections
caf::handle< connection_handle, invalid_connection_handle_t > |
caf::handle< datagram_handle, invalid_datagram_handle_t > |
caf::io::datagram_handle | Generic handle type for identifying datagram endpoints
caf::handle< datagram_handle, invalid_datagram_handle_t > |
caf::intrusive_cow_ptr< message_data > |
caf::intrusive_cow_ptr< message_data > |
caf::intrusive_cow_ptr< message_data > |
caf::intrusive_cow_ptr< message_data > |
caf::weak_intrusive_ptr< actor_control_block > |
caf::weak_intrusive_ptr< actor_control_block > |
caf::weak_intrusive_ptr< actor_control_block > |
caf::detail::comparable< actor > |
caf::actor | Identifies an untyped actor
caf::detail::comparable< actor, actor_addr > |
caf::actor | Identifies an untyped actor
caf::detail::comparable< actor, strong_actor_ptr > |
caf::actor | Identifies an untyped actor
caf::detail::comparable< actor_addr > |
caf::actor_addr | Stores the address of typed as well as untyped actors
caf::detail::comparable< actor_addr, abstract_actor * > |
caf::actor_addr | Stores the address of typed as well as untyped actors
caf::detail::comparable< actor_addr, actor_control_block * > |
caf::actor_addr | Stores the address of typed as well as untyped actors
caf::detail::comparable< actor_addr, strong_actor_ptr > |
caf::actor_addr | Stores the address of typed as well as untyped actors
caf::detail::comparable< actor_addr, weak_actor_ptr > |
caf::actor_addr | Stores the address of typed as well as untyped actors
caf::detail::comparable< cow_tuple< Ts... > > |
caf::cow_tuple< Ts > | A copy-on-write tuple implementation
caf::detail::comparable< cow_tuple< Ts... >, std::tuple< Ts... > > |
caf::cow_tuple< Ts > | A copy-on-write tuple implementation
caf::detail::comparable< Derived > |
caf::byte_address< Derived > | Base type for addresses based on a byte representation such as IP or Ethernet addresses
caf::detail::comparable< error > |
caf::error | A serializable type for storing error codes with category and optional, human-readable context information
caf::detail::comparable< group > |
caf::detail::comparable< group, invalid_group_t > |
caf::detail::comparable< intrusive_cow_ptr< detail::dynamic_message_data > > |
caf::intrusive_cow_ptr< detail::dynamic_message_data > |
caf::detail::comparable< intrusive_cow_ptr< detail::dynamic_message_data >, detail::dynamic_message_data * > |
caf::intrusive_cow_ptr< detail::dynamic_message_data > |
caf::detail::comparable< intrusive_cow_ptr< detail::dynamic_message_data >, intrusive_ptr< detail::dynamic_message_data > > |
caf::intrusive_cow_ptr< detail::dynamic_message_data > |
caf::detail::comparable< intrusive_cow_ptr< detail::dynamic_message_data >, std::nullptr_t > |
caf::intrusive_cow_ptr< detail::dynamic_message_data > |
caf::detail::comparable< intrusive_cow_ptr< impl > > |
caf::intrusive_cow_ptr< impl > |
caf::detail::comparable< intrusive_cow_ptr< impl >, impl * > |
caf::intrusive_cow_ptr< impl > |
caf::detail::comparable< intrusive_cow_ptr< impl >, intrusive_ptr< impl > > |
caf::intrusive_cow_ptr< impl > |
caf::detail::comparable< intrusive_cow_ptr< impl >, std::nullptr_t > |
caf::intrusive_cow_ptr< impl > |
caf::detail::comparable< intrusive_cow_ptr< T > > |
caf::intrusive_cow_ptr< T > | An intrusive, reference counting smart pointer implementation with copy-on-write optimization
caf::detail::comparable< intrusive_cow_ptr< T >, intrusive_ptr< T > > |
caf::intrusive_cow_ptr< T > | An intrusive, reference counting smart pointer implementation with copy-on-write optimization
caf::detail::comparable< intrusive_cow_ptr< T >, std::nullptr_t > |
caf::intrusive_cow_ptr< T > | An intrusive, reference counting smart pointer implementation with copy-on-write optimization
caf::detail::comparable< intrusive_cow_ptr< T >, T * > |
caf::intrusive_cow_ptr< T > | An intrusive, reference counting smart pointer implementation with copy-on-write optimization
caf::detail::comparable< ipv4_endpoint > |
caf::ipv4_endpoint | An IP endpoint that contains an ::ipv4_address and a port
caf::detail::comparable< ipv4_subnet > |
caf::detail::comparable< ipv6_address, ipv4_address > |
caf::detail::comparable< ipv6_endpoint > |
caf::ipv6_endpoint | An IP endpoint that contains an ::ipv6_address and a port
caf::detail::comparable< ipv6_endpoint, ipv4_endpoint > |
caf::ipv6_endpoint | An IP endpoint that contains an ::ipv6_address and a port
caf::detail::comparable< ipv6_subnet > |
caf::detail::comparable< message_id > |
caf::message_id | Bundles various flags along with an optional request ID
caf::detail::comparable< none_t > |
caf::none_t | Represents "nothing", e.g., for clearing an optional by assigning none
caf::detail::comparable< stream_slots > |
caf::stream_slots | Maps two stream_slot values into a pair for storing sender and receiver slot information
caf::detail::comparable< string_view > |
caf::string_view | Drop-in replacement for C++17 std::string_view
caf::detail::comparable< Subtype > |
caf::handle< Subtype, InvalidType, InvalidId > | Base class for IO handles such as accept_handle or connection_handle
caf::detail::comparable< Subtype, InvalidType > |
caf::handle< Subtype, InvalidType, InvalidId > | Base class for IO handles such as accept_handle or connection_handle
caf::detail::comparable< typed_actor< Sigs... > > |
caf::typed_actor< Rs... > |
caf::typed_actor< Xs... > |
caf::typed_actor< Sigs... > |
caf::typed_actor< Sigs..., Es... > |

caf::typed_actor< replies_to< publish_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 > >, reacts_to< unpublish_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 > >

caf::typed_actor< Ts... > |
caf::typed_actor< Sigs > | Identifies a statically typed actor
caf::detail::comparable< typed_actor< Sigs... >, actor > |
caf::typed_actor< Rs... > |
caf::typed_actor< Xs... > |
caf::typed_actor< Sigs... > |
caf::typed_actor< Sigs..., Es... > |

caf::typed_actor< replies_to< publish_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 > >, reacts_to< unpublish_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 > >

caf::typed_actor< Ts... > |
caf::typed_actor< Sigs > | Identifies a statically typed actor
caf::detail::comparable< typed_actor< Sigs... >, actor_addr > |
caf::typed_actor< Rs... > |
caf::typed_actor< Xs... > |
caf::typed_actor< Sigs... > |
caf::typed_actor< Sigs..., Es... > |

caf::typed_actor< replies_to< publish_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 > >, reacts_to< unpublish_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 > >

caf::typed_actor< Ts... > |
caf::typed_actor< Sigs > | Identifies a statically typed actor
caf::detail::comparable< typed_actor< Sigs... >, strong_actor_ptr > |
caf::typed_actor< Rs... > |
caf::typed_actor< Xs... > |
caf::typed_actor< Sigs... > |
caf::typed_actor< Sigs..., Es... > |

caf::typed_actor< replies_to< publish_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 > >, reacts_to< unpublish_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 > >

caf::typed_actor< Ts... > |
caf::typed_actor< Sigs > | Identifies a statically typed actor
caf::detail::comparable< unit_t > |
caf::unit_t | Unit is analogous to void, but can be safely returned, stored, etc
caf::detail::comparable< uri > |
caf::uri | A URI according to RFC 3986
caf::detail::comparable< uri, string_view > |
caf::uri | A URI according to RFC 3986
caf::detail::comparable< weak_intrusive_ptr< T > > |
caf::weak_intrusive_ptr< T > | An intrusive, reference counting smart pointer implementation
caf::detail::comparable< weak_intrusive_ptr< T >, const T * > |
caf::weak_intrusive_ptr< T > | An intrusive, reference counting smart pointer implementation
caf::detail::comparable< weak_intrusive_ptr< T >, std::nullptr_t > |
caf::weak_intrusive_ptr< T > | An intrusive, reference counting smart pointer implementation
caf::detail::conjunction< BoolConstants > | Joins all bool constants using operator &&
caf::detail::container_view< F, Container > | Decorates a container of type T to appear as container of type U
caf::detail::deconst_kvp< T > | Utility trait for removing const inside a map<K, V>::value_type
caf::detail::disjunction< BoolConstants > | Joins all bool constants using operator ||
caf::detail::get_callable_trait< T > | Gets a callable trait for T, where T is a function object type, i.e., a function, member function, or a class providing the call operator
caf::detail::has_serialize< T, Ignore > | Checks whether T provides either a free function or a member function for serialization
caf::detail::has_to_string< T > | Checks whether T defines a free function to_string
caf::detail::il_indices< List, Pos, Indices > | Creates indices for List beginning at Pos
caf::detail::ini_category_consumer | Consumes a config category
caf::detail::ini_consumer | Consumes a series of dictionaries forming a application configuration
caf::detail::ini_value_consumer | Consumes a single value from an INI parser
caf::detail::int_list< Is > | A list of integers (wraps a long... template parameter pack)
caf::detail::invoke_result_visitor | Inspects the result of message handlers and triggers type-depended actions such as generating result messages
caf::detail::is_builtin< T > | Checks whether T is considered a builtin type
caf::detail::is_byte_sequence< T > | Checks whether T is a contiguous sequence of byte
caf::detail::is_callable< T > | Checks wheter T is a function or member function
caf::detail::is_callable_with< F, Ts > | Checks wheter F is callable with arguments of types Ts...
caf::detail::is_comparable< T1, T2 > | Checks whether T1 is comparable with T2
caf::detail::is_complete< T > | Checks whether T is a complete type
caf::detail::is_duration< T > | Checks whether T is a std::chrono::duration
caf::detail::is_forward_iterator< T > | Checks wheter T behaves like a forward iterator
caf::detail::is_handler_for< F, T > | Checks whether F is convertible to either std::function<void (T&)> or std::function<void (const T&)>
caf::detail::is_inspectable< Inspector, T > | Checks whether T is inspectable by Inspector
caf::detail::is_iterable< T > | Checks whether T has begin() and end() member functions returning forward iterators
caf::detail::is_list_like< T > | Checks whether T behaves like std::vector, std::list, or std::set
caf::detail::is_manipulator< F > | Checks wheter F takes mutable references
caf::detail::is_map_like< T > | Checks whether T behaves like std::map
caf::detail::is_mutable_ref< T > | Checks wheter T is a non-const reference
caf::detail::is_one_of< T, Ts > | Checks wheter T is in the template parameter pack Ts
caf::detail::is_one_of< T, Ts... > |
caf::detail::is_pair< T > | Utility trait for checking whether T is a std::pair
caf::detail::is_pair< std::pair< First, Second > > | Utility trait for checking whether T is a std::pair
caf::detail::is_primitive< T > | Checks whether T is primitive, i.e., either an arithmetic type or convertible to one of STL's string types
caf::detail::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
caf::detail::is_serializable< T > | Any inspectable type is considered to be serializable
caf::detail::is_serializable_impl< T, false, false > | Checks whether T is builtin or provides a serialize (free or member) function
caf::detail::is_specialization< Tpl, T > | Checks whether Tpl is a specialization of T or not
caf::detail::path_state< Filter, T > | Bundles a filter and a buffer
caf::detail::path_state< unit_t, T > | Compress path_state if Filter is unit
caf::detail::scope_guard< Fun > | A lightweight scope guard implementation
caf::detail::shared_spinlock | A spinlock implementation providing shared and exclusive locking
caf::detail::simple_actor_clock::event | Base class for clock events
caf::detail::simple_actor_clock::cancellation | Cancels a delayed event
caf::detail::simple_actor_clock::multi_timeout_cancellation | Cancels the matching multi timeout
caf::detail::simple_actor_clock::ordinary_timeout_cancellation | Cancels matching ordinary timeouts
caf::detail::simple_actor_clock::request_timeout_cancellation | Cancels a sec::request_timeout error
caf::detail::simple_actor_clock::timeouts_cancellation | Cancels all timeouts for an actor
caf::detail::simple_actor_clock::delayed_event | An event with a timeout attached to it
caf::detail::simple_actor_clock::actor_msg | A delayed ::message to an actor
caf::detail::simple_actor_clock::group_msg | A delayed ::message to a group
caf::detail::simple_actor_clock::multi_timeout | An timeout event for actors that allows multiple active timers for the same type
caf::detail::simple_actor_clock::ordinary_timeout | An ordinary timeout event for actors
caf::detail::simple_actor_clock::request_timeout | A delayed sec::request_timeout error that gets cancelled when the request arrives in time
caf::detail::simple_actor_clock::drop_all | Cancels all timeouts and messages
caf::detail::simple_actor_clock::shutdown | Shuts down the actor clock
caf::detail::single_arg_wrapper< T > | Enables automagical string conversion for CAF_ARG
caf::detail::squashed_int< T > | Squashes integer types into [u]int_[8|16|32|64]_t equivalents
caf::detail::static_error_printer< NumMessageHandlers, Pos, RemainingXs, RemainingYs > | Generates an error using static_assert on an interface mismatch
caf::detail::sync_request_bouncer | Drains a mailbox and sends an error message to each unhandled request
caf::detail::tick_emitter | Converts realtime into a series of ticks, whereas each tick represents a preconfigured timespan
caf::detail::tl_apply< List, VarArgTemplate > | Applies the types of the list to VarArgTemplate
caf::detail::tl_at< type_list< E... >, N > | Gets element at index N of List
caf::detail::tl_back< List > | Gets the last element in List
caf::detail::tl_binary_forall< ListA, ListB, Pred > | Tests whether a binary predicate holds for all corresponding elements of ListA and ListB
caf::detail::tl_concat< Lists > | Concatenates lists
caf::detail::tl_concat_impl< type_list< LhsTs... >, type_list< RhsTs... > > | Concatenates two lists
caf::detail::tl_cons< What, List > | Alias for tl_push_front<List, What>
caf::detail::tl_count< List, Pred > | Counts the number of elements in the list which satisfy a predicate
caf::detail::tl_count_not< List, Pred > | Counts the number of elements in the list which satisfy a predicate
caf::detail::tl_count_type< List, T > | Counts the number of elements in the list which are equal to T
caf::detail::tl_distinct< List > | Creates a new list from List without any duplicate elements
caf::detail::tl_empty< List > | Tests whether a list is empty
caf::detail::tl_equal< ListA, ListB > | Tests whether ListA contains the same elements as ListB and vice versa
caf::detail::tl_exists< List, Pred > | Tests whether a predicate holds for some of the elements of a list
caf::detail::tl_filter< type_list< T... >, Pred > | Create a new list containing all elements which satisfy Pred
caf::detail::tl_filter_not< List, Pred > | Creates a new list containing all elements which do not satisfy Pred
caf::detail::tl_filter_not_type< List, Type > | Creates a new list containing all elements which are not equal to Type
caf::detail::tl_filter_type< List, Type > | Creates a new list containing all elements which are equal to Type
caf::detail::tl_find< List, Pred > | Finds the first element satisfying Pred beginning at index Pos
caf::detail::tl_find_impl< Pred, Ts > | Finds the first element of type What beginning at index Pos
caf::detail::tl_forall< List, Pred > | Tests whether a predicate holds for all elements of a list
caf::detail::tl_from< class > | Construct a type list from types that take a list of variadic template arguments
caf::detail::tl_head< List > | Gets the first element of List
caf::detail::tl_index_of< List, T > | Finds the first element satisfying Pred beginning at index Pos
caf::detail::tl_index_of_impl< Pos, X, Ts > | Finds the first element of type What beginning at index Pos
caf::detail::tl_index_where< List, Pred > | Finds the first element satisfying a given predicate
caf::detail::tl_is_distinct< List > | Tests whether a list is distinct
caf::detail::tl_map< List, Funs > | Creates a new list by applying a "template function" to each element
caf::detail::tl_map_conditional< List, Trait, TRes, Funs > | Creates a new list by applying a Fun to each element which returns TraitResult for Trait
caf::detail::tl_pad_left< List, NewSize, FillType > | Resizes the list to contain NewSize elements and uses FillType to initialize prepended elements with
caf::detail::tl_pad_right< List, NewSize, FillType > | Resizes the list to contain NewSize elements and uses FillType to initialize the new elements with
caf::detail::tl_pop_back< List > | Creates a new list wih all but the last element of List
caf::detail::tl_prepend< type_list< T... >, What > | Creates a new list with What prepended to List
caf::detail::tl_push_back< type_list< ListTs... >, What > | Appends What to given list
caf::detail::tl_push_front< type_list< ListTs... >, What > | Appends What to given list
caf::detail::tl_replace_back< List, Back, Intermediate > | Creates a new list with all but the last element of List and append T to the new list
caf::detail::tl_replace_back< type_list< T1, Ts... >, Back, type_list< Us..., T0 > > |
caf::detail::tl_reverse< List > | Creates a new list wih elements in reversed order
caf::detail::tl_right< List, NewSize, OldSize > | Creates a new list containing the last N elements
caf::detail::tl_size< List > | Gets the number of template parameters of List
caf::detail::tl_slice< List, First, Last > | Creates a new list from range (First, Last]
caf::detail::tl_tail< List > | Gets the tail of List
caf::detail::tl_trim< List, What > | Removes trailing What elements from the end
caf::detail::tl_zip< ListA, ListB, Fun > | Zips two lists of equal size
caf::detail::tl_zip_right< ListA, ListB, Fun, N > | Equal to zip(right(ListA, N), right(ListB, N), Fun)
caf::detail::transfer_const< T, U > | Transfers const from T to U. U remains unchanged if T is not const
caf::detail::type_at< N, Ts > | Gets the Nth element of the template parameter pack Ts
caf::detail::type_list< Ts > | A list of types
caf::detail::unique_function< Signature > | A move-only replacement for std::function
caf::detail::wrapper<> |
caf::detail::unique_function< R(Ts...)>::wrapper | Function object that dispatches application with a virtual member function
caf::detail::unordered_flat_map< Key, T, Allocator > | A map abstraction with an unsorted std::vector providing O(n) lookup
caf::dictionary< V > | Maps strings to values of type V, but unlike std::map<std::string, V> accepts string_view for looking up keys efficiently
caf::down_msg | Sent to all actors monitoring an actor when it is terminated
caf::downstream< T > | Grants access to an output stream buffer
caf::downstream_manager | Manages downstream communication for a stream_manager
caf::downstream_manager_base | The default downstream manager base stores outbound paths in an unordered map
caf::buffered_downstream_manager< T > | Mixin for streams with any number of downstreams
caf::fused_downstream_manager< T, Ts > | A downstream manager that delegates to any number of sub-managers
caf::downstream_manager::path_predicate | Predicate object for paths
caf::downstream_manager::path_visitor | Function object for iterating over all paths
caf::downstream_msg::batch | Transmits stream data
caf::downstream_msg::close | Orderly shuts down a stream after receiving an ACK for the last batch
caf::downstream_msg::forced_close | Propagates a fatal error from sources to sinks
caf::duration | Time duration consisting of a time_unit and a 64 bit unsigned integer
caf::dynamically_typed_actor_base | Marker type for dynamically typed actors
caf::blocking_actor | A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
caf::event_based_actor | A cooperatively scheduled, event-based actor implementation
caf::raw_event_based_actor | A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages
caf::raw_event_based_actor | A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages
caf::io::broker | Describes a dynamically typed broker
caf::io::basp_broker | A broker implementation for the Binary Actor System Protocol (BASP)
caf::execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler
caf::io::network::multiplexer | Low-level backend for IO multiplexing
caf::scheduler::worker< Policy > | Policy-based implementation of the abstract worker base class
caf::scoped_execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler
caf::exit_msg | Sent to all links when an actor is terminated
caf::expected< T > | Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error
caf::expected< void > | The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool
caf::extend< Base, Derived > | Allows convenient definition of types using mixins
caf::function_view< Actor > | A function view for an actor hides any messaging from the caller
caf::fused_downstream_manager< T, Ts >::non_owning_ptr | State held for each slot
caf::group_down_msg | Sent to all members of a group when it goes offline
caf::group_module | Interface for user-defined multicast implementations
caf::has_make_error< T > | Evaluates to true if T is an enum with a free function make_error for converting it to an error
caf::has_sum_type_access< T > | Evaluates to true if T specializes sum_type_access
caf::has_type_id< T > | Evaluates to true if any of these statements holds true:
caf::illegal_message_element | Marker class identifying classes in CAF that are not allowed to be used as message element
caf::inbound_path | State for a path to an upstream actor (source)
caf::inbound_path::stats_t | Stores statistics for measuring complexity of incoming batches
caf::inbound_path::stats_t::calculation_result | Wraps the resulf of stats_t::calculate()
caf::inbound_path::stats_t::measurement | Wraps a time measurement for a single processed batch
caf::inbound_stream_slot< In > | Wraps a stream slot ID for inbound paths with the full type information of the path creation
caf::index_mapping | Marker for representing placeholders at runtime
caf::infer_handle_from_class< T, bool > | Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced
caf::infer_handle_from_fun< F, Trait > | Deduces an actor handle type from a function or function object
caf::infinite_t | Represents an infinite amount of timeout for specifying "invalid" timeouts
caf::intrusive::drr_cached_queue< Policy > | A Deficit Round Robin queue with an internal cache for allowing skipping consumers
caf::intrusive::fifo_inbox< Policy > | A FIFO inbox that combines an efficient thread-safe LIFO inbox with a FIFO queue for re-ordering incoming messages
caf::intrusive::lifo_inbox< Policy > | An intrusive, thread-safe LIFO queue implementation for a single reader with any number of writers
caf::intrusive::new_round_result | Returns the state of a consumer from new_round
caf::intrusive::singly_linked< T > | Intrusive base for singly linked types that allows queues to use T with dummy nodes
caf::intrusive::singly_linked< mailbox_element > |
caf::intrusive::task_queue< Policy > | A singly-linked FIFO queue for storing tasks of varying size
caf::intrusive::drr_queue< nested > |
caf::intrusive::drr_queue< policy::upstream_messages > |
caf::intrusive::drr_queue< Policy > | A Deficit Round Robin queue
caf::intrusive::wdrr_dynamic_multiplexed_queue< Policy > | A work queue that internally multiplexes any number of DRR queues
caf::intrusive::wdrr_fixed_multiplexed_queue< Policy, Q, Qs > | A work queue that internally multiplexes any number of DRR queues
caf::intrusive_ptr< T > | An intrusive, reference counting smart pointer implementation
caf::io::acceptor_closed_msg | Signalizes that a `broker` acceptor has been closed
caf::io::acceptor_passivated_msg | Signalizes that an acceptor has entered passive mode
caf::io::basp::header | The header of a Binary Actor System Protocol (BASP) message
caf::io::basp::instance | Describes a protocol instance managing multiple connections
caf::io::basp::instance::callee | Provides a callback-based interface for certain BASP events
caf::io::basp_broker | A broker implementation for the Binary Actor System Protocol (BASP)
caf::io::basp::message_queue | Enforces strict order of message delivery, i.e., deliver messages in the same order as if they were deserialized by a single thread
caf::io::basp::message_queue::actor_msg | Request for sending a message to an actor at a later time
caf::io::basp::routing_table | Stores routing information for a single broker participating as BASP peer and provides both direct and indirect paths
caf::io::basp::routing_table::route | Describes a routing path to a node
caf::io::broker_servant< Base, Handle, SysMsgType > | Base class for scribe and doorman
caf::io::connection_closed_msg | Signalizes that a `broker` connection has been closed
caf::io::connection_passivated_msg | Signalizes that a connection has entered passive mode
caf::io::data_transferred_msg | Signalizes that a certain amount of bytes has been written
caf::io::datagram_sent_msg | Signalizes that a datagram with a certain size has been sent
caf::io::datagram_servant_closed_msg | Signalizes that a datagram endpoint has entered passive mode
caf::io::datagram_servant_passivated_msg | Signalizes that a datagram sink has entered passive mode
caf::io::network::event_handler | A socket I/O event handler
caf::io::network::acceptor | An acceptor is responsible for accepting incoming connections
caf::io::network::acceptor_impl< caf::policy::tcp > |
caf::io::network::acceptor_impl< ProtocolPolicy > | A concrete acceptor with a technology-dependent policy
caf::io::network::pipe_reader | An event handler for the internal event pipe
caf::io::network::stream | A stream capable of both reading and writing
caf::io::network::stream_impl< caf::policy::tcp > |
caf::io::network::stream_impl< ProtocolPolicy > | A concrete stream with a technology-dependent policy for sending and receiving data from a socket
caf::io::network::event_handler::state | Stores various status flags and user-defined config parameters
caf::io::network::interfaces | Utility class bundling access to network interface names and addresses
caf::io::network::ip_endpoint | A hashable wrapper for a sockaddr storage
caf::io::network::multiplexer::supervisor | Makes sure the multipler does not exit its event loop until the destructor of supervisor has been called
caf::io::network::protocol | Bundles protocol information for network and transport layer communication
caf::io::network::receive_buffer | A container that does not call constructors and destructors for its values
caf::io::new_connection_msg | Signalizes a newly accepted connection from a `broker`
caf::io::new_data_msg | Signalizes newly arrived data for a `broker`
caf::io::new_datagram_msg | Signalizes that a datagram with a certain size has been sent
caf::is_actor_handle< T > | Checks whether T is an actor or a typed_actor<...>
caf::is_error_code_enum< T > | Customization point for enabling conversion from an enum type to an error or error_code
caf::is_typed_actor< T > | Evaluates to true if T is a typed_actor<...>
caf::logger::config | Combines various logging-related flags and parameters into a bitfield
caf::logger::event | Encapsulates a single logging event
caf::logger::field | Represents a single format string field
caf::logger::line_builder | Utility class for building user-defined log messages with CAF_ARG
caf::mailbox_category_corrector<... > | Corrects the message ID for down- and upstream messages to make sure the category for a mailbox_element matches its content
caf::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
caf::ref_counted | Base class for reference counted objects with an atomic reference count
caf::abstract_group | A multicast group
caf::io::network::manager | A manager configures an I/O device and provides callbacks for various I/O operations
caf::io::network::acceptor_manager | An acceptor manager configures an acceptor and provides callbacks for incoming connections as well as for error handling
caf::io::broker_servant< network::acceptor_manager, accept_handle, new_connection_msg > |
caf::io::doorman | Manages incoming connections
caf::io::network::doorman_impl | Default doorman implementation
caf::io::network::datagram_manager | A datagram manager provides callbacks for outgoing datagrams as well as for error handling
caf::io::broker_servant< network::datagram_manager, datagram_handle, new_datagram_msg > |
caf::io::datagram_servant | Manages writing to a datagram sink
caf::io::network::datagram_servant_impl | Default datagram servant implementation
caf::io::network::stream_manager | A stream manager configures an IO stream and provides callbacks for incoming data as well as for error handling
caf::io::broker_servant< network::stream_manager, connection_handle, new_data_msg > |
caf::io::scribe | Manages a stream
caf::io::network::scribe_impl | Default scribe implementation
caf::io::network::multiplexer::runnable | Simple wrapper for runnables
caf::logger | Centrally logs events from all actors in an actor system
caf::stream_manager | Manages a single stream with any number of in- and outbound paths
caf::detail::stream_distribution_tree< Policy > | A stream distribution tree consist of peers forming an acyclic graph
caf::message::cli_arg | Stores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback
caf::message::cli_res | Stores the result of message::extract_opts
caf::message_builder | Provides a convenient interface for createing message objects from a series of values using the member function append
caf::message_handler | A partial function implementation used to process a message
caf::message_view | Represents an object pointing to a type_erased_tuple that is convertible to a message
caf::meta::annotation | Type tag for all meta annotations in CAF
caf::mixin::behavior_changer< Base, Subtype > | A behavior_changer is an actor that supports self->become(...) and self->unbecome()
caf::mixin::requester< Base, Subtype > | A requester is an actor that supports self->request(...)
caf::mixin::sender< Base, Subtype > | A sender is an actor that supports self->send(...)
caf::mixin::subscriber_base | Marker for subscriber
caf::mixin::subscriber< Base, Subtype > | A subscriber is an actor that can subscribe to a group via self->join(...)
caf::named_actor_config | Stores a flow-control configuration
caf::no_error_t | Helper class to construct an expected<T> that represents no error
caf::no_stages_t | Convenience tag type for producing empty forwarding stacks
caf::node_id | A node ID is an opaque value for representing CAF instances in the network
caf::non_blocking_actor_base | Marker type for non-blocking actors
caf::scheduled_actor | A cooperatively scheduled, event-based actor implementation
caf::event_based_actor | A cooperatively scheduled, event-based actor implementation
caf::io::abstract_broker | A broker mediates between actor systems and other components in the network
caf::io::broker | Describes a dynamically typed broker
caf::open_stream_msg | Demands the receiver to open a new stream from the sender to the receiver
caf::optional< T > | A C++17 compatible optional implementation
caf::optional< T & > | Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead
caf::outbound_path | State for a single path to a sink of a downstream_manager
caf::outbound_stream_slot< OutputType, HandshakeArgs > | Wraps a stream slot ID for outbound paths with the full type information of the path creation
caf::param< T > | Represents a message handler parameter of type T and guarantees copy-on-write semantics
caf::param_decay< T > | Convenience struct for remove_param<std::decay<T>>
caf::parser_state< Iterator, Sentinel > | Stores all informations necessary for implementing an FSM-based parser
caf::policy::arg< Ts > | Provides a wrapper to pass policy types as values to functions
caf::policy::categorized | Configures a cached WDRR fixed multiplexed queue for dispatching to four nested queue (one for each message category type)
caf::policy::downstream_messages | Configures a dynamic WDRR queue for holding downstream messages
caf::policy::downstream_messages::nested | Configures a nested DRR queue
caf::policy::normal_messages | Configures a cached DRR queue for holding asynchronous messages with default priority
caf::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
caf::policy::scheduler_policy | This concept class describes a policy for worker and coordinator of the scheduler
caf::policy::work_sharing | Implements scheduling of actors via work sharing (central job queue)
caf::policy::work_stealing | Implements scheduling of actors via work stealing
caf::policy::profiled< policy::work_stealing > |
caf::policy::scheduler_policy::coordinator_data | Policy-specific data fields for the coordinator
caf::policy::scheduler_policy::worker_data | Policy-specific data fields for the worker
caf::policy::tcp | Policy object for wrapping default TCP operations
caf::policy::udp | Policy object for wrapping default UDP operations
caf::policy::unprofiled | This class is intended to be used as a base class for actual polices
caf::policy::work_sharing | Implements scheduling of actors via work sharing (central job queue)
caf::policy::work_stealing | Implements scheduling of actors via work stealing
caf::policy::upstream_messages | Configures a DRR queue for holding upstream messages
caf::policy::urgent_messages | Configures a cached DRR queue for holding asynchronous messages with default priority
caf::proxy_registry | Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages
caf::proxy_registry::backend | Responsible for creating proxy actors
caf::io::basp_broker | A broker implementation for the Binary Actor System Protocol (BASP)
caf::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
caf::remove_param< T > | Unpacks param<T> to T
caf::response_handle< Self, Output, IsBlocking > | This helper class identifies an expected response message and enables request(...).then(...)
caf::response_promise | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e
caf::response_type< Ts, Xs > | Defines:
caf::response_type< detail::type_list< Ts... >, Xs... > |
caf::response_type< Ts, message > |
caf::response_type< Ts, Xs... > |
caf::response_type_unbox< Ts, Xs > | Unboxes Xs and calls response_type
caf::resumable | A cooperatively executed task managed by one or more instances of execution_unit
caf::io::network::multiplexer::runnable | Simple wrapper for runnables
caf::scheduled_actor | A cooperatively scheduled, event-based actor implementation
caf::runtime_settings_map | Thread-safe container for mapping atoms to arbitrary settings
caf::scheduled_actor::mailbox_policy | Configures the FIFO inbox with four nested queues:
caf::scheduled_actor::mailbox_visitor | Consumes messages from the mailbox
caf::scoped_actor | A scoped handle to a blocking actor
caf::select_callback< F, Args > | Utility class for selecting a callback_impl
caf::select_config_value_access< T, Hint > | Delegates to config_value_access for all specialized versions
caf::select_config_value_access< T, select_config_value_hint::is_integral > | Catches all non-specialized integer types
caf::select_config_value_access< T, select_config_value_hint::is_list > | Catches all non-specialized list types
caf::select_config_value_access< T, select_config_value_hint::is_map > | Catches all non-specialized map types
caf::skip_t | Default handler function that leaves messages in the mailbox
caf::span< T > | A C++11/14 drop-in replacement for C++20's std::span without support for static extents
caf::spawn_options | Stores options passed to the spawn function family
caf::stateful_actor< State, Base > | An event-based actor with managed state
caf::stateful_actor< State, base > |
caf::stateful_actor< State, base > * |
caf::stateful_actor< State, broker > |
caf::stateful_actor< State, broker_base > |
caf::stateful_actor< State, broker_base > * |
caf::stateful_actor< State, typename State::actor_base > |
caf::composable_behavior_based_actor< State, Base > | Implementation class for spawning composable states directly as actors
caf::statically_typed_actor_base | Marker type for statically typed actors
caf::typed_event_based_actor< Sigs... > |
caf::io::middleman_actor_impl | Default implementation of the middleman_actor interface
caf::typed_event_based_actor< Sigs... > * |
caf::typed_event_based_actor< Sigs > | A cooperatively scheduled, event-based actor implementation with static type-checking
caf::stream< T > | Empty marker type for streaming handshakes
caf::stream_buffer< CharT, Traits > | The base class for all stream buffer implementations
caf::arraybuf< char > |
caf::containerbuf< std::vector< char > > |
caf::arraybuf< CharT, Traits > | A streambuffer abstraction over a fixed array of bytes
caf::stream_buffer< char, std::char_traits< char > > |
caf::stream_buffer< Container::value_type, std::char_traits< Container::value_type > > |
caf::containerbuf< Container > | A streambuffer abstraction over a contiguous container
caf::stream_finalize_trait< Fun, State, AcceptsTwoArgs > | Dispatches a finalize call to a function taking either one or two arguments
caf::stream_finalize_trait< Fun, State, false > | Specializes the trait for callbacks that only take the state
caf::stream_finalize_trait< Fun, State, true > | Specializes the trait for callbacks that take state and error
caf::stream_sink_driver< Input > | Identifies an unbound sequence of messages
caf::detail::stream_sink_driver_impl< Input, Process, Finalize > | Identifies an unbound sequence of messages
caf::stream_sink_trait< Fun > | Defines required type aliases for stream sinks
caf::stream_sink_trait_base< State, In > | Base type for all sink traits
caf::stream_sink_trait< void(State &, In)> | Specializes the trait for element-wise processing
caf::stream_sink_trait< void(State &, const std::vector< In > &)> | Specializes the trait for batch-wise processing with const references
caf::stream_sink_trait< void(State &, std::vector< In > &)> | Specializes the trait for batch-wise processing
caf::stream_source_driver< DownstreamManager > | Identifies an unbound sequence of messages
caf::detail::stream_source_driver_impl< DownstreamManager, Pull, Done, Finalize > | Identifies an unbound sequence of messages
caf::stream_source_trait< Pull > | Deduces the output type and the state type for a stream source from its pull implementation
caf::stream_stage_driver< Input, DownstreamManager > | Encapsulates user-provided functionality for generating a stream stage
caf::detail::stream_stage_driver_impl< Input, DownstreamManager, Process, Finalize > | Default implementation for a stream_stage_driver that hardwires message as result type and implements process and finalize using user-provided function objects (usually lambdas)
caf::stream_stage_trait< void(State &, downstream< Out > &, In)> | Deduces the input type, output type and the state type for a stream stage from its process implementation
caf::sum_type_access< T > | Specializing this trait allows users to enable holds_alternative, get, get_if, and visit for any user-defined sum type
caf::tag::boxing_type | Allows the testing DSL to recognize that subtypes are boxing content types
caf::downstream_msg | Stream messages that travel downstream, i.e., batches and close messages
caf::upstream_msg | Stream messages that flow upstream, i.e., acks and drop messages
caf::thread_hook | Interface to define thread hooks
caf::timeout_msg | Signalizes a timeout event
caf::type_by_id< V > | Maps the globally unique ID V to a type (inverse to ::type_id)
caf::type_erased_tuple | Represents a tuple of type-erased values
caf::empty_type_erased_tuple | Dummy objects representing empty tuples
caf::message | Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type
caf::type_erased_value | Represents a single type-erased value
caf::detail::type_erased_value_impl< T > | Default implementation for single type-erased values
caf::type_erased_value_factory | Converts values to type-erased values
caf::type_id< T > | Maps the type T to a globally unique ID
caf::type_name< T > | Convenience type that resolves to type_name_by_id<type_id_v<T>>
caf::type_name< void > | Convenience specialization that enables generic code to not treat void manually
caf::type_name_by_id< V > | Maps the globally unique ID V to a type name
caf::type_nr< T, IsIntegral > | Computes the type number for T
caf::typed_actor_view_base | Tag type for typed_actor_view
caf::typed_behavior< Sigs >::unsafe_init | Empty struct tag for constructing from an untyped behavior
caf::typed_response_promise< Ts > | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e
caf::unbox_message_element< T, IsPlaceholderRes > | Unboxes atom constants, i.e., converts atom_constant<V> to V
caf::upstream_msg::ack_batch | Cumulatively acknowledges received batches and signalizes new demand from a sink to its source
caf::upstream_msg::ack_open | Acknowledges a previous open message and finalizes a stream handshake
caf::upstream_msg::drop | Asks the source to discard any remaining credit and close this path after receiving an ACK for the last batch
caf::upstream_msg::forced_drop | Propagates a fatal error from sinks to sources
caf::uri::authority_type | Bundles the authority component of the URI, i.e., userinfo, host, and port
caf::variant< Ts > | A variant represents always a valid value of one of the types Ts...