Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

►Ccaf::abstract_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::local_actor	Base class for actors running on this node, either living in an own thread or cooperatively scheduled
Ccaf::abstract_blocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Ccaf::abstract_blocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Ccaf::abstract_scheduled_actor	A cooperatively scheduled, event-based actor implementation
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::blocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Ccaf::io::typed_broker< Sigs >	A typed broker mediates between actor systems and other components in the network
►Ccaf::abstract_mailbox	The base class for all mailbox implementations
Ccaf::detail::default_mailbox	Our default mailbox implementation
Ccaf::action	A functional interface similar to std::function<void()> with dispose semantics
Ccaf::actor_clock	A monotonic clock for scheduling timeouts and delayed messages
Ccaf::actor_config	Stores spawn-time settings and flags
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_from_state_t< class >	Helper class for automating the creation of an event-based actor with managed state
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 names
Ccaf::actor_system	Actor environment including scheduler, registry, and optional components such as a middleman
Ccaf::actor_system::actor_metric_families_t	Metrics that some actors may collect in addition to the base metrics
Ccaf::actor_system::base_metrics_t	Metrics that the actor system collects by default
Ccaf::actor_system::global_state_guard	Calls a cleanup function in its destructor for cleaning up global state
Ccaf::actor_system_config	Configures an actor_system on startup
►Ccaf::actor_system_module	An (optional) component of the actor system
►Ccaf::actor_system::networking_module	An (optional) component of the actor system with networking capabilities
Ccaf::io::middleman	Manages brokers and network backends
Ccaf::net::middleman	Provides a network backend for running protocol stacks
Ccaf::allowed_unsafe_message_type< T >	Template specializations can whitelist individual types for unsafe message passing operations
Ccaf::anon_mail_t< Priority, Args >	Provides a fluent interface for sending anonymous messages to actors
Ccaf::anon_scheduled_mail_t< Priority, Args >	Provides a fluent interface for sending anonymous messages to actors at a specific point in time
Ccaf::async::batch	A reference-counted, type-erased container for transferring items from producers to consumers
Ccaf::async::blocking_consumer< T >	Blocking interface for emitting items to an asynchronous consumer
Ccaf::async::blocking_producer< T >	Blocking interface for emitting items to an asynchronous consumer
Ccaf::async::bound_future< T >	Provides an interface for accessing the result of an asynchronous computation on an asynchronous execution_context
►Ccaf::async::consumer	Base type for asynchronous consumers of an event source
Ccaf::flow::op::from_resource_sub< Buffer >	Reads from an observable buffer and emits the consumed items
Ccaf::async::consumer_adapter< T >	Integrates an SPSC buffer consumer into an asynchronous event loop
Ccaf::async::consumer_adapter< output_type >
Ccaf::async::consumer_resource< T >	Grants read access to the first consumer that calls open on the resource
Ccaf::async::consumer_resource< accept_event >
Ccaf::async::consumer_resource< input_type >
Ccaf::async::delay_errors_t	Policy type for having consume call on_error only after processing all items from the buffer
►Ccaf::async::execution_context	Represents a single execution context with an internal event-loop to schedule action objects
►Ccaf::flow::coordinator	Coordinates any number of co-located observables and observers
Ccaf::net::socket_manager	Manages the lifetime of a single socket and handles any I/O events on it
Ccaf::net::multiplexer	Multiplexes any number of socket_manager objects with a socket
Ccaf::async::file	Bundles factories for asynchronous sources and sinks that operate on files
Ccaf::async::future< T >	Represents the result of an asynchronous computation
Ccaf::async::prioritize_errors_t	Policy type for having consume call on_error immediately after the producer has aborted even if the buffer still contains items
►Ccaf::async::producer	Base type for asynchronous producers of events
Ccaf::flow::buffer_writer_impl< Buffer >	Writes observed values to a bounded buffer
Ccaf::async::producer_adapter< T >	Integrates an SPSC buffer producer into an asynchronous event loop
Ccaf::async::producer_adapter< input_type >
Ccaf::async::producer_resource< T >	Grants access to a buffer to the first producer that calls open
Ccaf::async::producer_resource< output_type >
Ccaf::async::promise< T >	Provides a facility to store a value or an error that is later acquired asynchronously via a future object
Ccaf::async::promise< caf::net::http::response >
Ccaf::async::publisher< T >	Provides an interface for accessing an asynchronous data flow
Ccaf::async::source_runner< Factory >	Helper class to run an asynchronous source
Ccaf::async::spsc_buffer< T >::flags	Packs various status flags for the buffer into a single struct
Ccaf::async_mail_base_t< Priority, Trait, Args >	Provides a fluent interface for sending asynchronous messages to actors
►Ccaf::async_mail_base_t< Priority, Trait, Args... >
Ccaf::async_mail_t< Priority, Trait, Args >	Provides a fluent interface for sending asynchronous messages to actors
Ccaf::blocking_mail_t< Priority, Trait, Args >	Provides a fluent interface for sending asynchronous messages to actors
Ccaf::event_based_mail_t< Priority, Trait, Args >	Provides a fluent interface for sending asynchronous messages to actors
Ccaf::async_scheduled_mail_t< Priority, Trait, Args >	Provides a fluent interface for sending asynchronous messages to actors at a specific point in time
►Ccaf::async_scheduled_mail_t< Priority, Trait, Args... >
Ccaf::blocking_scheduled_mail_t< Priority, Trait, Args >	Provides a fluent interface for sending asynchronous messages to actors at a specific point in time
Ccaf::event_based_scheduled_mail_t< Priority, Trait, Args >	Provides a fluent interface for sending asynchronous messages to actors at a specific point in time
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::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::blocking_actor_base	Marker type for blocking actors
Ccaf::blocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Ccaf::blocking_delayed_response_handle<... >	Similar to blocking_response_handle, but also holds the disposable for the delayed request message
Ccaf::blocking_response_handle<... >	This helper class identifies an expected response message and enables request(...).then(...)
Ccaf::blocking_response_handle< message >	This helper class identifies an expected response message and enables request(...).then(...)
Ccaf::blocking_response_handle< Results... >
Ccaf::blocking_response_handle_state	Holds state for a blocking response handles
Ccaf::byte_address< Derived >	Base type for addresses based on a byte representation such as IP or Ethernet addresses
Ccaf::byte_address< ipv4_address >
Ccaf::byte_address< ipv6_address >
Ccaf::callback< class >	Describes a simple callback, usually implemented via lambda expression
Ccaf::callback_impl< F, Signature >	Utility class for wrapping a function object of type F
Ccaf::chrono::datetime	Represents a point in time, expressed as a date and time of day
Ccaf::chrono::fixed	Tag type for converting timestamps to strings with a fixed number of fractional digits
Ccaf::chunk	An implicitly shared type for binary data
Ccaf::chunked_string	Represents a chunked string as a linked list of string views
Ccaf::chunked_string_builder	Builds a chunked string by allocating each chunk on a monotonic buffer
Ccaf::chunked_string_builder_output_iterator	An output iterator that appends characters to a linked string chunk builder
Ccaf::config_option	Defines a configuration option for the application
Ccaf::config_option::find_result	Stores the result of a find operation
Ccaf::config_option::meta_state	Custom vtable-like struct for delegating to type-specific functions and storing type-specific information shared by several config options
Ccaf::config_option_adder	Adds config options of the same category to a config_option_set
Ccaf::config_option_set	A set of config_option objects that parses CLI arguments into a settings object
Ccaf::config_value	A type for config parameters with similar interface to a variant
Ccaf::cow_vector< class >	A copy-on-write vector implementation that wraps a std::vector
Ccaf::deep_to_string_t	Wraps deep_to_string into a function object
Ccaf::default_actor_traits< T, ExtendsAbstractActor >	Default implementation of actor_traits for non-actors (SFINAE-friendly)
►Ccaf::default_actor_traits< T, std::is_base_of_v< abstract_actor, T > >
Ccaf::actor_traits< T >	Provides uniform access to properties of actor types
Ccaf::default_actor_traits< T, true >	Default implementation of actor_traits for regular actors
Ccaf::defaults::parameter< T >	Stores the name of a parameter along with the fallback value
Ccaf::delegated<... >	Helper class to indicate that a request has been forwarded
Ccaf::detail::abstract_worker_hub	A central place where workers return to after finishing a task
Ccaf::detail::accepts_opaque_value< Inspector, T >	Checks whether the inspector has an opaque_value overload for T
Ccaf::detail::actor_system_access	Utility to override internal components of an actor system
Ccaf::detail::always_false< class >	Utility for fallbacks calling static_assert
Ccaf::detail::always_true_t	Utility class for predicates that always return true
Ccaf::detail::async_cell< T >	Implementation detail for async::future and async::promise
►Ccaf::detail::atomic_ref_counted	Base class for reference counted objects with an atomic reference count
Ccaf::flow::op::cold< Trait::output_type >
►Ccaf::flow::op::cold< defer_trait< Factory >::output_type >
Ccaf::flow::op::defer< Factory >	Implementation of the defer operator
Ccaf::flow::op::cold< from_steps_output_t< Steps... > >
Ccaf::flow::op::cold< int64_t >
►Ccaf::flow::op::cold< cow_tuple< cow_vector< T >, observable< T > > >
Ccaf::flow::op::prefix_and_tail< T >	Decorates an observable to split its output into a prefix of fixed size plus an observable remainder
►Ccaf::flow::op::cold< zip_with_output_t< F, Ts... > >
Ccaf::flow::op::zip_with< F, Ts >	Combines items from any number of observables using a zip function
Ccaf::flow::op::hot< async::batch >
►Ccaf::flow::op::hot< from_generator_output_t< Generator, Steps... > >
Ccaf::flow::op::from_generator< Generator, Steps >	Converts a Generator to an observable
Ccaf::flow::buffer_writer_impl< Buffer >	Writes observed values to a bounded buffer
►Ccaf::flow::op::cold< T >	Convenience base type for cold observable types
Ccaf::flow::op::empty< T >	An observable that represents an empty range
Ccaf::flow::op::fail< T >	Emits an error to the subscriber immediately after subscribing
Ccaf::flow::op::never< T >	An observable that never calls any callbacks on its subscribers
Ccaf::flow::op::from_resource_sub< Buffer >	Reads from an observable buffer and emits the consumed items
►Ccaf::flow::op::hot< T >	Convenience base type for hot observable types
Ccaf::flow::op::on_backpressure_buffer< T >	An observable that on_backpressure_buffer calls any callbacks on its subscribers
Ccaf::net::socket_manager	Manages the lifetime of a single socket and handles any I/O events on it
►Ccaf::ref_counted	Base class for reference counted objects with an atomic reference count
Ccaf::async::spsc_buffer< T >	A Single Producer Single Consumer buffer
►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::log::event	Captures a single event for a logger
Ccaf::net::dsl::config_base	Base class for configuration objects
Ccaf::net::http::responder::promise_state	Implementation detail for promise
►Ccaf::net::http::route	Represents a single route for HTTP requests at a server
Ccaf::detail::http_route_base< Ts... >
Ccaf::detail::http_catch_all_route_impl< F >	Represents an HTTP route that matches any path
Ccaf::detail::http_route_base< Ts >	Base type for HTTP routes that parse one or more arguments from the requests and then forward them to a user-provided function object
Ccaf::detail::http_simple_route_base	A simple implementation for http::route that does not parse any arguments from the requests and simply calls the user-provided function object
Ccaf::detail::callable_trait< Functor >	Defines result_type, arg_types, and fun_type
Ccaf::detail::comparable< Subclass, T >	Barton–Nackman trick implementation
►Ccaf::detail::comparable< accept_handle >
►Ccaf::handle< accept_handle, invalid_accept_handle_t >
Ccaf::io::accept_handle	Generic handle type for managing incoming connections
►Ccaf::detail::comparable< accept_handle, invalid_accept_handle_t >
Ccaf::handle< accept_handle, invalid_accept_handle_t >
►Ccaf::detail::comparable< actor >
Ccaf::actor	Identifies an untyped actor
►Ccaf::detail::comparable< actor, actor_addr >
Ccaf::actor	Identifies an untyped actor
►Ccaf::detail::comparable< actor, strong_actor_ptr >
Ccaf::actor	Identifies an untyped actor
►Ccaf::detail::comparable< actor_addr >
Ccaf::actor_addr	Stores the address of typed as well as untyped actors
►Ccaf::detail::comparable< actor_addr, abstract_actor * >
Ccaf::actor_addr	Stores the address of typed as well as untyped actors
►Ccaf::detail::comparable< actor_addr, actor_control_block * >
Ccaf::actor_addr	Stores the address of typed as well as untyped actors
►Ccaf::detail::comparable< actor_addr, strong_actor_ptr >
Ccaf::actor_addr	Stores the address of typed as well as untyped actors
►Ccaf::detail::comparable< actor_addr, weak_actor_ptr >
Ccaf::actor_addr	Stores the address of typed as well as untyped actors
►Ccaf::detail::comparable< basic_cow_string< CharT > >
Ccaf::basic_cow_string< char >
Ccaf::basic_cow_string< class >	A copy-on-write string implementation that wraps a std::basic_string
►Ccaf::detail::comparable< basic_cow_string< CharT >, const CharT * >
Ccaf::basic_cow_string< char >
Ccaf::basic_cow_string< class >	A copy-on-write string implementation that wraps a std::basic_string
►Ccaf::detail::comparable< basic_cow_string< CharT >, std::basic_string< CharT > >
Ccaf::basic_cow_string< char >
Ccaf::basic_cow_string< class >	A copy-on-write string implementation that wraps a std::basic_string
►Ccaf::detail::comparable< connection_handle >
►Ccaf::handle< connection_handle, invalid_connection_handle_t >
Ccaf::io::connection_handle	Generic handle type for identifying connections
►Ccaf::detail::comparable< connection_handle, invalid_connection_handle_t >
Ccaf::handle< connection_handle, invalid_connection_handle_t >
►Ccaf::detail::comparable< cow_tuple< Ts... > >
Ccaf::cow_tuple< async::consumer_resource< frame >, async::producer_resource< frame >, Ts... >
Ccaf::cow_tuple< async::consumer_resource< net::web_socket::frame >, async::producer_resource< net::web_socket::frame >, Ts... >
Ccaf::cow_tuple<... >	A copy-on-write tuple implementation
►Ccaf::detail::comparable< cow_tuple< Ts... >, std::tuple< Ts... > >
Ccaf::cow_tuple< async::consumer_resource< frame >, async::producer_resource< frame >, Ts... >
Ccaf::cow_tuple< async::consumer_resource< net::web_socket::frame >, async::producer_resource< net::web_socket::frame >, Ts... >
Ccaf::cow_tuple<... >	A copy-on-write tuple implementation
►Ccaf::detail::comparable< datagram_handle >
►Ccaf::handle< datagram_handle, invalid_datagram_handle_t >
Ccaf::io::datagram_handle	Generic handle type for identifying datagram endpoints
►Ccaf::detail::comparable< datagram_handle, invalid_datagram_handle_t >
Ccaf::handle< datagram_handle, invalid_datagram_handle_t >
►Ccaf::detail::comparable< disposable >
Ccaf::disposable	Represents a disposable resource
►Ccaf::detail::comparable< error >
Ccaf::error	A serializable type for storing error codes with category and optional, human-readable context information
►Ccaf::detail::comparable< intrusive_cow_ptr< detail::message_data > >
Ccaf::intrusive_cow_ptr< detail::message_data >
►Ccaf::detail::comparable< intrusive_cow_ptr< detail::message_data >, detail::message_data * >
Ccaf::intrusive_cow_ptr< detail::message_data >
►Ccaf::detail::comparable< intrusive_cow_ptr< detail::message_data >, intrusive_ptr< detail::message_data > >
Ccaf::intrusive_cow_ptr< detail::message_data >
►Ccaf::detail::comparable< intrusive_cow_ptr< detail::message_data >, std::nullptr_t >
Ccaf::intrusive_cow_ptr< detail::message_data >
►Ccaf::detail::comparable< intrusive_cow_ptr< impl > >
Ccaf::intrusive_cow_ptr< impl >
►Ccaf::detail::comparable< intrusive_cow_ptr< impl >, impl * >
Ccaf::intrusive_cow_ptr< impl >
►Ccaf::detail::comparable< intrusive_cow_ptr< impl >, intrusive_ptr< impl > >
Ccaf::intrusive_cow_ptr< impl >
►Ccaf::detail::comparable< intrusive_cow_ptr< impl >, std::nullptr_t >
Ccaf::intrusive_cow_ptr< impl >
►Ccaf::detail::comparable< intrusive_cow_ptr< State > >
Ccaf::intrusive_cow_ptr< State >
►Ccaf::detail::comparable< intrusive_cow_ptr< State >, intrusive_ptr< State > >
Ccaf::intrusive_cow_ptr< State >
►Ccaf::detail::comparable< intrusive_cow_ptr< State >, State * >
Ccaf::intrusive_cow_ptr< State >
►Ccaf::detail::comparable< intrusive_cow_ptr< State >, std::nullptr_t >
Ccaf::intrusive_cow_ptr< State >
►Ccaf::detail::comparable< intrusive_cow_ptr< T > >
Ccaf::intrusive_cow_ptr< T >	An intrusive, reference counting smart pointer implementation with copy-on-write optimization
►Ccaf::detail::comparable< intrusive_cow_ptr< T >, intrusive_ptr< T > >
Ccaf::intrusive_cow_ptr< T >	An intrusive, reference counting smart pointer implementation with copy-on-write optimization
►Ccaf::detail::comparable< intrusive_cow_ptr< T >, std::nullptr_t >
Ccaf::intrusive_cow_ptr< T >	An intrusive, reference counting smart pointer implementation with copy-on-write optimization
►Ccaf::detail::comparable< intrusive_cow_ptr< T >, T * >
Ccaf::intrusive_cow_ptr< T >	An intrusive, reference counting smart pointer implementation with copy-on-write optimization
Ccaf::detail::comparable< ipv4_address >
►Ccaf::detail::comparable< ipv4_endpoint >
Ccaf::ipv4_endpoint	An IP endpoint that contains an ipv4_address and a port
Ccaf::detail::comparable< ipv4_subnet >
Ccaf::detail::comparable< ipv6_address >
Ccaf::detail::comparable< ipv6_address, ipv4_address >
►Ccaf::detail::comparable< ipv6_endpoint >
Ccaf::ipv6_endpoint	An IP endpoint that contains an ipv6_address and a port
►Ccaf::detail::comparable< ipv6_endpoint, ipv4_endpoint >
Ccaf::ipv6_endpoint	An IP endpoint that contains an ipv6_address and a port
Ccaf::detail::comparable< ipv6_subnet >
►Ccaf::detail::comparable< label >
Ccaf::telemetry::label	An (immutable) key-value pair for adding extra dimensions to metrics
Ccaf::detail::comparable< label_view >
Ccaf::detail::comparable< label_view, label >
►Ccaf::detail::comparable< message_id >
Ccaf::message_id	Bundles various flags along with an optional request ID
►Ccaf::detail::comparable< none_t >
Ccaf::none_t	Represents "nothing", e.g., for clearing an optional by assigning none
►Ccaf::detail::comparable< observer< caf::async::batch > >
Ccaf::flow::observer< caf::async::batch >
►Ccaf::detail::comparable< observer< caf::cow_tuple > >
Ccaf::flow::observer< caf::cow_tuple >
►Ccaf::detail::comparable< observer< int64_t > >
Ccaf::flow::observer< int64_t >
►Ccaf::detail::comparable< observer< output_type > >
Ccaf::flow::observer< output_type >
►Ccaf::detail::comparable< observer< T > >
Ccaf::flow::observer< T >	Handle to a consumer of items
►Ccaf::detail::comparable< observer< value_type > >
Ccaf::flow::observer< value_type >
►Ccaf::detail::comparable< socket >
►Ccaf::net::socket	An internal endpoint for sending or receiving data
►Ccaf::net::network_socket	A bidirectional network communication endpoint
►Ccaf::net::datagram_socket	A datagram-oriented network communication endpoint
Ccaf::net::udp_datagram_socket	A datagram-oriented network communication endpoint for bidirectional byte transmission
►Ccaf::net::stream_socket	A connection-oriented network communication endpoint for bidirectional byte streams
Ccaf::net::tcp_stream_socket	Represents a TCP connection
Ccaf::net::tcp_accept_socket	Represents a TCP acceptor in listening mode
Ccaf::net::pipe_socket	A unidirectional communication endpoint for inter-process communication
►Ccaf::detail::comparable< stream >
Ccaf::stream	Provides access to a potentially unbound sequence of items emitted by an actor
Ccaf::typed_stream< T >	Provides access to a statically typed, potentially unbound sequence of items emitted by an actor
►Ccaf::detail::comparable< Subtype >
Ccaf::handle< Subtype, InvalidType, InvalidId >	Base class for IO handles such as accept_handle or connection_handle
►Ccaf::detail::comparable< Subtype, InvalidType >
Ccaf::handle< Subtype, InvalidType, InvalidId >	Base class for IO handles such as accept_handle or connection_handle
►Ccaf::detail::comparable< type_id_list >
Ccaf::type_id_list	A list of type IDs, stored in a size-prefix, contiguous memory block
►Ccaf::detail::comparable< typed_actor< TraitOrSignature > >
Ccaf::typed_actor< TraitOrSignature >	Identifies a statically typed actor
►Ccaf::detail::comparable< typed_actor< TraitOrSignature >, actor >
Ccaf::typed_actor< TraitOrSignature >	Identifies a statically typed actor
►Ccaf::detail::comparable< typed_actor< TraitOrSignature >, actor_addr >
Ccaf::typed_actor< TraitOrSignature >	Identifies a statically typed actor
►Ccaf::detail::comparable< typed_actor< TraitOrSignature >, strong_actor_ptr >
Ccaf::typed_actor< TraitOrSignature >	Identifies a statically typed actor
►Ccaf::detail::comparable< typed_stream< T > >
Ccaf::typed_stream< T >	Provides access to a statically typed, potentially unbound sequence of items emitted by an actor
►Ccaf::detail::comparable< unit_t >
Ccaf::unit_t	Unit is analogous to void, but can be safely returned, stored, etc
►Ccaf::detail::comparable< uri >
Ccaf::uri	A URI according to RFC 3986
►Ccaf::detail::comparable< uri, std::string_view >
Ccaf::uri	A URI according to RFC 3986
►Ccaf::detail::comparable< uuid >
Ccaf::uuid	A universally unique identifier according to RFC 4122
►Ccaf::detail::comparable< weak_intrusive_ptr< actor_control_block > >
Ccaf::weak_intrusive_ptr< actor_control_block >
►Ccaf::detail::comparable< weak_intrusive_ptr< actor_control_block >, const actor_control_block * >
Ccaf::weak_intrusive_ptr< actor_control_block >
►Ccaf::detail::comparable< weak_intrusive_ptr< actor_control_block >, std::nullptr_t >
Ccaf::weak_intrusive_ptr< actor_control_block >
►Ccaf::detail::comparable< weak_intrusive_ptr< T > >
Ccaf::weak_intrusive_ptr< T >	An intrusive, reference counting smart pointer implementation
►Ccaf::detail::comparable< weak_intrusive_ptr< T >, const T * >
Ccaf::weak_intrusive_ptr< T >	An intrusive, reference counting smart pointer implementation
►Ccaf::detail::comparable< weak_intrusive_ptr< T >, std::nullptr_t >
Ccaf::weak_intrusive_ptr< T >	An intrusive, reference counting smart pointer implementation
Ccaf::detail::config_consumer	Consumes a series of key-value pairs from an application configuration
Ccaf::detail::config_list_consumer	Consumes a list of config values
Ccaf::detail::config_value_consumer	Consumes a single configuration value
Ccaf::detail::connection_acceptor	Accepts incoming connections and creates a socket manager for each
Ccaf::detail::connection_factory< ConnectionHandle >	Creates new socket managers for an accept_handler
Ccaf::detail::consumer< T >	Consumes a single value
Ccaf::detail::consumer< int64_t >	Specializes consumer for int64_t with a safe conversion from uint64_t
Ccaf::detail::consumer< uint64_t >	Specializes consumer for uint64_t with a safe conversion from int64_t
Ccaf::detail::container_view< F, Container >	Decorates a container of type T to appear as container of type U
Ccaf::detail::file_reader< T >	A generator that emits characters or bytes from a file
Ccaf::detail::flow_bridge_initializer	Initializes the inputs and outputs of a flow bridge
Ccaf::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
Ccaf::detail::has_builtin_inspect< Inspector, T >	Checks whether the inspector has a builtin_inspect overload for T
Ccaf::detail::has_init_host_system< T >	Checks whether T has a static member function called init_host_system
Ccaf::detail::has_inspect_overload< Inspector, T >	Checks whether T provides an inspect overload for Inspector
Ccaf::detail::has_to_string< T >	Checks whether T defines a free function to_string
Ccaf::detail::il_indices< List, Pos, Indices >	Creates indices for List beginning at Pos
Ccaf::detail::init_fun_factory_helper< Base, F, Tuple, ReturnsBehavior, HasSelfPtr >	Wraps a user-defined function and gives it a uniform signature
Ccaf::detail::int_list< Is >	A list of integers (wraps a long... template parameter pack)
Ccaf::detail::int_types_by_size< size_t >	Compile-time list of integer types types
Ccaf::detail::invoke_result_visitor	Inspects the result of message handlers and triggers type-depended actions such as generating result messages
Ccaf::detail::is_behavior< T >	Checks whether T is a behavior or typed_behavior
Ccaf::detail::is_builtin_inspector_type< T, IsLoading >	Checks whether T is primitive, i.e., either an arithmetic type or convertible to one of STL's string types
Ccaf::detail::is_callable< T >	Checks whether T is a function, function object or member function
Ccaf::detail::is_comparable< T1, T2 >	Checks whether T1 is comparable with T2
Ccaf::detail::is_forward_iterator< T >	Checks whether T behaves like a forward iterator
Ccaf::detail::is_handler_for< F, T >	Checks whether F is convertible to either std::function<void (T&)> or std::function<void (const T&)>
Ccaf::detail::is_iterable< T >	Checks whether T has begin() and end() member functions returning forward iterators
Ccaf::detail::is_list_like< T >	Checks whether T behaves like std::vector, std::list, or std::set
Ccaf::detail::is_map_like< T >	Checks whether T behaves like std::map
Ccaf::detail::is_mutable_ref< T >	Checks whether T is a non-const reference
Ccaf::detail::is_one_of< T, Ts >	Checks whether T is in the template parameter pack Ts
Ccaf::detail::is_one_of< T, Ts... >
Ccaf::detail::is_optional< T >	Checks whether T is a std::optional
Ccaf::detail::is_pair< T >	Utility trait for checking whether T is a std::pair
Ccaf::detail::is_primitive< T >	Checks whether T is primitive, i.e., either an arithmetic type or convertible to one of STL's string types
Ccaf::detail::is_publisher< T >	Checks whether T is a publisher
Ccaf::detail::is_stl_tuple_type< T >	Evaluates to true for all types that specialize std::tuple_size, i.e., std::tuple, std::pair, and std::array
Ccaf::detail::is_stream< T >	Checks whether T is a stream or typed_stream
Ccaf::detail::left_oracle< Left, Right >	Always evaluates to Left
Ccaf::detail::log_level_map	Maps log levels to their names
Ccaf::detail::mailbox_factory	The base class for all mailbox implementations
Ccaf::detail::message_builder_element	Wraps a value for either copying or moving it into a pre-allocated storage later
Ccaf::detail::message_data	Container for storing an arbitrary number of message elements
Ccaf::detail::meta_object	Enables destroying, constructing and serializing objects through type-erased pointers
Ccaf::detail::monotonic_buffer_resource	Replacement for std::pmr::monotonic_buffer_resource, which sadly is not available on all platforms CAF currently supports
Ccaf::detail::monotonic_buffer_resource::block	A single block of memory
Ccaf::detail::monotonic_buffer_resource::bucket	A bucket for storing multiple blocks
Ccaf::detail::normalize_newlines_step	Converts "\r\n" and "\r" to "\n"
►Ccaf::detail::plain_ref_counted	Base class for reference counted objects with an plain (i.e., thread-unsafe) reference count
Ccaf::flow::observer_impl_base< on_success_arg_t< OnSuccess > >
►Ccaf::flow::observer_impl_base< T >	Simple base type observer implementations that implements the reference counting member functions with a plain (i.e., not thread-safe) reference count
Ccaf::flow::forwarder< T, Target, Token >	Forwards all events to its parent
Ccaf::flow::op::ucast_sub_state< T >	Shared state between an operator that emits values and the subscribed observer
►Ccaf::flow::subscription::impl_base	Simple base type for all subscription implementations that implements the reference counting member functions
Ccaf::flow::op::cell_sub< T >	The subscription object for interfacing an observer with the cell state
Ccaf::flow::op::concat_sub< T >	Combines items from any number of observables
Ccaf::flow::op::merge_sub< T >	Receives observables from the pre-merge step and merges their inputs for the observer
Ccaf::flow::op::sample_sub< T >	The subscription for the sample operator
Ccaf::flow::op::zip_with_sub< F, Ts >	Combines items from any number of observables using a zip function
Ccaf::flow::subscription::fwd_impl	Default implementation for subscriptions that forward request and cancel to a listener
Ccaf::detail::print_iterator_adapter< OutputIterator >	Wraps an output iterator to provide a push_back and insert member functions for using the print algorithms
Ccaf::detail::rfc3629	Wraps functions for processing RFC 3629 encoding, i.e., UTF-8
Ccaf::detail::ring_buffer< T >	A simple ring buffer implementation
Ccaf::detail::ring_buffer< output_type >
Ccaf::detail::scope_guard< Fun >	A lightweight scope guard implementation
Ccaf::detail::single_arg_wrapper< T >	Enables automagical string conversion for CAF_ARG
Ccaf::detail::split_as_utf8_at_step	Turns a sequence of bytes into a sequence of cow_string based on separator
Ccaf::detail::split_at_step	Turns a sequence of bytes into a sequence of chunks based on separator
Ccaf::detail::squashed_int< T >	Squashes integer types into [u]int_[8|16|32|64]_t equivalents
Ccaf::detail::stateful_actor_base< State, Base >	Conditional base type for stateful_actor that overrides make_behavior if State::make_behavior() exists
Ccaf::detail::static_error_printer< NumMessageHandlers, Pos, RemainingXs, RemainingYs >	Generates an error using static_assert on an interface mismatch
Ccaf::detail::sync_request_bouncer	Consumes mailbox elements and sends an error message for each request
Ccaf::detail::thread_safe_actor_clock::schedule_entry	Stores actions along with their scheduling period
Ccaf::detail::tl_apply< List, VarArgTemplate >	Applies the types of the list to VarArgTemplate
Ccaf::detail::tl_at< type_list< E... >, N >	Gets element at index N of List
Ccaf::detail::tl_back< List >	Gets the last element in List
Ccaf::detail::tl_exists< List, Pred >	Tests whether a predicate holds for some of the elements of a list
Ccaf::detail::tl_filter< type_list< Ts... >, Pred >	Create a new list containing all elements which satisfy Pred
Ccaf::detail::tl_filter_not< type_list< Ts... >, Pred >	Create a new list containing all elements which satisfy Pred
Ccaf::detail::tl_forall< List, Pred >	Tests whether a predicate holds for all elements of a list
Ccaf::detail::tl_head< List >	Gets the first element of List
Ccaf::detail::tl_index_of< List, T >	Finds the first element satisfying Pred beginning at index Pos
Ccaf::detail::tl_index_of_impl< Pos, X, Ts >	Finds the first element of type What beginning at index Pos
Ccaf::detail::tl_is_distinct< List >	Tests whether a list is distinct
Ccaf::detail::tl_map< List, Fn >	Creates a new list by applying a "template function" to each element
Ccaf::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
Ccaf::detail::tl_replace_back< type_list< T1, Ts... >, Back, type_list< Us..., T0 > >
Ccaf::detail::tl_size< List >	Gets the number of template parameters of List
Ccaf::detail::tl_subset_of< ListA, ListB >	Evaluates to true if ListA is a subset of ListB, i.e., if all elements in ListA are also in ListB
Ccaf::detail::to_chars_step	Turns a sequence of strings into a sequence of characters
Ccaf::detail::to_chunks_step	Turns a sequence of bytes into a sequence of chunks
Ccaf::detail::to_lines_step	Turns a sequence of characters into a sequence of lines
Ccaf::detail::unique_function< Signature >	A move-only replacement for std::function
Ccaf::detail::unique_function< caf::behavior(caf::local_actor *)>
Ccaf::detail::unique_function< R(Ts...)>::wrapper	Function object that dispatches application with a virtual member function
Ccaf::detail::unique_function< void(local_actor *)>
Ccaf::dictionary< class >	Maps strings to values of type V, but unlike std::map<std::string, V> accepts std::string_view for looking up keys efficiently
Ccaf::dictionary< config_value >
►Ccaf::disposable::impl	Internal implementation class of a disposable
Ccaf::action::impl	Internal interface of action
Ccaf::flow::op::from_resource_sub< Buffer >	Reads from an observable buffer and emits the consumed items
Ccaf::down_msg	Sent to all actors monitoring an actor when it is terminated
Ccaf::dynamically_typed	Tag type to indicate that the sender of a message is a dynamically typed actor
►Ccaf::dynamically_typed_actor_base	Marker type for dynamically typed actors
Ccaf::blocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Ccaf::event_based_actor	A cooperatively scheduled, event-based actor implementation
►Ccaf::io::broker	Describes a dynamically typed broker
Ccaf::detail::prometheus_broker	Makes system metrics in the Prometheus format available via HTTP 1.1
Ccaf::io::basp_broker	A broker implementation for the Binary Actor System Protocol (BASP)
Ccaf::net::actor_shell	Enables socket managers to communicate with actors using dynamically typed messaging
Ccaf::error_code< class >	A lightweight wrapper around an error code enum
Ccaf::event_based_delayed_response_handle<... >	Similar to event_based_response_handle, but also holds the disposable for the delayed request message
Ccaf::event_based_mtl< Self, Adapter, Reader >	Enables event-based actors to generate messages from a user-defined data exchange format such as JSON and to send the generated messages to another (typed) actor
Ccaf::event_based_response_handle<... >	This helper class identifies an expected response message and enables request(...).then(...)
Ccaf::event_based_response_handle< message >	This helper class identifies an expected response message and enables request(...).then(...)
Ccaf::event_based_response_handle< Results... >
Ccaf::event_based_response_handle_state	Holds state for a event-based response handles
Ccaf::exit_msg	Sent to all links when an actor is terminated
Ccaf::expected< class >	Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error
Ccaf::expected< std::tuple< T1, T2, Ts... > >
Ccaf::expected< T >
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::flow::byte	Provides transformations for sequences of bytes
Ccaf::flow::connectable< T >	Resembles a regular observable, except that it does not begin emitting items when it is subscribed to
►Ccaf::flow::coordinated	An object that lives on a coordinator
►Ccaf::flow::op::base< async::batch >
Ccaf::flow::op::hot< async::batch >
►Ccaf::flow::op::base< Trait::output_type >
Ccaf::flow::op::cold< Trait::output_type >
►Ccaf::flow::op::base< defer_trait< Factory >::output_type >
Ccaf::flow::op::cold< defer_trait< Factory >::output_type >
►Ccaf::flow::op::base< from_generator_output_t< Generator, Steps... > >
Ccaf::flow::op::hot< from_generator_output_t< Generator, Steps... > >
►Ccaf::flow::op::base< from_steps_output_t< Steps... > >
Ccaf::flow::op::cold< from_steps_output_t< Steps... > >
►Ccaf::flow::op::base< int64_t >
Ccaf::flow::op::cold< int64_t >
►Ccaf::flow::op::base< zip_with_output_t< F, Ts... > >
Ccaf::flow::op::cold< zip_with_output_t< F, Ts... > >
Ccaf::flow::observer< T >::impl	Internal interface of an observer
►Ccaf::flow::op::base< T >	Abstract base type for all flow operators that implement the observable concept
Ccaf::flow::op::cold< cow_tuple< cow_vector< T >, observable< T > > >
Ccaf::flow::op::cold< T >	Convenience base type for cold observable types
Ccaf::flow::op::hot< T >	Convenience base type for hot observable types
Ccaf::flow::op::ucast_sub_state< T >	Shared state between an operator that emits values and the subscribed observer
►Ccaf::flow::subscription::impl	Internal interface of a subscription
Ccaf::flow::op::from_resource_sub< Buffer >	Reads from an observable buffer and emits the consumed items
Ccaf::flow::subscription::impl_base	Simple base type for all subscription implementations that implements the reference counting member functions
Ccaf::flow::subscription::listener	Describes a listener to the subscription that will receive an event whenever the observer calls request or cancel
Ccaf::flow::gen::empty< T >	A generator that emits nothing and calls on_complete immediately
Ccaf::flow::gen::from_callable< F >	A generator that emits values from a function object
Ccaf::flow::gen::from_container< Container >	A generator that emits values from a vector
Ccaf::flow::gen::iota< T >	A generator that emits ascending values
Ccaf::flow::gen::just< T >	A generator that emits a single value once
Ccaf::flow::gen::repeat< T >	A generator that emits the same value repeatedly
Ccaf::flow::generation_materializer< Generator >	Materializes an observable from a Generator that produces items and any number of processing steps that immediately transform the produced items
Ccaf::flow::multicaster< T >	A multicaster pushes items to any number of subscribers
Ccaf::flow::observable< T >	Represents a potentially unbound sequence of values
Ccaf::flow::observable< caf::flow::observable< T > >
Ccaf::flow::observable< input_type >
Ccaf::flow::observable< int64_t >
Ccaf::flow::observable< typename Trait::select_token_type >
Ccaf::flow::observable_builder	Factory for observable objects
Ccaf::flow::observable_def< Materializer, Steps >	Captures the definition of an observable that has not materialized yet
►Ccaf::flow::op::cell_listener< T >	Interface for listening on a cell
Ccaf::flow::op::cell_sub< T >	The subscription object for interfacing an observer with the cell state
Ccaf::flow::op::cell_sub_state< T >	State shared between one multicast operator and one subscribed observer
►Ccaf::flow::op::pullable	Base class for operators that allow observers to pull items via request(n)
Ccaf::flow::op::merge_sub< T >	Receives observables from the pre-merge step and merges their inputs for the observer
Ccaf::flow::op::ucast_sub_state< T >	Shared state between an operator that emits values and the subscribed observer
Ccaf::flow::op::ucast_sub_state< T >::abstract_listener	Interface for listeners that want to be notified when a ucast_sub_state is disposed, has consumed some items, or when its demand hast changed
Ccaf::flow::single< T >	Similar to an observable, but always emits either a single value or an error
Ccaf::flow::step::ignore_elements< T >	A step that ignores all elements and only forwards calls to on_complete and on_error
Ccaf::flow::string	Provides transformations for strings and sequences of characters
Ccaf::flow::subscription	Controls the flow of items from publishers to subscribers
Ccaf::flow::transformation_materializer< Input >	Materializes an observable from a source observable and one or more processing steps
Ccaf::format_string_with_location	Wraps a format string and its source location
Ccaf::function_view< class >	A function view for an actor hides any messaging from the caller
Ccaf::get_or_auto_deduce	Configures get_or to uses the get_or_deduction_guide
Ccaf::get_or_deduction_guide< T >	Customization point for configuring automatic mappings from default value types to deduced types
Ccaf::ignore_case_t	Tag type for selecting case-insensitive algorithms
Ccaf::illegal_message_element	Marker class identifying classes in CAF that are not allowed to be used as message element
Ccaf::infer_handle_from_class< T, bool >	Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced
Ccaf::infer_handle_from_fun_trait< Trait >	Deduces an actor handle type from a function or function object
Ccaf::inspector_access< T >	Customization point for adding support for a custom type
Ccaf::inspector_access_base< T >	Provides default implementations for save_field and load_field
Ccaf::inspector_access_base< std::byte >
Ccaf::inspector_access_base< std::chrono::duration< Rep, Period > >
Ccaf::inspector_access_base< std::chrono::time_point< std::chrono::system_clock, Duration > >
Ccaf::inspector_access_base< uri >
Ccaf::inspector_access_type	Wraps tag types for static dispatching
Ccaf::inspector_access_type::builtin	Flags types with builtin support of the inspection API
Ccaf::inspector_access_type::builtin_inspect	Flags types with builtin support via Inspector::builtin_inspect
Ccaf::inspector_access_type::empty	Flags stateless message types
Ccaf::inspector_access_type::inspect	Flags types that provide an inspect() overload
Ccaf::inspector_access_type::list	Flags types with std::vector-like API
Ccaf::inspector_access_type::map	Flags types with std::map-like API
Ccaf::inspector_access_type::none	Flags types without any default access
Ccaf::inspector_access_type::specialization	Flags types that provide an inspector_access specialization
Ccaf::inspector_access_type::tuple	Flags types with std::tuple-like API
Ccaf::inspector_access_type::unsafe	Flags allowed unsafe message types
Ccaf::internal::flow_bridge_base< UpperLayer, LowerLayer, ItemType >	Translates between a message-oriented transport and data flows
Ccaf::intrusive::lifo_inbox< T >	An intrusive, thread-safe LIFO queue implementation for a single reader with any number of writers
Ccaf::intrusive::lifo_inbox< mailbox_element >
Ccaf::intrusive::linked_list< T >	A singly-linked list implementation
Ccaf::intrusive::linked_list< mailbox_element >
Ccaf::intrusive::singly_linked< T >	Intrusive base for singly linked types that allows queues to use T with dummy nodes
Ccaf::intrusive::singly_linked< mailbox_element >
Ccaf::intrusive::stack< T >	A simple stack implementation with singly-linked nodes
Ccaf::intrusive::stack< mailbox_element >
Ccaf::intrusive_ptr< class >	An intrusive, reference counting smart pointer implementation
Ccaf::intrusive_ptr< actor_control_block >
Ccaf::intrusive_ptr< actor_local_printer >
Ccaf::intrusive_ptr< base< T > >
Ccaf::intrusive_ptr< Buffer >
Ccaf::intrusive_ptr< caf::actor_companion >
Ccaf::intrusive_ptr< caf::disposable::impl >
Ccaf::intrusive_ptr< caf::flow::coordinated >
Ccaf::intrusive_ptr< caf::flow::coordinator >
Ccaf::intrusive_ptr< caf::flow::observer::impl >
Ccaf::intrusive_ptr< caf::flow::op::base< Input > >
Ccaf::intrusive_ptr< caf::flow::op::base< input_type > >
Ccaf::intrusive_ptr< caf::flow::op::base< T > >
Ccaf::intrusive_ptr< caf::flow::subscription::impl >
Ccaf::intrusive_ptr< caf::flow::subscription::listener >
Ccaf::intrusive_ptr< caf::logger >
Ccaf::intrusive_ptr< caf::net::http::responder::promise_state >
Ccaf::intrusive_ptr< caf::resumable >
Ccaf::intrusive_ptr< chunk::data >
Ccaf::intrusive_ptr< config_type >
Ccaf::intrusive_ptr< consumer >
Ccaf::intrusive_ptr< coordinator >
Ccaf::intrusive_ptr< data >
Ccaf::intrusive_ptr< datagram_manager >
Ccaf::intrusive_ptr< datagram_servant >
Ccaf::intrusive_ptr< detail::behavior_impl >
Ccaf::intrusive_ptr< detail::message_data >
Ccaf::intrusive_ptr< doorman >
Ccaf::intrusive_ptr< event >
Ccaf::intrusive_ptr< execution_context >
Ccaf::intrusive_ptr< impl >
Ccaf::intrusive_ptr< impl_type >
Ccaf::intrusive_ptr< manager_type >
Ccaf::intrusive_ptr< multiplexer >
Ccaf::intrusive_ptr< node_id_data >
Ccaf::intrusive_ptr< op::base< input_type > >
Ccaf::intrusive_ptr< op::base< int64_t > >
Ccaf::intrusive_ptr< op::base< T > >
Ccaf::intrusive_ptr< op::base< typename Trait::select_token_type > >
Ccaf::intrusive_ptr< op::mcast< T > >
Ccaf::intrusive_ptr< op::publish< T > >
Ccaf::intrusive_ptr< producer >
Ccaf::intrusive_ptr< ref_counted >
Ccaf::intrusive_ptr< resource_ctrl< accept_event, false > >
Ccaf::intrusive_ptr< resource_ctrl< input_type, false > >
Ccaf::intrusive_ptr< resource_ctrl< output_type, true > >
Ccaf::intrusive_ptr< resource_ctrl< T, false > >
Ccaf::intrusive_ptr< resource_ctrl< T, true > >
Ccaf::intrusive_ptr< scribe >
Ccaf::intrusive_ptr< socket_manager >
Ccaf::intrusive_ptr< State >
Ccaf::intrusive_ptr< state >
Ccaf::intrusive_ptr< storage >
Ccaf::intrusive_ptr< stream_manager >
Ccaf::intrusive_ptr< T >
Ccaf::intrusive_ptr< Target >
Ccaf::intrusive_ptr< uri::impl_type >
Ccaf::intrusive_ptr< ws_conn_acceptor >
Ccaf::intrusive_ptr_access< T >	Policy for adding and releasing references in an intrusive_ptr
►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::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::basp::header	The header of a Binary Actor System Protocol (BASP) message
Ccaf::io::basp::instance	Describes a protocol instance managing multiple connections
►Ccaf::io::basp::instance::callee	Provides a callback-based interface for certain BASP events
Ccaf::io::basp_broker	A broker implementation for the Binary Actor System Protocol (BASP)
Ccaf::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
Ccaf::io::basp::message_queue::actor_msg	Request for sending a message to an actor at a later time
Ccaf::io::basp::routing_table	Stores routing information for a single broker participating as BASP peer and provides both direct and indirect paths
Ccaf::io::basp::routing_table::route	Describes a routing path to a node
►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::middleman::background_task	Independent tasks that run in the background, usually in their own thread
Ccaf::io::middleman::metric_singletons_t	Metrics that the middleman collects by default
Ccaf::io::middleman_actor_impl	Default implementation of the middleman_actor interface
►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::policy::tcp >
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< caf::policy::tcp >
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::event_handler::state	Stores various status flags and user-defined config parameters
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 multiplier 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::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_actor_handle< T >	Checks whether T is an actor or a typed_actor<...>
Ccaf::is_error_code_enum< T >	Customization point for enabling conversion from an enum type to an error or error_code
Ccaf::is_typed_actor< T >	Evaluates to true if T is a typed_actor<...>
Ccaf::is_variant_wrapper< class >	Customization point
Ccaf::json_array	Represents a JSON array
Ccaf::json_object	Represents a JSON object
Ccaf::json_value	Represents an immutable JSON value
Ccaf::load_inspector	Base type for inspectors that load objects from some input source
Ccaf::local_actor::inbound_stream_metrics_t	Optional metrics for inbound stream traffic collected by individual actors when configured to do so
Ccaf::local_actor::metrics_t	Optional metrics collected by individual actors when configured to do so
Ccaf::local_actor::outbound_stream_metrics_t	Optional metrics for outbound stream traffic collected by individual actors when configured to do so
Ccaf::log::event::field	A single, user-defined field
Ccaf::log::event::field_list	A list of user-defined fields
Ccaf::log::event_fields_builder	Builds list of user-defined fields for a log event
Ccaf::log::event_sender	Builds a log event by allocating each field on a monotonic buffer and then sends it to the current logger
Ccaf::log::keep_timestamp_t	Tag type for event::with_message that indicates that the event should keep its original timestamp
Ccaf::log::level	Provides integer constants for the predefined log levels
Ccaf::logger	Centrally logs events from all actors in an actor system
Ccaf::logger::entrypoint	Provides an API entry point for sending a log event to the current logger
Ccaf::logger::line_builder	Utility class for building user-defined log messages with CAF_ARG
Ccaf::logger::trace_exit_guard	Helper class to print exit trace messages on scope exit
Ccaf::mail_cache	A simple cache for storing mailbox elements for an actor for later reuse
Ccaf::message	Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type
Ccaf::message_builder	Provides a convenient interface for creating 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::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::net::actor_shell_ptr	An "owning" pointer to an actor shell in the sense that it calls quit() on the shell when going out of scope
Ccaf::net::dsl::arg::cstring	Represents a null-terminated string or null
Ccaf::net::dsl::arg::val< T >	Represents a value of type T or null
Ccaf::net::dsl::base	Base type for our DSL classes to configure a factory object
Ccaf::net::dsl::client_config	Wraps configuration parameters for starting clients
Ccaf::net::dsl::client_config::conn	Configuration for a client that uses an already established SSL connection
Ccaf::net::dsl::client_config_tag< T >	Meta programming utility
Ccaf::net::dsl::client_factory_base< Derived >	Base type for client factories for use with has_connect
►Ccaf::net::dsl::client_factory_base< client_factory >
Ccaf::net::http::client_factory	Factory for the with(...).connect(...).request(...) DSL
Ccaf::net::lp::client_factory	Factory for the with(...).connect(...).start(...) DSL
Ccaf::net::octet_stream::client_factory	Factory for the with(...).connect(...).start(...) DSL
Ccaf::net::web_socket::client_factory	Factory for the with(...).connect(...).start(...) DSL
Ccaf::net::dsl::generic_config	Wraps configuration of some base parameters before we know whether the user is starting a client or a server
Ccaf::net::dsl::generic_config_tag< T >	Meta programming utility
Ccaf::net::dsl::get_name< T >	Meta programming utility for accessing the name of a type
Ccaf::net::dsl::has_accept< Base, Subtype >	DSL entry point for creating a server
Ccaf::net::dsl::has_connect< Base, Subtype >	DSL entry point for creating a client
Ccaf::net::dsl::has_context< Base, Subtype >	DSL entry point for creating a server
Ccaf::net::dsl::has_lazy_context< Base, Subtype >	DSL entry point for postponing the creation of a ssl context, if and when needed by the protocol
►Ccaf::net::dsl::has_make_ctx	Configuration for an endpoint that stores a SSL context factory for secure networking
Ccaf::net::dsl::client_config::lazy	Configuration for a client that creates the socket on demand
Ccaf::net::dsl::client_config::socket	Configuration for a client that uses a user-provided socket
Ccaf::net::dsl::generic_config::lazy	Configuration for a client that creates the socket on demand
Ccaf::net::dsl::server_config::lazy	Configuration for a server that creates the socket on demand
Ccaf::net::dsl::server_config::socket	Configuration for a server that uses a user-provided socket
Ccaf::net::dsl::has_uri_connect< Base, Subtype >	DSL entry point for creating a client from an URI
Ccaf::net::dsl::server_address	Simple type for storing host and port information for reaching a server
Ccaf::net::dsl::server_config	Wraps configuration parameters for starting clients
Ccaf::net::dsl::server_config_tag< T >	Meta programming utility
Ccaf::net::dsl::server_factory_base< Derived >	Base type for server factories for use with can_accept
►Ccaf::net::dsl::server_factory_base< has_on_request >
Ccaf::net::web_socket::has_on_request	DSL entry point for creating a server
►Ccaf::net::dsl::server_factory_base< server_factory >
Ccaf::net::http::server_factory	Factory type for the with(...).accept(...).start(...) DSL
Ccaf::net::lp::server_factory	Factory type for the with(...).accept(...).start(...) DSL
►Ccaf::net::dsl::server_factory_base< server_factory< Ts... > >
Ccaf::net::web_socket::server_factory< Ts >	Factory type for the with(...).accept(...).start(...) DSL
►Ccaf::net::generic_lower_layer	Bundles protocol-independent, generic member functions for (almost all) lower layers
Ccaf::net::http::lower_layer	Parses HTTP requests and passes them to the upper layer
►Ccaf::net::lp::lower_layer	Provides access to a resource that operates on the granularity of binary messages
Ccaf::net::lp::framing	Implements length-prefix framing for discretizing a Byte stream into messages of varying size
Ccaf::net::octet_stream::lower_layer	Provides access to a resource that operates on a byte stream, e.g., a TCP socket
►Ccaf::net::web_socket::lower_layer	Produces text and binary messages for the upper layer
Ccaf::net::web_socket::framing	Implements the WebSocket framing protocol as defined in RFC-6455
►Ccaf::net::generic_upper_layer	Bundles protocol-independent, generic member functions for (almost all) upper layers
Ccaf::net::http::upper_layer	Operates on HTTP requests
Ccaf::net::lp::upper_layer	Consumes lp messages from the lower layer
►Ccaf::net::octet_stream::upper_layer	The upper layer requests bytes from the lower layer and consumes raw chunks of data
Ccaf::net::http::client	Implements the client part for the HTTP Protocol as defined in RFC 7231
Ccaf::net::http::server	Implements the server part for the HTTP Protocol as defined in RFC 7231
Ccaf::net::lp::framing	Implements length-prefix framing for discretizing a Byte stream into messages of varying size
Ccaf::net::web_socket::client	Implements the client part for the WebSocket Protocol as defined in RFC
Ccaf::net::web_socket::framing	Implements the WebSocket framing protocol as defined in RFC-6455
Ccaf::net::web_socket::server	Implements the server part for the WebSocket Protocol as defined in RFC
Ccaf::net::web_socket::upper_layer	Consumes text and binary messages from the lower layer
Ccaf::net::http::arg_parser< class >	Customization point for adding custom types to the <arg> parsing of the router
►Ccaf::net::http::header	Encapsulates meta data for HTTP header fields
Ccaf::net::http::request_header	Encapsulates meta data for HTTP requests
Ccaf::net::http::response_header	Encapsulates meta data for HTTP response
Ccaf::net::http::request	Implicitly shared handle type that represents an HTTP client request with a promise for the HTTP response
Ccaf::net::http::responder	Responds to an HTTP request at the server
Ccaf::net::http::responder::promise	Allows users to respond to an incoming HTTP request at some later time
Ccaf::net::http::response	Handle type (implicitly shared) that represents an HTTP server response
Ccaf::net::http::with_t	Entry point for the with(...) DSL
Ccaf::net::lp::base_config< Trait >	Configuration for the with_t DSL entry point
Ccaf::net::lp::with_t	Entry point for the with(...) DSL
Ccaf::net::octet_stream::policy	Configures a transport object
Ccaf::net::octet_stream::with_t	Entry point for the with(...) DSL
Ccaf::net::prometheus::scrape_state	State for scraping Metrics data
Ccaf::net::receive_policy	Configures how many bytes an octet stream transport receives before calling consume on its upper layer
Ccaf::net::socket_event_layer	The lowest layer in a protocol stack
Ccaf::net::socket_guard< Socket >	Closes the guarded socket when destroyed
Ccaf::net::ssl::connection	SSL state for a single connections
Ccaf::net::ssl::context	SSL state, shared by multiple connections
Ccaf::net::ssl::tcp_acceptor	Wraps a TCP accept socket and an SSL context
Ccaf::net::ssl::transport	Implements a octet stream transport that manages a stream socket with encrypted communication over TLS
Ccaf::net::this_host	Groups functions for managing the host system
Ccaf::net::typed_actor_shell_ptr< T1, T2, Ts... >	An "owning" pointer to an actor shell in the sense that it calls quit() on the shell when going out of scope
Ccaf::net::typed_actor_shell_ptr< TraitOrSignature >	An "owning" pointer to an actor shell in the sense that it calls quit() on the shell when going out of scope
Ccaf::net::web_socket::acceptor< Ts >	Accepts or rejects incoming connection requests
Ccaf::net::web_socket::acceptor< Ts... >
Ccaf::net::web_socket::frame	An implicitly shared type for passing along WebSocket data frames, i.e., text or binary frames
Ccaf::net::web_socket::handshake	Wraps state and algorithms for the WebSocket client handshake as defined in RFC 6455
Ccaf::net::web_socket::is_acceptor< T >	Type trait that determines if a type is an acceptor
Ccaf::net::web_socket::is_acceptor< acceptor< Ts... > >	Specialization of is_acceptor for acceptor types
►Ccaf::net::web_socket::server_factory_base	Factory type for the with(...).accept(...).start(...) DSL
Ccaf::net::web_socket::server_factory< Ts >	Factory type for the with(...).accept(...).start(...) DSL
Ccaf::net::web_socket::switch_protocol_bind_1	DSL entry point for creating a server
Ccaf::net::web_socket::switch_protocol_bind_2< OnRequest >	Binds a switch_protocol invocation to a function object for on_request
Ccaf::net::web_socket::with_t	Entry point for the with(...) DSL
Ccaf::node_down_msg	Sent to all actors monitoring a node when CAF loses connection to it
Ccaf::node_id	A node ID is an opaque value for representing CAF instances in the network
►Ccaf::non_blocking_actor_base	Marker type for non-blocking actors
Ccaf::abstract_scheduled_actor	A cooperatively scheduled, event-based actor implementation
Ccaf::once_t	Tag type to indicate that an operation should take place only once
Ccaf::optional_inspector_access< T >	Provides inspector access for types that represent optional values
Ccaf::optional_inspector_access< std::optional< T > >
Ccaf::optional_inspector_access< std::unique_ptr< error::data > >
Ccaf::parser_state< Iterator, Sentinel >	Stores all information necessary for implementing an FSM-based parser
Ccaf::parser_state< std::string_view::iterator >
Ccaf::partial_behavior_init_t	Tag type for constructing a typed_behavior with an incomplete list of message handlers, delegating to the default handler for all unmatched inputs
Ccaf::policy::arg< Ts >	Provides a wrapper to pass policy types as values to functions
Ccaf::policy::select_all< ResponseType >	Enables a response_handle to fan-in all responses messages into a single result (a vector that stores all received results)
Ccaf::policy::select_any< ResponseType >	Enables a response_handle to pick the first arriving response, ignoring all other results
Ccaf::policy::single_response< ResponseType >	Trivial policy for handling a single result in a response_handler
Ccaf::policy::tcp	Policy object for wrapping default TCP operations
Ccaf::policy::udp	Policy object for wrapping default UDP operations
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::io::basp_broker	A broker implementation for the Binary Actor System Protocol (BASP)
Ccaf::repeat_t	Tag type to indicate that an operation should be repeated
Ccaf::response_handle< ActorType, Policy >	This helper class identifies an expected response message and enables request(...).then(...)
Ccaf::response_promise	Enables actors to delay a response message by capturing the context of a request message
Ccaf::response_type< Ts, Xs >	Defines:
Ccaf::response_type< Ts, message >
Ccaf::response_type< Ts, Xs... >
Ccaf::response_type< type_list< Fs... >, Xs... >
Ccaf::response_type_unbox< Ts, Xs >	Unboxes Xs and calls response_type
Ccaf::result< Ts >	Wraps the result of a message handler to represent either a value (wrapped into a message), a delegated<Ts...> (indicates that another actor is going to respond), or an error
Ccaf::result_base< Ts >	Base type for all specializations of result
Ccaf::result_base< message >
Ccaf::result_base< T >
Ccaf::result_base< T0, T1, Ts... >
Ccaf::result_base< void >
►Ccaf::resumable	A cooperatively scheduled entity
Ccaf::action::impl	Internal interface of action
Ccaf::io::network::multiplexer::runnable	Simple wrapper for runnables
Ccaf::save_inspector	Base type for inspectors that save objects to some output sink
►Ccaf::scheduler	A scheduler is responsible for managing the execution of resumables
Ccaf::io::network::multiplexer	Low-level backend for IO multiplexing
Ccaf::scoped_actor	A scoped handle to a blocking actor
Ccaf::skip_t	Default handler function that leaves messages in the mailbox
Ccaf::skippable_result	Similar to result<message>, but also allows to skip a message
Ccaf::span< T >	A C++11/14 drop-in replacement for C++20's std::span without support for static extents
Ccaf::span< const std::byte >
Ccaf::span< format_arg >
Ccaf::stateful_actor< State, Base >	An event-based actor with managed state
Ccaf::statically_typed< Sigs >	A statically typed trait type wrapping the given parameter pack of signatures as a type list
►Ccaf::statically_typed_actor_base	Marker type for statically typed actors
Ccaf::io::typed_broker< Sigs >	A typed broker mediates between actor systems and other components in the network
Ccaf::net::typed_actor_shell< T1, T2, Ts... >	Enables socket managers to communicate with actors using statically typed messaging
Ccaf::net::typed_actor_shell< TraitOrSignature >	Enables socket managers to communicate with actors using statically typed messaging
Ccaf::typed_event_based_actor< T1, T2, Ts... >	A cooperatively scheduled, event-based actor implementation with static type-checking
Ccaf::typed_event_based_actor< TraitOrSignature >	A cooperatively scheduled, event-based actor implementation with static type-checking
Ccaf::stream_abort_msg	Informs the sink that a stream has been aborted due to an unrecoverable error
Ccaf::stream_ack_msg	Informs the sink that the source has added it to the flow
Ccaf::stream_batch_msg	Transfers items from a source to a sink
Ccaf::stream_cancel_msg	Informs the source that the sender is no longer interest in receiving items from this stream
Ccaf::stream_close_msg	Informs the sink that a stream has reached the end
Ccaf::stream_demand_msg	Asks the source for more data
Ccaf::stream_open_msg	Asks a source to add another sink
Ccaf::strong_ref_t	Tag type to indicate that the system should keep a strong reference to an actor
Ccaf::strong_self_ref_t	Tag type to indicate that the system should keep a strong reference to an actor after passing it the self pointer
Ccaf::telemetry::collector::prometheus	Collects system metrics and exports them to the text-based Prometheus format
Ccaf::telemetry::counter< ValueType >	A metric that represents a single value that can only go up
Ccaf::telemetry::counter< int64_t >
Ccaf::telemetry::dbl_gauge	A metric that represents a single integer value that can arbitrarily go up and down
Ccaf::telemetry::histogram< ValueType >	Represent aggregatable distributions of events
Ccaf::telemetry::importer::process	Imports CPU and memory metrics for the current process
Ccaf::telemetry::int_gauge	A metric that represents a single integer value that can arbitrarily go up and down
Ccaf::telemetry::metric	A single metric, identified by the values it sets for the label dimensions
Ccaf::telemetry::metric_family	Manages a collection (family) of metrics
Ccaf::telemetry::metric_registry	Manages a collection of metric families
Ccaf::telemetry::metric_registry::span_type< T >	Forces the compiler to use the type span<const T> instead of trying to match parameters to a span
Ccaf::telemetry::timer	Convenience helper for measuring durations such as latency using a histogram with second resolution
Ccaf::thread_hook	Interface to define thread hooks
Ccaf::timeout_msg	Signals a timeout to an actor
Ccaf::type_by_id< V >	Maps the globally unique ID V to a type (inverse to type_id)
Ccaf::type_id< T >	Maps the type T to a globally unique ID
►Ccaf::type_id_mapper	Translates between human-readable type names and type IDs
Ccaf::default_type_id_mapper	Dispatches to query_type_name and query_type_id
Ccaf::type_list< Ts >	A list of types
Ccaf::type_name< T >	Convenience type that resolves to type_name_by_id<type_id_v<T>>
Ccaf::type_name< void >	Convenience specialization that enables generic code to not treat void manually
Ccaf::type_name_by_id< V >	Maps the globally unique ID V to a type name
Ccaf::typed_actor< T1, T2, Ts... >	Identifies a statically typed actor
Ccaf::typed_actor_pointer< T1, T2, Ts... >	Provides a view to an actor that implements this messaging interface without knowledge of the actual type
Ccaf::typed_actor_view< T1, T2, Ts... >	Decorates a pointer to a scheduled_actor with a statically typed actor interface
Ccaf::typed_actor_view< TraitOrSignature >	Decorates a pointer to a scheduled_actor with a statically typed actor interface
►Ccaf::typed_actor_view_base	Tag type for typed_actor_view
Ccaf::typed_actor_pointer< TraitOrSignature >	Provides a view to an actor that implements this messaging interface without knowledge of the actual type
Ccaf::typed_response_promise< Ts >	Enables statically typed actors to delay a response message by capturing the context of a request message
Ccaf::unordered_flat_map< Key, T, Allocator >	A map abstraction with an unsorted std::vector providing O(n) lookup
Ccaf::unordered_flat_map< caf::message_id, multiplexed_response >
Ccaf::unordered_flat_map< std::string, std::string >
Ccaf::unsafe_behavior_init_t	Empty struct tag for constructing a typed behavior from an untyped behavior
Ccaf::uri::authority_type	Bundles the authority component of the URI, i.e., userinfo, host, and port
Ccaf::uri::userinfo_type	Userinfo subcomponent of the authority component
Ccaf::version	Provides version information for CAF
Ccaf::weak_ref_t	Tag type to indicate that the system should keep a weak reference to an actor
Ccaf::weak_self_ref_t	Tag type to indicate that the system should keep a weak reference to an actor after passing it the self pointer