Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►Ncaf	Root namespace of libcaf
►Nasync
Cbatch	A reference-counted, type-erased container for transferring items from producers to consumers
Cblocking_consumer	Blocking interface for emitting items to an asynchronous consumer
Cblocking_producer	Blocking interface for emitting items to an asynchronous consumer
Cbound_future	Provides an interface for accessing the result of an asynchronous computation on an asynchronous execution_context
Cconsumer	Base type for asynchronous consumers of an event source
Cconsumer_adapter	Integrates an SPSC buffer consumer into an asynchronous event loop
Cconsumer_resource	Grants read access to the first consumer that calls open on the resource
Cdelay_errors_t	Policy type for having consume call on_error only after processing all items from the buffer
Cexecution_context	Represents a single execution context with an internal event-loop to schedule action objects
Cfile	Bundles factories for asynchronous sources and sinks that operate on files
Cfuture	Represents the result of an asynchronous computation
Cprioritize_errors_t	Policy type for having consume call on_error immediately after the producer has aborted even if the buffer still contains items
Cproducer	Base type for asynchronous producers of events
Cproducer_adapter	Integrates an SPSC buffer producer into an asynchronous event loop
Cproducer_resource	Grants access to a buffer to the first producer that calls open
Cpromise	Provides a facility to store a value or an error that is later acquired asynchronously via a future object
Cpublisher	Provides an interface for accessing an asynchronous data flow
Csource_runner	Helper class to run an asynchronous source
►Cspsc_buffer	A Single Producer Single Consumer buffer
Cflags	Packs various status flags for the buffer into a single struct
►Nchrono
Cdatetime	Represents a point in time, expressed as a date and time of day
Cfixed	Tag type for converting timestamps to strings with a fixed number of fractional digits
►Ndefaults
Cparameter	Stores the name of a parameter along with the fallback value
►Ndetail
Cabstract_worker_hub	A central place where workers return to after finishing a task
Caccepts_opaque_value	Checks whether the inspector has an opaque_value overload for T
Cactor_system_access	Utility to override internal components of an actor system
Calways_false	Utility for fallbacks calling static_assert
Calways_true_t	Utility class for predicates that always return true
Casync_cell	Implementation detail for async::future and async::promise
Catomic_ref_counted	Base class for reference counted objects with an atomic reference count
Ccallable_trait	Defines result_type, arg_types, and fun_type
Ccomparable	Barton–Nackman trick implementation
Cconfig_consumer	Consumes a series of key-value pairs from an application configuration
Cconfig_list_consumer	Consumes a list of config values
Cconfig_value_consumer	Consumes a single configuration value
Cconnection_acceptor	Accepts incoming connections and creates a socket manager for each
Cconnection_factory	Creates new socket managers for an accept_handler
Cconsumer	Consumes a single value
Cconsumer< int64_t >	Specializes consumer for int64_t with a safe conversion from uint64_t
Cconsumer< uint64_t >	Specializes consumer for uint64_t with a safe conversion from int64_t
Ccontainer_view	Decorates a container of type T to appear as container of type U
Cdefault_mailbox	Our default mailbox implementation
Cfile_reader	A generator that emits characters or bytes from a file
Cflow_bridge_initializer	Initializes the inputs and outputs of a flow bridge
Cget_callable_trait	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
Chas_builtin_inspect	Checks whether the inspector has a builtin_inspect overload for T
Chas_init_host_system	Checks whether T has a static member function called init_host_system
Chas_inspect_overload	Checks whether T provides an inspect overload for Inspector
Chas_to_string	Checks whether T defines a free function to_string
Chttp_catch_all_route_impl	Represents an HTTP route that matches any path
Chttp_route_base	Base type for HTTP routes that parse one or more arguments from the requests and then forward them to a user-provided function object
Chttp_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
Cil_indices	Creates indices for List beginning at Pos
Cinit_fun_factory_helper	Wraps a user-defined function and gives it a uniform signature
Cint_list	A list of integers (wraps a long... template parameter pack)
Cint_types_by_size	Compile-time list of integer types types
Cinvoke_result_visitor	Inspects the result of message handlers and triggers type-depended actions such as generating result messages
Cis_behavior	Checks whether T is a behavior or typed_behavior
Cis_builtin_inspector_type	Checks whether T is primitive, i.e., either an arithmetic type or convertible to one of STL's string types
Cis_callable	Checks whether T is a function, function object or member function
Cis_comparable	Checks whether T1 is comparable with T2
Cis_forward_iterator	Checks whether T behaves like a forward iterator
Cis_handler_for	Checks whether F is convertible to either std::function<void (T&)> or std::function<void (const T&)>
Cis_iterable	Checks whether T has begin() and end() member functions returning forward iterators
Cis_list_like	Checks whether T behaves like std::vector, std::list, or std::set
Cis_map_like	Checks whether T behaves like std::map
Cis_mutable_ref	Checks whether T is a non-const reference
Cis_one_of	Checks whether T is in the template parameter pack Ts
Cis_optional	Checks whether T is a std::optional
Cis_pair	Utility trait for checking whether T is a std::pair
Cis_primitive	Checks whether T is primitive, i.e., either an arithmetic type or convertible to one of STL's string types
Cis_publisher	Checks whether T is a publisher
Cis_stl_tuple_type	Evaluates to true for all types that specialize std::tuple_size, i.e., std::tuple, std::pair, and std::array
Cis_stream	Checks whether T is a stream or typed_stream
Cleft_oracle	Always evaluates to Left
Clog_level_map	Maps log levels to their names
Cmailbox_factory	The base class for all mailbox implementations
Cmessage_builder_element	Wraps a value for either copying or moving it into a pre-allocated storage later
Cmessage_data	Container for storing an arbitrary number of message elements
Cmeta_object	Enables destroying, constructing and serializing objects through type-erased pointers
Cmonitor_action	A thread safe single shot action encapsulating a function and a function argument error
►Cmonotonic_buffer_resource	Replacement for std::pmr::monotonic_buffer_resource, which sadly is not available on all platforms CAF currently supports
Cblock	A single block of memory
Cbucket	A bucket for storing multiple blocks
Cnormalize_newlines_step	Converts "\r\n" and "\r" to "\n"
Cplain_ref_counted	Base class for reference counted objects with an plain (i.e., thread-unsafe) reference count
Cprint_iterator_adapter	Wraps an output iterator to provide a push_back and insert member functions for using the print algorithms
Cprometheus_broker	Makes system metrics in the Prometheus format available via HTTP 1.1
Crfc3629	Wraps functions for processing RFC 3629 encoding, i.e., UTF-8
Cring_buffer	A simple ring buffer implementation
Cscope_guard	A lightweight scope guard implementation
Csingle_arg_wrapper	Enables automagical string conversion for CAF_ARG
Csplit_as_utf8_at_step	Turns a sequence of bytes into a sequence of cow_string based on separator
Csplit_at_step	Turns a sequence of bytes into a sequence of chunks based on separator
Csquashed_int	Squashes integer types into [u]int_[8|16|32|64]_t equivalents
Cstateful_actor_base	Conditional base type for stateful_actor that overrides make_behavior if State::make_behavior() exists
Cstatic_error_printer	Generates an error using static_assert on an interface mismatch
Csync_request_bouncer	Consumes mailbox elements and sends an error message for each request
Ctl_apply	Applies the types of the list to VarArgTemplate
Ctl_at< type_list< E... >, N >	Gets element at index N of List
Ctl_back	Gets the last element in List
Ctl_exists	Tests whether a predicate holds for some of the elements of a list
Ctl_filter< type_list< Ts... >, Pred >	Create a new list containing all elements which satisfy Pred
Ctl_filter_not< type_list< Ts... >, Pred >	Create a new list containing all elements which satisfy Pred
Ctl_forall	Tests whether a predicate holds for all elements of a list
Ctl_head	Gets the first element of List
Ctl_index_of	Finds the first element satisfying Pred beginning at index Pos
Ctl_index_of_impl	Finds the first element of type What beginning at index Pos
Ctl_is_distinct	Tests whether a list is distinct
Ctl_map	Creates a new list by applying a "template function" to each element
Ctl_replace_back	Creates a new list with all but the last element of List and append T to the new list
Ctl_size	Gets the number of template parameters of List
Ctl_subset_of	Evaluates to true if ListA is a subset of ListB, i.e., if all elements in ListA are also in ListB
Cto_chars_step	Turns a sequence of strings into a sequence of characters
Cto_chunks_step	Turns a sequence of bytes into a sequence of chunks
Cto_lines_step	Turns a sequence of characters into a sequence of lines
Cunique_function	A move-only replacement for std::function
►Nflow
►Ngen
Cempty	A generator that emits nothing and calls on_complete immediately
Cfrom_callable	A generator that emits values from a function object
Cfrom_container	A generator that emits values from a vector
Ciota	A generator that emits ascending values
Cjust	A generator that emits a single value once
Crepeat	A generator that emits the same value repeatedly
►Nop
Cbase	Abstract base type for all flow operators that implement the observable concept
Ccell_listener	Interface for listening on a cell
Ccell_sub	The subscription object for interfacing an observer with the cell state
Ccell_sub_state	State shared between one multicast operator and one subscribed observer
Ccold	Convenience base type for cold observable types
Cconcat_sub	Combines items from any number of observables
Cdefer	Implementation of the defer operator
Cempty	An observable that represents an empty range
Cfail	Emits an error to the subscriber immediately after subscribing
Cfrom_generator	Converts a Generator to an observable
Cfrom_resource_sub	Reads from an observable buffer and emits the consumed items
Chot	Convenience base type for hot observable types
Cmerge_sub	Receives observables from the pre-merge step and merges their inputs for the observer
Cnever	An observable that never calls any callbacks on its subscribers
Con_backpressure_buffer	An observable that on_backpressure_buffer calls any callbacks on its subscribers
Cprefix_and_tail	Decorates an observable to split its output into a prefix of fixed size plus an observable remainder
Cpublish	Publishes the items from a single operator to multiple subscribers
Cpullable	Base class for operators that allow observers to pull items via request(n)
Csample_sub	The subscription for the sample operator
►Cucast_sub_state	Shared state between an operator that emits values and the subscribed observer
Cabstract_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
Czip_with	Combines items from any number of observables using a zip function
Czip_with_sub	Combines items from any number of observables using a zip function
►Nstep
Cignore_elements	A step that ignores all elements and only forwards calls to on_complete and on_error
Cbuffer_writer_impl	Writes observed values to a bounded buffer
Cbyte	Provides transformations for sequences of bytes
Cconnectable	Resembles a regular observable, except that it does not begin emitting items when it is subscribed to
Ccoordinated	An object that lives on a coordinator
Ccoordinator	Coordinates any number of co-located observables and observers
Cforwarder	Forwards all events to its parent
Cgeneration_materializer	Materializes an observable from a Generator that produces items and any number of processing steps that immediately transform the produced items
Cmulticaster	A multicaster pushes items to any number of subscribers
Cobservable	Represents a potentially unbound sequence of values
Cobservable_builder	Factory for observable objects
Cobservable_def	Captures the definition of an observable that has not materialized yet
►Cobserver	Handle to a consumer of items
Cimpl	Internal interface of an observer
Cobserver_impl_base	Simple base type observer implementations that implements the reference counting member functions with a plain (i.e., not thread-safe) reference count
Csingle	Similar to an observable, but always emits either a single value or an error
Cstring	Provides transformations for strings and sequences of characters
►Csubscription	Controls the flow of items from publishers to subscribers
Cfwd_impl	Default implementation for subscriptions that forward request and cancel to a listener
Cimpl	Internal interface of a subscription
Cimpl_base	Simple base type for all subscription implementations that implements the reference counting member functions
Clistener	Describes a listener to the subscription that will receive an event whenever the observer calls request or cancel
Ctransformation_materializer	Materializes an observable from a source observable and one or more processing steps
►Nhash
Cfnv	Non-cryptographic hash algorithm (variant 1a) named after Glenn Fowler, Landon Curt Noll, and Kiem-Phong Vo
Csha1	US Secure Hash Algorithm 1 (SHA1) as defined in RFC 3174
►Ninternal
Cflow_bridge_base	Translates between a message-oriented transport and data flows
►Nintrusive
Clifo_inbox	An intrusive, thread-safe LIFO queue implementation for a single reader with any number of writers
Clinked_list	A singly-linked list implementation
Csingly_linked	Intrusive base for singly linked types that allows queues to use T with dummy nodes
Cstack	A simple stack implementation with singly-linked nodes
►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
►Nlog
►Cevent	Captures a single event for a logger
Cfield	A single, user-defined field
Cfield_list	A list of user-defined fields
Cevent_fields_builder	Builds list of user-defined fields for a log event
Cevent_sender	Builds a log event by allocating each field on a monotonic buffer and then sends it to the current logger
Ckeep_timestamp_t	Tag type for event::with_message that indicates that the event should keep its original timestamp
Clevel	Provides integer constants for the predefined log levels
►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
►Narg
Ccstring	Represents a null-terminated string or null
Cval	Represents a value of type T or null
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
►Ncollector
Cprometheus	Collects system metrics and exports them to the text-based Prometheus format
►Nimporter
Cprocess	Imports CPU and memory metrics for the current process
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