| ▶Ncaf | Root namespace of libcaf |
| ▶Nio | Contains all IO-related classes and functions |
| ▶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 |
| Casio_acceptor | An acceptor is responsible for accepting incoming connections |
| Casio_multiplexer | A wrapper for the boost::asio multiplexer |
| Casio_stream | A stream capable of both reading and writing |
| 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 |
| 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 multipler 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 |
| Ctcp_policy | Policy object for wrapping default TCP operations |
| Cudp_policy | Policy object for wrapping default UDP operations |
| 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 |
| Chook | Interface to define hooks into the IO layer |
| Cmiddleman | Manages brokers and network backends |
| 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 |
| ▶Nmeta | |
| Cannotation | Type tag for all meta annotations in CAF |
| ▶Nmixin | Contains mixin classes implementing several actor traits |
| Cbehavior_changer | A behavior_changer is an actor that supports self->become(...) and self->unbecome() |
| Crequester | A requester is an actor that supports `self->request(...) |
| Csender | A sender is an actor that supports self->send(...) |
| Csubscriber | A subscriber is an actor that can subscribe to a group via self->join(...) |
| Csubscriber_base | Marker for subscriber |
| ▶Npolicy | Contains policies encapsulating characteristics or algorithms |
| Carg | Provides a wrapper to pass policy types as values to functions |
| Cprofiled | An enhancement of CAF's scheduling policy which records fine-grained resource utiliziation for worker threads and actors in the parent coordinator of the workers |
| ▶Cscheduler_policy | This concept class describes a policy for worker and coordinator of the scheduler |
| Ccoordinator_data | Policy-specific data fields for the coordinator |
| Cworker_data | Policy-specific data fields for the worker |
| Cunprofiled | This class is intended to be used as a base class for actual polices |
| Cwork_sharing | Implements scheduling of actors via work sharing (central job queue) |
| Cwork_stealing | Implements scheduling of actors via work stealing |
| ▶Nscheduler | |
| Cabstract_coordinator | A coordinator creates the workers, manages delayed sends and the central printer instance for aout |
| Ccoordinator | Policy-based implementation of the abstract coordinator base class |
| Cprofiled_coordinator | A coordinator which keeps fine-grained profiling state about its workers and their jobs |
| Ctest_coordinator | A schedule coordinator for testing purposes |
| Cworker | Policy-based implementation of the abstract worker base class |
| Cabstract_actor | Base class for all actor implementations |
| Cabstract_channel | Interface for all message receivers |
| Cabstract_composable_behavior | Marker type that allows CAF to spawn actors from composable states |
| Cabstract_group | A multicast group |
| 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 flags and groups |
| 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_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 atoms (names) |
| ▶Cactor_system | Actor environment including scheduler, registry, and optional components such as a middleman |
| Cmodule | An (optional) component of the actor system |
| Cactor_system_config | Configures an actor_system on startup |
| Callowed_unsafe_message_type | Template specializations can whitelist individual types for unsafe message passing operations |
| Cannotated_stream | Identifies an unbound sequence of messages annotated with the additional handshake arguments emitted to the next stage |
| Carraybuf | A streambuffer abstraction over a fixed array of bytes |
| Catom_constant | Lifts an atom_value to a compile-time constant |
| ▶Cattachable | Callback utility class |
| Ctoken | Represents a pointer to a value with its subtype as type ID number |
| Cbehavior | Describes the behavior of an actor, i.e., provides a message handler and an optional timeout |
| ▶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 |
| Cbroadcast_topic_scatterer | A topic scatterer that delivers data in broadcast fashion to all sinks |
| Cbuffered_scatterer | Mixin for streams with any number of downstreams |
| Ccallback | Describes a simple callback, usually implemented via lambda expression |
| Ccallback_impl | Utility class for wrapping a function object of type Base |
| Ccomposable_behavior | Base type for composable actor states |
| Ccomposable_behavior_base | Generates an interface class that provides operator() |
| Ccomposable_behavior_based_actor | Implementation class for spawning composable states directly as actors |
| Ccomposed_type | Computes the type for f*g (actor composition) |
| ▶Cconfig_option | Helper class to generate config readers for different input types |
| Ctype_name_visitor | Returns a human-readable type name for the visited type |
| Ccontainerbuf | A streambuffer abstraction over a contiguous container |
| Cdata_processor | A data processor translates an object into a format that can be stored or vice versa |
| Cdelegated | Helper class to indicate that a request has been forwarded |
| Cdeserializer | Technology-independent deserialization interface |
| Cdown_msg | Sent to all actors monitoring an actor when it is terminated |
| Cdownstream | Grants access to an output stream buffer |
| Cduration | Time duration consisting of a time_unit and a 64 bit unsigned integer |
| Cempty_type_erased_tuple | |
| Cerror | A serializable type for storing error codes with category and optional, human-readable context information |
| Cevent_based_actor | A cooperatively scheduled, event-based actor implementation |
| Cexecution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler |
| 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 |
| 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 |
| Cfused_scatterer | A scatterer that delegates to any number of sub-scatterers |
| Cgroup_down_msg | Sent to all members of a group when it goes offline |
| Cgroup_module | Interface for user-defined multicast implementations |
| Chandle | Base class for IO handles such as accept_handle or connection_handle |
| Chas_make_error | Evaluates to true if T is an enum with a free function make_error for converting it to an error |
| Cillegal_message_element | Marker class identifying classes in CAF that are not allowed to be used as message element |
| Cinbound_path | State for a path to an upstream actor (source) |
| Cindex_mapping | Marker for representing placeholders at runtime |
| Cinfer_handle_from_class | Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced |
| Cinfer_handle_from_fun | Deduces an actor handle type from a function or function object |
| Cinfinite_t | Represents an infinite amount of timeout for specifying "invalid" timeouts |
| Cintrusive_ptr | An intrusive, reference counting smart pointer implementation |
| Cinvalid_stream_gatherer | Type-erased policy for receiving data from sources |
| Cinvalid_stream_scatterer | Type-erased policy for dispatching data to sinks |
| Cinvalid_stream_t | Marker type for constructing invalid stream objects |
| Cis_same_ish | Compares T to U und evaluates to true_type if either `T == U or if T and U are both integral types of the same size and signedness |
| Cis_typed_actor | Evaluates to true if T is a typed_actor<...> |
| ▶Clogger | Centrally logs events from all actors in an actor system |
| Carg_wrapper | Enables automagical string conversion for CAF_ARG |
| Cevent | Encapsulates a single logging event |
| Cfield | Represents a single format string field |
| Cline_builder | Utility class for building user-defined log messages with CAF_ARG |
| Cmailbox_element_vals | Encapsulates arbitrary data in a message element |
| Cmailbox_element_view | Provides a view for treating arbitrary data as message element |
| Cmemory_managed | This base enables derived classes to enforce a different allocation strategy than new/delete by providing a virtual protected request_deletion() function and non-public destructor |
| ▶Cmessage | Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type |
| Ccli_arg | Stores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback |
| Ccli_res | Stores the result of message::extract_opts |
| Cmessage_builder | Provides a convenient interface for createing 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 | Denotes whether a message is asynchronous or synchronous |
| Cmessage_view | Represents an object pointing to a type_erased_tuple that is convertible to a message |
| Cmonitorable_actor | Base class for all actor implementations |
| Cnamed_actor_config | Stores a flow-control configuration |
| Cno_error_t | Helper class to construct an expected<T> that represents no error |
| Cno_stages_t | Convenience tag type for producing empty forwarding stacks |
| Cnode_id | A node ID consists of a host ID and process ID |
| Cnone_t | Represents "nothing", e.g., for clearing an optional by assigning none |
| Coptional | A C++17 compatible optional implementation |
| Coptional< T & > | Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead |
| ▶Coutbound_path | State for a single path to a sink on a stream_scatterer |
| Cclient_data | Stores information about the initiator of the steam |
| Cparam | Represents a message handler parameter of type T and guarantees copy-on-write semantics |
| Cparam_decay | Convenience struct for remove_param<std::decay<T>> |
| ▶Cproxy_registry | Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages |
| Cbackend | Responsible for creating proxy actors |
| Crandom_gatherer | Pulls data from sources in arbitrary order |
| Crandom_topic_scatterer | A topic scatterer that delivers data to sinks in random order |
| Cratio_to_time_unit_helper | Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes |
| Craw_event_based_actor | A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages |
| Cref_counted | Base class for reference counted objects with an atomic reference count |
| Cremove_param | Unpacks param<T> to T |
| Cresponse_handle | This helper class identifies an expected response message and enables request(...).then(...) |
| Cresponse_promise | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e |
| Cresponse_type | Defines: |
| Cresponse_type_unbox | Unboxes Xs and calls response_type |
| Cresumable | A cooperatively executed task managed by one or more instances of execution_unit |
| Cscheduled_actor | A cooperatively scheduled, event-based actor implementation |
| Cscoped_actor | A scoped handle to a blocking actor |
| Cscoped_execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler |
| Cselect_callback | Utility class for selecting a callback_impl |
| Cserializer | Technology-independent serialization interface |
| Cskip_t | |
| Cspawn_options | Stores options passed to the spawn function family |
| Cstateful_actor | An event-based actor with managed state |
| Cstream | Identifies an unbound sequence of messages |
| Cstream_buffer | The base class for all stream buffer implementations |
| Cstream_deserializer | Implements the deserializer interface with a binary serialization protocol |
| Cstream_edge_impl | Provides a common scaffold for implementations of the stream_gatherer and stream_scatterer interfaces |
| Cstream_gatherer | Type-erased policy for receiving data from sources |
| Cstream_gatherer_impl | Type-erased policy for receiving data from sources |
| Cstream_manager | Manages a single stream with any number of down- and upstream actors |
| ▶Cstream_msg | Stream communication messages for handshaking, ACKing, data transmission, etc |
| Cack_batch | Cumulatively acknowledges received batches and signalizes new demand from a sink to its source |
| Cack_open | Acknowledges a previous open message and finalizes a stream handshake |
| Cbatch | Transmits stream data |
| Cclose | Orderly shuts down a stream after receiving an ACK for the last batch |
| Cdrop | Informs a source that a sink orderly drops out of a stream |
| Cforced_close | Propagates a fatal error from sources to sinks |
| Cforced_drop | Propagates a fatal error from sinks to sources |
| Copen | Initiates a stream handshake |
| Cstream_result | Terminates a stream by reducing it to a single value |
| Cstream_scatterer | Type-erased policy for dispatching data to sinks |
| Cstream_scatterer_impl | Type-erased policy for dispatching data to sinks |
| Cstream_serializer | Implements the serializer interface with a binary serialization protocol |
| Cterminal_stream_scatterer | Special-purpose scatterer for sinks that terminate a stream |
| Cthread_hook | Interface to define thread hooks |
| Ctimeout_msg | Signalizes a timeout event |
| Ctopic_scatterer | A topic scatterer allows stream nodes to fork into multiple lanes, where each lane carries only a subset of the data |
| Ctype_erased_tuple | Represents a tuple of type-erased values |
| Ctype_erased_value | Represents a single type-erased value |
| Ctype_erased_value_factory | |
| Ctype_nr | Computes the type number for T |
| Ctyped_actor | Identifies a statically typed actor |
| Ctyped_event_based_actor | A cooperatively scheduled, event-based actor implementation with static type-checking |
| Ctyped_response_promise | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e |
| Cunbox_message_element | Unboxes atom constants, i.e., converts atom_constant<V> to V |
| Cunit_t | Unit is analogous to void, but can be safely returned, stored, etc |
| Cunsafe_actor_handle_init_t | Tag type to select the unsafe constructor of actor handles |
| Cvariant | A variant represents always a valid value of one of the types Ts... |
| Cvariant_compare_helper | |
| Cvariant_reader | |
| Cvariant_writer | |
| Cweak_intrusive_ptr | An intrusive, reference counting smart pointer implementation |
