Namespace List

Here is a list of all documented namespaces with brief descriptions:

[detail level 12345]

►Ncaf	Root namespace of libcaf
Nexit_reason	Contains all predefined exit reasons
►Nio	Contains all IO-related classes and functions
►Nbasp	Contains all classes and functions for the Binary Actor System Protocol
Cheader	The header of a Binary Actor System Protocol (BASP) message
►Cinstance	Describes a protocol instance managing multiple connections
Ccallee	Provides a callback-based interface for certain BASP events
►Cmessage_queue	Enforces strict order of message delivery, i.e., deliver messages in the same order as if they were deserialized by a single thread
Cactor_msg	Request for sending a message to an actor at a later time
►Crouting_table	Stores routing information for a single broker participating as BASP peer and provides both direct and indirect paths
Croute	Describes a routing path to a node
Cworker	Deserializes payloads for BASP messages asynchronously
►Nnetwork	Contains classes and functions used for network abstraction
Cacceptor	An acceptor is responsible for accepting incoming connections
Cacceptor_impl	A concrete acceptor with a technology-dependent policy
Cacceptor_manager	An acceptor manager configures an acceptor and provides callbacks for incoming connections as well as for error handling
Cdatagram_handler_impl	A concrete datagram_handler with a technology-dependent policy
Cdatagram_manager	A datagram manager provides callbacks for outgoing datagrams as well as for error handling
Cdatagram_servant_impl	Default datagram servant implementation
Cdoorman_impl	Default doorman implementation
►Cevent_handler	A socket I/O event handler
Cstate	Stores various status flags and user-defined config parameters
Cinterfaces	Utility class bundling access to network interface names and addresses
Cip_endpoint	A hashable wrapper for a sockaddr storage
Cmanager	A manager configures an I/O device and provides callbacks for various I/O operations
►Cmultiplexer	Low-level backend for IO multiplexing
Crunnable	Simple wrapper for runnables
Csupervisor	Makes sure the multiplier does not exit its event loop until the destructor of supervisor has been called
Cpipe_reader	An event handler for the internal event pipe
Cprotocol	Bundles protocol information for network and transport layer communication
Creceive_buffer	A container that does not call constructors and destructors for its values
Cscribe_impl	Default scribe implementation
Cstream	A stream capable of both reading and writing
Cstream_impl	A concrete stream with a technology-dependent policy for sending and receiving data from a socket
Cstream_manager	A stream manager configures an IO stream and provides callbacks for incoming data as well as for error handling
Cabstract_broker	A broker mediates between actor systems and other components in the network
Caccept_handle	Generic handle type for managing incoming connections
Cacceptor_closed_msg	Signalizes that a broker acceptor has been closed
Cacceptor_passivated_msg	Signalizes that an acceptor has entered passive mode
Cbasp_broker	A broker implementation for the Binary Actor System Protocol (BASP)
Cbroker	Describes a dynamically typed broker
Cbroker_servant	Base class for scribe and doorman
Cconnection_closed_msg	Signalizes that a broker connection has been closed
Cconnection_handle	Generic handle type for identifying connections
Cconnection_passivated_msg	Signalizes that a connection has entered passive mode
Cdata_transferred_msg	Signalizes that a certain amount of bytes has been written
Cdatagram_handle	Generic handle type for identifying datagram endpoints
Cdatagram_sent_msg	Signalizes that a datagram with a certain size has been sent
Cdatagram_servant	Manages writing to a datagram sink
Cdatagram_servant_closed_msg	Signalizes that a datagram endpoint has entered passive mode
Cdatagram_servant_passivated_msg	Signalizes that a datagram sink has entered passive mode
Cdoorman	Manages incoming connections
►Cmiddleman	Manages brokers and network backends
Cbackground_task	Independent tasks that run in the background, usually in their own thread
Cmetric_singletons_t	Metrics that the middleman collects by default
Cmiddleman_actor_impl	Default implementation of the middleman_actor interface
Cnew_connection_msg	Signalizes a newly accepted connection from a broker
Cnew_data_msg	Signalizes newly arrived data for a broker
Cnew_datagram_msg	Signalizes that a datagram with a certain size has been sent
Cscribe	Manages a stream
Ctyped_broker	A typed broker mediates between actor systems and other components in the network
►Nmixin	Contains mixin classes implementing several actor traits
Crequester	A requester is an actor that supports self->request(...)
Csender	A sender is an actor that supports self->send(...)
►Nnet	Contains all classes and functions related to network protocols
►Ndsl	Contains building blocks to assemble protocol stacks in a declarative way
Cbase	Base type for our DSL classes to configure a factory object
►Cclient_config	Wraps configuration parameters for starting clients
Cconn	Configuration for a client that uses an already established SSL connection
Clazy	Configuration for a client that creates the socket on demand
Csocket	Configuration for a client that uses a user-provided socket
Cclient_config_tag	Meta programming utility
Cclient_factory_base	Base type for client factories for use with has_connect
Cconfig_base	Base class for configuration objects
►Cgeneric_config	Wraps configuration of some base parameters before we know whether the user is starting a client or a server
Clazy	Configuration for a client that creates the socket on demand
Cgeneric_config_tag	Meta programming utility
Cget_name	Meta programming utility for accessing the name of a type
Chas_accept	DSL entry point for creating a server
Chas_connect	DSL entry point for creating a client
Chas_context	DSL entry point for creating a server
Chas_lazy_context	DSL entry point for postponing the creation of a ssl context, if and when needed by the protocol
Chas_make_ctx	Configuration for an endpoint that stores a SSL context factory for secure networking
Chas_uri_connect	DSL entry point for creating a client from an URI
Cserver_address	Simple type for storing host and port information for reaching a server
►Cserver_config	Wraps configuration parameters for starting clients
Clazy	Configuration for a server that creates the socket on demand
Csocket	Configuration for a server that uses a user-provided socket
Cserver_config_tag	Meta programming utility
Cserver_factory_base	Base type for server factories for use with can_accept
►Nhttp	Contains an implementation for HTTP
Carg_parser	Customization point for adding custom types to the <arg> parsing of the router
Casync_client	HTTP client for sending requests and receiving responses via promises
Cclient	Implements the client part for the HTTP Protocol as defined in RFC 7231
Cclient_factory	Factory for the with(...).connect(...).request(...) DSL
Cheader	Encapsulates meta data for HTTP header fields
Clower_layer	Parses HTTP requests and passes them to the upper layer
Crequest	Implicitly shared handle type that represents an HTTP client request with a promise for the HTTP response
Crequest_header	Encapsulates meta data for HTTP requests
►Cresponder	Responds to an HTTP request at the server
Cpromise	Allows users to respond to an incoming HTTP request at some later time
Cpromise_state	Implementation detail for promise
Cresponse	Handle type (implicitly shared) that represents an HTTP server response
Cresponse_header	Encapsulates meta data for HTTP response
Croute	Represents a single route for HTTP requests at a server
Crouter	Sits on top of a server and dispatches incoming requests to user-defined handlers
Cserver	Implements the server part for the HTTP Protocol as defined in RFC 7231
Cserver_factory	Factory type for the with(...).accept(...).start(...) DSL
Cupper_layer	Operates on HTTP requests
Cwith_t	Entry point for the with(...) DSL
►Nlp	Contains an implementation for message exchange over length-prefix framing
Cbase_config	Configuration for the with_t DSL entry point
Cclient_factory	Factory for the with(...).connect(...).start(...) DSL
Cframing	Implements length-prefix framing for discretizing a Byte stream into messages of varying size
Clower_layer	Provides access to a resource that operates on the granularity of binary messages
Cserver_config	The configuration for a length-prefix framing server
►Cserver_factory	Factory type for the with(...).accept(...).start(...) DSL
Cconfig_impl	The configuration for a length-prefix framing server
Cupper_layer	Consumes lp messages from the lower layer
Cwith_t	Entry point for the with(...) DSL
►Noctet_stream	Contains classes and utilities for transports that operate on raw octets
Cclient_factory	Factory for the with(...).connect(...).start(...) DSL
Clower_layer	Provides access to a resource that operates on a byte stream, e.g., a TCP socket
Cpolicy	Configures a transport object
Cupper_layer	The upper layer requests bytes from the lower layer and consumes raw chunks of data
Cwith_t	Entry point for the with(...) DSL
►Nprometheus	Contains a scraper for exposing metrics from an actor system to Prometheus
Cscrape_state	State for scraping Metrics data
►Nssl	Contains wrappers for convenient access to SSL
Cconnection	SSL state for a single connections
Ccontext	SSL state, shared by multiple connections
Ctcp_acceptor	Wraps a TCP accept socket and an SSL context
Ctransport	Implements a octet stream transport that manages a stream socket with encrypted communication over TLS
►Nweb_socket	Contains an implementation for message exchange over the WebSocket protocol
Cacceptor	Accepts or rejects incoming connection requests
Cclient	Implements the client part for the WebSocket Protocol as defined in RFC
Cclient_factory	Factory for the with(...).connect(...).start(...) DSL
Cframe	An implicitly shared type for passing along WebSocket data frames, i.e., text or binary frames
Cframing	Implements the WebSocket framing protocol as defined in RFC-6455
Chandshake	Wraps state and algorithms for the WebSocket client handshake as defined in RFC 6455
Chas_on_request	DSL entry point for creating a server
Cis_acceptor	Type trait that determines if a type is an acceptor
Cis_acceptor< acceptor< Ts... > >	Specialization of is_acceptor for acceptor types
Clower_layer	Produces text and binary messages for the upper layer
Cserver	Implements the server part for the WebSocket Protocol as defined in RFC
Cserver_factory	Factory type for the with(...).accept(...).start(...) DSL
►Cserver_factory_base	Factory type for the with(...).accept(...).start(...) DSL
Cconfig_impl	The configuration for a WebSocket server
Cswitch_protocol_bind_1	DSL entry point for creating a server
Cswitch_protocol_bind_2	Binds a switch_protocol invocation to a function object for on_request
Cupper_layer	Consumes text and binary messages from the lower layer
Cwith_t	Entry point for the with(...) DSL
Cactor_shell	Enables socket managers to communicate with actors using dynamically typed messaging
Cactor_shell_ptr	An "owning" pointer to an actor shell in the sense that it calls quit() on the shell when going out of scope
Cdatagram_socket	A datagram-oriented network communication endpoint
Cgeneric_lower_layer	Bundles protocol-independent, generic member functions for (almost all) lower layers
Cgeneric_upper_layer	Bundles protocol-independent, generic member functions for (almost all) upper layers
Cmiddleman	Provides a network backend for running protocol stacks
Cmultiplexer	Multiplexes any number of socket_manager objects with a socket
Cnetwork_socket	A bidirectional network communication endpoint
Cpipe_socket	A unidirectional communication endpoint for inter-process communication
Creceive_policy	Configures how many bytes an octet stream transport receives before calling consume on its upper layer
Csocket	An internal endpoint for sending or receiving data
Csocket_event_layer	The lowest layer in a protocol stack
Csocket_guard	Closes the guarded socket when destroyed
Csocket_manager	Manages the lifetime of a single socket and handles any I/O events on it
Cstream_socket	A connection-oriented network communication endpoint for bidirectional byte streams
Ctcp_accept_socket	Represents a TCP acceptor in listening mode
Ctcp_stream_socket	Represents a TCP connection
Cthis_host	Groups functions for managing the host system
Ctyped_actor_shell< T1, T2, Ts... >	Enables socket managers to communicate with actors using statically typed messaging
Ctyped_actor_shell< TraitOrSignature >	Enables socket managers to communicate with actors using statically typed messaging
Ctyped_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
Ctyped_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
Cudp_datagram_socket	A datagram-oriented network communication endpoint for bidirectional byte transmission
►Npolicy	Contains policies encapsulating characteristics or algorithms
Carg	Provides a wrapper to pass policy types as values to functions
Cselect_all	Enables a response_handle to fan-in all responses messages into a single result (a vector that stores all received results)
Cselect_any	Enables a response_handle to pick the first arriving response, ignoring all other results
Csingle_response	Trivial policy for handling a single result in a response_handler
Ctcp	Policy object for wrapping default TCP operations
Cudp	Policy object for wrapping default UDP operations
►Ntelemetry	Contains classes and functions for collecting telemetry data
Ccounter	A metric that represents a single value that can only go up
Cdbl_gauge	A metric that represents a single integer value that can arbitrarily go up and down
Chistogram	Represent aggregatable distributions of events
Cint_gauge	A metric that represents a single integer value that can arbitrarily go up and down
Clabel	An (immutable) key-value pair for adding extra dimensions to metrics
Cmetric	A single metric, identified by the values it sets for the label dimensions
Cmetric_family	Manages a collection (family) of metrics
►Cmetric_registry	Manages a collection of metric families
Cspan_type	Forces the compiler to use the type span<const T> instead of trying to match parameters to a span
Ctimer	Convenience helper for measuring durations such as latency using a histogram with second resolution
Cabstract_actor	Base class for all actor implementations
Cabstract_blocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Cabstract_mailbox	The base class for all mailbox implementations
Cabstract_scheduled_actor	A cooperatively scheduled, event-based actor implementation
►Caction	A functional interface similar to std::function<void()> with dispose semantics
Cimpl	Internal interface of action
Cactor	Identifies an untyped actor
Cactor_addr	Stores the address of typed as well as untyped actors
Cactor_clock	A monotonic clock for scheduling timeouts and delayed messages
Cactor_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
Cactor_config	Stores spawn-time settings and flags
Cactor_control_block	Actors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it
Cactor_from_state_t	Helper class for automating the creation of an event-based actor with managed state
Cactor_ostream	Provides support for thread-safe output operations on character streams
Cactor_pool	An actor poool is a lightweight abstraction for a set of workers
Cactor_proxy	Represents an actor running on a remote machine, or different hardware, or in a separate process
Cactor_registry	A registry is used to associate actors to IDs or names
►Cactor_system	Actor environment including scheduler, registry, and optional components such as a middleman
Cactor_metric_families_t	Metrics that some actors may collect in addition to the base metrics
Cbase_metrics_t	Metrics that the actor system collects by default
Cglobal_state_guard	Calls a cleanup function in its destructor for cleaning up global state
Cnetworking_module	An (optional) component of the actor system with networking capabilities
Cactor_system_config	Configures an actor_system on startup
Cactor_system_module	An (optional) component of the actor system
Cactor_traits	Provides uniform access to properties of actor types
Callowed_unsafe_message_type	Template specializations can whitelist individual types for unsafe message passing operations
Canon_mail_t	Provides a fluent interface for sending anonymous messages to actors
Canon_scheduled_mail_t	Provides a fluent interface for sending anonymous messages to actors at a specific point in time
Casync_mail_base_t	Provides a fluent interface for sending asynchronous messages to actors
Casync_mail_t	Provides a fluent interface for sending asynchronous messages to actors
Casync_scheduled_mail_t	Provides a fluent interface for sending asynchronous messages to actors at a specific point in time
►Cattachable	Callback utility class
Ctoken	Represents a pointer to a value with its subtype as type ID number
Cbasic_cow_string	A copy-on-write string implementation that wraps a std::basic_string
Cbehavior	Describes the behavior of an actor, i.e., provides a message handler and an optional timeout
Cbinary_deserializer	Deserializes C++ objects from sequence of bytes
Cbinary_serializer	Serializes C++ objects into a sequence of bytes
►Cblocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Caccept_one_cond	Pseudo receive condition modeling a single receive
Cdo_receive_helper	Implementation helper for blocking_actor::do_receive
Creceive_cond	Represents pre- and postconditions for receive loops
Creceive_for_helper	Implementation helper for blocking_actor::receive_for
Creceive_while_helper	Implementation helper for blocking_actor::receive_while
Cblocking_actor_base	Marker type for blocking actors
Cblocking_delayed_response_handle	Similar to blocking_response_handle, but also holds the disposable for the delayed request message
Cblocking_mail_t	Provides a fluent interface for sending asynchronous messages to actors
Cblocking_response_handle	This helper class identifies an expected response message and enables request(...).then(...)
Cblocking_response_handle< message >	This helper class identifies an expected response message and enables request(...).then(...)
Cblocking_response_handle_state	Holds state for a blocking response handles
Cblocking_scheduled_mail_t	Provides a fluent interface for sending asynchronous messages to actors at a specific point in time
Cbyte_address	Base type for addresses based on a byte representation such as IP or Ethernet addresses
Ccallback	Describes a simple callback, usually implemented via lambda expression
Ccallback_impl	Utility class for wrapping a function object of type F
Cchunk	An implicitly shared type for binary data
Cchunked_string	Represents a chunked string as a linked list of string views
Cchunked_string_builder	Builds a chunked string by allocating each chunk on a monotonic buffer
Cchunked_string_builder_output_iterator	An output iterator that appends characters to a linked string chunk builder
►Cconfig_option	Defines a configuration option for the application
Cfind_result	Stores the result of a find operation
Cmeta_state	Custom vtable-like struct for delegating to type-specific functions and storing type-specific information shared by several config options
Cconfig_option_adder	Adds config options of the same category to a config_option_set
Cconfig_option_set	A set of config_option objects that parses CLI arguments into a settings object
Cconfig_value	A type for config parameters with similar interface to a variant
Cconfig_value_reader	Extracts objects from a config_value
Cconfig_value_writer	Serializes an objects into a config_value
Ccow_tuple	A copy-on-write tuple implementation
Ccow_vector	A copy-on-write vector implementation that wraps a std::vector
Cdeep_to_string_t	Wraps deep_to_string into a function object
Cdefault_actor_traits	Default implementation of actor_traits for non-actors (SFINAE-friendly)
Cdefault_actor_traits< T, true >	Default implementation of actor_traits for regular actors
Cdefault_type_id_mapper	Dispatches to query_type_name and query_type_id
Cdelegated	Helper class to indicate that a request has been forwarded
Cdeserializer	Technology-independent deserialization interface
Cdictionary	Maps strings to values of type V, but unlike std::map<std::string, V> accepts std::string_view for looking up keys efficiently
►Cdisposable	Represents a disposable resource
Cimpl	Internal implementation class of a disposable
Cdown_msg	Sent to all actors monitoring an actor when it is terminated
Cdynamically_typed	Tag type to indicate that the sender of a message is a dynamically typed actor
Cdynamically_typed_actor_base	Marker type for dynamically typed actors
Cerror	A serializable type for storing error codes with category and optional, human-readable context information
Cerror_code	A lightweight wrapper around an error code enum
Cevent_based_actor	A cooperatively scheduled, event-based actor implementation
Cevent_based_delayed_response_handle	Similar to event_based_response_handle, but also holds the disposable for the delayed request message
Cevent_based_mail_t	Provides a fluent interface for sending asynchronous messages to actors
Cevent_based_mtl	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
Cevent_based_response_handle	This helper class identifies an expected response message and enables request(...).then(...)
Cevent_based_response_handle< message >	This helper class identifies an expected response message and enables request(...).then(...)
Cevent_based_response_handle_state	Holds state for a event-based response handles
Cevent_based_scheduled_mail_t	Provides a fluent interface for sending asynchronous messages to actors at a specific point in time
Cexit_msg	Sent to all links when an actor is terminated
Cexpected	Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error
Cexpected< void >	The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool
Cextend	Allows convenient definition of types using mixins
Cformat_string_with_location	Wraps a format string and its source location
Cforwarding_actor_proxy	Implements a simple proxy forwarding all operations to a manager
Cfunction_view	A function view for an actor hides any messaging from the caller
Cget_or_auto_deduce	Configures get_or to uses the get_or_deduction_guide
Cget_or_deduction_guide	Customization point for configuring automatic mappings from default value types to deduced types
Chandle	Base class for IO handles such as accept_handle or connection_handle
Cignore_case_t	Tag type for selecting case-insensitive algorithms
Cillegal_message_element	Marker class identifying classes in CAF that are not allowed to be used as message element
Cinfer_handle_from_class	Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced
Cinfer_handle_from_fun_trait	Deduces an actor handle type from a function or function object
Cinspector_access	Customization point for adding support for a custom type
Cinspector_access_base	Provides default implementations for save_field and load_field
►Cinspector_access_type	Wraps tag types for static dispatching
Cbuiltin	Flags types with builtin support of the inspection API
Cbuiltin_inspect	Flags types with builtin support via Inspector::builtin_inspect
Cempty	Flags stateless message types
Cinspect	Flags types that provide an inspect() overload
Clist	Flags types with std::vector-like API
Cmap	Flags types with std::map-like API
Cnone	Flags types without any default access
Cspecialization	Flags types that provide an inspector_access specialization
Ctuple	Flags types with std::tuple-like API
Cunsafe	Flags allowed unsafe message types
Cintrusive_cow_ptr	An intrusive, reference counting smart pointer implementation with copy-on-write optimization
Cintrusive_ptr	An intrusive, reference counting smart pointer implementation
Cintrusive_ptr_access	Policy for adding and releasing references in an intrusive_ptr
Cipv4_endpoint	An IP endpoint that contains an ipv4_address and a port
Cipv6_endpoint	An IP endpoint that contains an ipv6_address and a port
Cis_actor_handle	Checks whether T is an actor or a typed_actor<...>
Cis_error_code_enum	Customization point for enabling conversion from an enum type to an error or error_code
Cis_typed_actor	Evaluates to true if T is a typed_actor<...>
Cis_variant_wrapper	Customization point
Cjson_array	Represents a JSON array
Cjson_builder	Serializes an inspectable object to a json_value
Cjson_object	Represents a JSON object
Cjson_reader	Deserializes an inspectable object from a JSON-formatted string
Cjson_value	Represents an immutable JSON value
Cjson_writer	Serializes an inspectable object to a JSON-formatted string
Cload_inspector	Base type for inspectors that load objects from some input source
►Clocal_actor	Base class for actors running on this node, either living in an own thread or cooperatively scheduled
Cinbound_stream_metrics_t	Optional metrics for inbound stream traffic collected by individual actors when configured to do so
Cmetrics_t	Optional metrics collected by individual actors when configured to do so
Coutbound_stream_metrics_t	Optional metrics for outbound stream traffic collected by individual actors when configured to do so
►Clogger	Centrally logs events from all actors in an actor system
Centrypoint	Provides an API entry point for sending a log event to the current logger
Cline_builder	Utility class for building user-defined log messages with CAF_ARG
Ctrace_exit_guard	Helper class to print exit trace messages on scope exit
Cmail_cache	A simple cache for storing mailbox elements for an actor for later reuse
Cmessage	Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type
Cmessage_builder	Provides a convenient interface for creating message objects from a series of values using the member function append
Cmessage_handler	A partial function implementation used to process a message
Cmessage_id	Bundles various flags along with an optional request ID
Cnode_down_msg	Sent to all actors monitoring a node when CAF loses connection to it
Cnode_id	A node ID is an opaque value for representing CAF instances in the network
Cnon_blocking_actor_base	Marker type for non-blocking actors
Cnone_t	Represents "nothing", e.g., for clearing an optional by assigning none
Conce_t	Tag type to indicate that an operation should take place only once
Coptional_inspector_access	Provides inspector access for types that represent optional values
Cparser_state	Stores all information necessary for implementing an FSM-based parser
Cpartial_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
►Cproxy_registry	Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages
Cbackend	Responsible for creating proxy actors
Cref_counted	Base class for reference counted objects with an atomic reference count
Crepeat_t	Tag type to indicate that an operation should be repeated
Cresponse_handle	This helper class identifies an expected response message and enables request(...).then(...)
Cresponse_promise	Enables actors to delay a response message by capturing the context of a request message
Cresponse_type	Defines:
Cresponse_type_unbox	Unboxes Xs and calls response_type
Cresult	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
Cresult_base	Base type for all specializations of result
Cresumable	A cooperatively scheduled entity
Csave_inspector	Base type for inspectors that save objects to some output sink
Cscheduler	A scheduler is responsible for managing the execution of resumables
Cscoped_actor	A scoped handle to a blocking actor
Cserializer	Technology-independent serialization interface
Cskip_t	Default handler function that leaves messages in the mailbox
Cskippable_result	Similar to result<message>, but also allows to skip a message
Cspan	A C++11/14 drop-in replacement for C++20's std::span without support for static extents
Cstateful_actor	An event-based actor with managed state
Cstatically_typed	A statically typed trait type wrapping the given parameter pack of signatures as a type list
Cstatically_typed_actor_base	Marker type for statically typed actors
Cstream	Provides access to a potentially unbound sequence of items emitted by an actor
Cstream_abort_msg	Informs the sink that a stream has been aborted due to an unrecoverable error
Cstream_ack_msg	Informs the sink that the source has added it to the flow
Cstream_batch_msg	Transfers items from a source to a sink
Cstream_cancel_msg	Informs the source that the sender is no longer interest in receiving items from this stream
Cstream_close_msg	Informs the sink that a stream has reached the end
Cstream_demand_msg	Asks the source for more data
Cstream_open_msg	Asks a source to add another sink
Cstrong_ref_t	Tag type to indicate that the system should keep a strong reference to an actor
Cstrong_self_ref_t	Tag type to indicate that the system should keep a strong reference to an actor after passing it the self pointer
Cthread_hook	Interface to define thread hooks
Ctimeout_msg	Signals a timeout to an actor
Ctype_by_id	Maps the globally unique ID V to a type (inverse to type_id)
Ctype_id	Maps the type T to a globally unique ID
Ctype_id_list	A list of type IDs, stored in a size-prefix, contiguous memory block
Ctype_id_mapper	Translates between human-readable type names and type IDs
Ctype_list	A list of types
Ctype_name	Convenience type that resolves to type_name_by_id<type_id_v<T>>
Ctype_name< void >	Convenience specialization that enables generic code to not treat void manually
Ctype_name_by_id	Maps the globally unique ID V to a type name
Ctyped_actor< T1, T2, Ts... >	Identifies a statically typed actor
Ctyped_actor< TraitOrSignature >	Identifies a statically typed actor
Ctyped_actor_pointer< T1, T2, Ts... >	Provides a view to an actor that implements this messaging interface without knowledge of the actual type
Ctyped_actor_pointer< TraitOrSignature >	Provides a view to an actor that implements this messaging interface without knowledge of the actual type
Ctyped_actor_view< T1, T2, Ts... >	Decorates a pointer to a scheduled_actor with a statically typed actor interface
Ctyped_actor_view< TraitOrSignature >	Decorates a pointer to a scheduled_actor with a statically typed actor interface
Ctyped_actor_view_base	Tag type for typed_actor_view
Ctyped_event_based_actor< T1, T2, Ts... >	A cooperatively scheduled, event-based actor implementation with static type-checking
Ctyped_event_based_actor< TraitOrSignature >	A cooperatively scheduled, event-based actor implementation with static type-checking
Ctyped_response_promise	Enables statically typed actors to delay a response message by capturing the context of a request message
Ctyped_stream	Provides access to a statically typed, potentially unbound sequence of items emitted by an actor
Cunit_t	Unit is analogous to void, but can be safely returned, stored, etc
Cunordered_flat_map	A map abstraction with an unsorted std::vector providing O(n) lookup
Cunsafe_behavior_init_t	Empty struct tag for constructing a typed behavior from an untyped behavior
►Curi	A URI according to RFC 3986
Cauthority_type	Bundles the authority component of the URI, i.e., userinfo, host, and port
Cuserinfo_type	Userinfo subcomponent of the authority component
Cuuid	A universally unique identifier according to RFC 4122
Cversion	Provides version information for CAF
Cweak_intrusive_ptr	An intrusive, reference counting smart pointer implementation
Cweak_ref_t	Tag type to indicate that the system should keep a weak reference to an actor
Cweak_self_ref_t	Tag type to indicate that the system should keep a weak reference to an actor after passing it the self pointer
Nstd	STL namespace