  caf | Root namespace of libcaf |
  exit_reason | Contains all predefined exit reasons |
 io | Contains all IO-related classes and functions |
 basp | Contains all classes and functions for the Binary Actor Sytem Protocol |
| network | Contains classes and functions used for network abstraction |
 acceptor | An acceptor is responsible for accepting incoming connections |
| acceptor_impl | A concrete acceptor with a technology-dependent policy |
| acceptor_manager | An acceptor manager configures an acceptor and provides callbacks for incoming connections as well as for error handling |
| datagram_handler_impl | A concrete datagram_handler with a technology-dependent policy |
| datagram_manager | A datagram manager provides callbacks for outgoing datagrams as well as for error handling |
| datagram_servant_impl | Default datagram servant implementation |
| doorman_impl | Default doorman implementation |
| event_handler | A socket I/O event handler |
 state | Stores various status flags and user-defined config parameters |
| interfaces | Utility class bundling access to network interface names and addresses |
| ip_endpoint | A hashable wrapper for a sockaddr storage |
| manager | A manager configures an I/O device and provides callbacks for various I/O operations |
| multiplexer | Low-level backend for IO multiplexing |
| runnable | Simple wrapper for runnables |
| supervisor | Makes sure the multipler does not exit its event loop until the destructor of supervisor has been called |
| pipe_reader | An event handler for the internal event pipe |
| protocol | Bundles protocol information for network and transport layer communication |
| receive_buffer | A container that does not call constructors and destructors for its values |
| scribe_impl | Default scribe implementation |
| stream | A stream capable of both reading and writing |
| stream_impl | A concrete stream with a technology-dependent policy for sending and receiving data from a socket |
| stream_manager | A stream manager configures an IO stream and provides callbacks for incoming data as well as for error handling |
| abstract_broker | A broker mediates between actor systems and other components in the network |
| accept_handle | Generic handle type for managing incoming connections |
| basp_broker | A broker implementation for the Binary Actor System Protocol (BASP) |
| broker | Describes a dynamically typed broker |
| broker_servant | Base class for scribe and doorman |
| connection_handle | Generic handle type for identifying connections |
| datagram_handle | Generic handle type for identifying datagram endpoints |
| datagram_servant | Manages writing to a datagram sink |
| doorman | Manages incoming connections |
| middleman | Manages brokers and network backends |
| middleman_actor_impl | Default implementation of the middleman_actor interface |
| scribe | Manages a stream |
| new_connection_msg | Signalizes a newly accepted connection from a broker |
| new_data_msg | Signalizes newly arrived data for a broker |
| data_transferred_msg | Signalizes that a certain amount of bytes has been written |
| connection_closed_msg | Signalizes that a broker connection has been closed |
| acceptor_closed_msg | Signalizes that a broker acceptor has been closed |
| connection_passivated_msg | Signalizes that a connection has entered passive mode |
| acceptor_passivated_msg | Signalizes that an acceptor has entered passive mode |
| new_datagram_msg | Signalizes that a datagram with a certain size has been sent |
| datagram_sent_msg | Signalizes that a datagram with a certain size has been sent |
| datagram_servant_passivated_msg | Signalizes that a datagram sink has entered passive mode |
| datagram_servant_closed_msg | Signalizes that a datagram endpoint has entered passive mode |
| meta | |
| annotation | Type tag for all meta annotations in CAF |
| mixin | Contains mixin classes implementing several actor traits |
| behavior_changer | A behavior_changer is an actor that supports self->become(...) and self->unbecome() |
| requester | A requester is an actor that supports `self->request(...) |
| sender | A sender is an actor that supports self->send(...) |
| subscriber_base | Marker for subscriber |
| subscriber | A subscriber is an actor that can subscribe to a group via self->join(...) |
| policy | Contains policies encapsulating characteristics or algorithms |
| arg | Provides a wrapper to pass policy types as values to functions |
| categorized | Configures a cached WDRR fixed multiplexed queue for dispatching to four nested queue (one for each message category type) |
| downstream_messages | Configures a dynamic WDRR queue for holding downstream messages |
| nested | Configures a nested DRR queue |
| normal_messages | Configures a cached DRR queue for holding asynchronous messages with default priority |
| profiled | 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 |
| scheduler_policy | This concept class describes a policy for worker and coordinator of the scheduler |
| coordinator_data | Policy-specific data fields for the coordinator |
| worker_data | Policy-specific data fields for the worker |
| unprofiled | This class is intended to be used as a base class for actual polices |
| upstream_messages | Configures a DRR queue for holding upstream messages |
| urgent_messages | Configures a cached DRR queue for holding asynchronous messages with default priority |
| work_sharing | Implements scheduling of actors via work sharing (central job queue) |
| work_stealing | Implements scheduling of actors via work stealing |
| scheduler | |
| profiled_coordinator | A coordinator which keeps fine-grained profiling state about its workers and their jobs |
| abstract_coordinator | A coordinator creates the workers, manages delayed sends and the central printer instance for aout |
| coordinator | Policy-based implementation of the abstract coordinator base class |
| test_coordinator | A schedule coordinator for testing purposes |
| worker | Policy-based implementation of the abstract worker base class |
| abstract_actor | Base class for all actor implementations |
| abstract_channel | Interface for all message receivers |
| abstract_composable_behavior | Marker type that allows CAF to spawn actors from composable states |
| abstract_group | A multicast group |
| actor | Identifies an untyped actor |
| actor_addr | Stores the address of typed as well as untyped actors |
| actor_clock | A monotonic clock for scheduling timeouts and delayed messages |
| actor_companion | An co-existing actor forwarding all messages through a user-defined callback to another object, thus serving as gateway to allow any object to interact with other actors |
| actor_config | Stores spawn-time flags and groups |
| actor_control_block | Actors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it |
| actor_ostream | Provides support for thread-safe output operations on character streams |
| actor_pool | An actor poool is a lightweight abstraction for a set of workers |
| actor_proxy | Represents an actor running on a remote machine, or different hardware, or in a separate process |
| actor_registry | A registry is used to associate actors to IDs or atoms (names) |
| actor_system | Actor environment including scheduler, registry, and optional components such as a middleman |
| module | An (optional) component of the actor system |
| actor_system_config | Configures an actor_system on startup |
| allowed_unsafe_message_type | Template specializations can whitelist individual types for unsafe message passing operations |
| atom_constant | Lifts an atom_value to a compile-time constant |
| attachable | Callback utility class |
| token | Represents a pointer to a value with its subtype as type ID number |
| behavior | Describes the behavior of an actor, i.e., provides a message handler and an optional timeout |
| binary_deserializer | Implements the deserializer interface with a binary serialization protocol |
| blocking_actor | A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing |
| accept_one_cond | Pseudo receive condition modeling a single receive |
| do_receive_helper | Implementation helper for blocking_actor::do_receive |
| mailbox_policy | Configures the FIFO inbox with two nested queues: |
| receive_cond | Represents pre- and postconditions for receive loops |
| receive_for_helper | Implementation helper for blocking_actor::receive_for |
| receive_while_helper | Implementation helper for blocking_actor::receive_while |
| buffered_downstream_manager | Mixin for streams with any number of downstreams |
| byte_address | Base type for addresses based on a byte representation such as IP or Ethernet addresses |
| callback | Describes a simple callback, usually implemented via lambda expression |
| callback_impl | Utility class for wrapping a function object of type Base |
| select_callback | Utility class for selecting a callback_impl |
| composable_behavior_base | Generates an interface class that provides operator() |
| composable_behavior | Base type for composable actor states |
| composable_behavior_based_actor | Implementation class for spawning composable states directly as actors |
| composed_type | Computes the type for f*g (actor composition) |
| config_option | Defines a configuration option for the application |
| meta_state | Custom vtable-like struct for delegating to type-specific functions and storing type-specific information shared by several config options |
| config_option_adder | Adds config options of the same category to a config_option_set |
| config_option_set | A set of config_option objects that parses CLI arguments into a settings object |
| config_value | A type for config parameters with similar interface to a variant |
| config_value_access | |
| select_config_value_access | Delegates to config_value_access for all specialized versions |
| select_config_value_access< T, true > | Catches all non-specialized integer types |
| config_value_access< std::vector< T > > | Implements automagic unboxing of std::vector<T> from a homogeneous config_value::list |
| config_value_access< std::tuple< Ts...> > | Implements automagic unboxing of std::tuple<Ts...> from a heterogeneous config_value::list |
| config_value_access< dictionary< V > > | Implements automagic unboxing of dictionary<V> from a homogeneous config_value::dictionary |
| cow_tuple | A copy-on-write tuple implementation |
| data_processor | A data processor translates an object into a format that can be stored or vice versa |
| default_downstream_manager | Selects a downstream manager implementation based on the signature of various handlers |
| default_sum_type_access | Allows specializing the sum_type_access trait for any type that simply wraps a variant and exposes it with a get_data() member function |
| delegated | Helper class to indicate that a request has been forwarded |
| deserializer | Technology-independent deserialization interface |
| dictionary | Maps strings to values of type V, but unlike std::map<std::string, V> accepts string_view for looking up keys efficiently |
| downstream | Grants access to an output stream buffer |
| downstream_manager | Manages downstream communication for a stream_manager |
| path_predicate | Predicate object for paths |
| path_visitor | Function object for iterating over all paths |
| downstream_manager_base | The default downstream manager base stores outbound paths in an unordered map |
| downstream_msg | Stream messages that travel downstream, i.e., batches and close messages |
| batch | Transmits stream data |
| close | Orderly shuts down a stream after receiving an ACK for the last batch |
| forced_close | Propagates a fatal error from sources to sinks |
| ratio_to_time_unit_helper | Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes |
| infinite_t | Represents an infinite amount of timeout for specifying "invalid" timeouts |
| duration | Time duration consisting of a time_unit and a 64 bit unsigned integer |
| has_make_error | Evaluates to true if T is an enum with a free function make_error for converting it to an error |
| error | A serializable type for storing error codes with category and optional, human-readable context information |
| event_based_actor | A cooperatively scheduled, event-based actor implementation |
| execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler |
| no_error_t | Helper class to construct an expected<T> that represents no error |
| expected | Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error |
| expected< void > | The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool |
| extend | Allows convenient definition of types using mixins |
| forwarding_actor_proxy | Implements a simple proxy forwarding all operations to a manager |
| function_view | A function view for an actor hides any messaging from the caller |
| fused_downstream_manager | A downstream manager that delegates to any number of sub-managers |
| non_owning_ptr | State held for each slot |
| intrusive_cow_ptr | An intrusive, reference counting smart pointer implementation with copy-on-write optimization |
| intrusive_ptr | An intrusive, reference counting smart pointer implementation |
| optional | A C++17 compatible optional implementation |
| param | Represents a message handler parameter of type T and guarantees copy-on-write semantics |
| serializer_impl | Implements the serializer interface with a binary serialization protocol |
| span | A C++11/14 drop-in replacement for C++20's std::span without support for static extents |
| stream | Empty marker type for streaming handshakes |
| weak_intrusive_ptr | An intrusive, reference counting smart pointer implementation |
| typed_actor | Identifies a statically typed actor |
| typed_event_based_actor | A cooperatively scheduled, event-based actor implementation with static type-checking |
| typed_response_promise | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e |
| variant | A variant represents always a valid value of one of the types Ts... |
| output_stream | Empty marker type for type-checking of stream sources and stages |
| stateful_actor | An event-based actor with managed state |
| group_module | Interface for user-defined multicast implementations |
| illegal_message_element | Marker class identifying classes in CAF that are not allowed to be used as message element |
| inbound_path | State for a path to an upstream actor (source) |
| stats_t | Stores statistics for measuring complexity of incoming batches |
| calculation_result | Wraps the resulf of stats_t::calculate() |
| measurement | Wraps a time measurement for a single processed batch |
| index_mapping | Marker for representing placeholders at runtime |
| infer_handle_from_fun | Deduces an actor handle type from a function or function object |
| infer_handle_from_class | Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced |
| ipv4_endpoint | An IP endpoint that contains an ::ipv4_address and a port |
| ipv6_endpoint | An IP endpoint that contains an ::ipv6_address and a port |
| is_actor_handle | Checks whether T is an actor or a typed_actor<...> |
| is_typed_actor | Evaluates to true if T is a typed_actor<...> |
| logger | Centrally logs events from all actors in an actor system |
| config | Combines various logging-related flags and parameters into a bitfield |
| event | Encapsulates a single logging event |
| field | Represents a single format string field |
| line_builder | Utility class for building user-defined log messages with CAF_ARG |
| mailbox_category_corrector | Corrects the message ID for down- and upstream messages to make sure the category for a mailbox_element matches its content |
| mailbox_element_vals | Encapsulates arbitrary data in a message element |
| mailbox_element_view | Provides a view for treating arbitrary data as message element |
| unbox_message_element | Unboxes atom constants, i.e., converts atom_constant<V> to V |
| make_sink_result | Returns a stream sink with the slot ID of its first inbound path |
| make_source_result | Returns a stream source with the slot ID of its first outbound path |
| make_stage_result | Returns a stream stage with the slot IDs of its first in- and outbound paths |
| type_erased_value_factory | |
| memory_managed | This base enables derived classes to enforce a different allocation strategy than new/delete by providing a virtual protected request_deletion() function and non-public destructor |
| message | Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type |
| cli_arg | Stores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback |
| cli_res | Stores the result of message::extract_opts |
| message_builder | Provides a convenient interface for createing message objects from a series of values using the member function append |
| message_handler | A partial function implementation used to process a message |
| message_id | Bundles various flags along with an optional request ID |
| message_view | Represents an object pointing to a type_erased_tuple that is convertible to a message |
| monitorable_actor | Base class for all actor implementations |
| named_actor_config | Stores a flow-control configuration |
| no_stages_t | Convenience tag type for producing empty forwarding stacks |
| node_id | A node ID is an opaque value for representing CAF instances in the network |
| none_t | Represents "nothing", e.g., for clearing an optional by assigning none |
| optional< T & > | Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead |
| outbound_path | State for a single path to a sink of a downstream_manager |
| remove_param | Unpacks param<T> to T |
| param_decay | Convenience struct for remove_param<std::decay<T>> |
| proxy_registry | Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages |
| backend | Responsible for creating proxy actors |
| raw_event_based_actor | A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages |
| ref_counted | Base class for reference counted objects with an atomic reference count |
| response_handle | This helper class identifies an expected response message and enables request(...).then(...) |
| response_promise | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e |
| response_type | Defines: |
| response_type_unbox | Unboxes Xs and calls response_type |
| resumable | A cooperatively executed task managed by one or more instances of execution_unit |
| runtime_settings_map | Thread-safe container for mapping atoms to arbitrary settings |
| scheduled_actor | A cooperatively scheduled, event-based actor implementation |
| mailbox_policy | Configures the FIFO inbox with four nested queues: |
| mailbox_visitor | Consumes messages from the mailbox |
| scoped_actor | A scoped handle to a blocking actor |
| scoped_execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler |
| serializer | Technology-independent serialization interface |
| skip_t | |
| spawn_options | Stores options passed to the spawn function family |
| stream_deserializer | Implements the deserializer interface with a binary serialization protocol |
| stream_finalize_trait | Dispatches a finalize call to a function taking either one or two arguments |
| stream_finalize_trait< Fun, State, false > | Specializes the trait for callbacks that only take the state |
| stream_finalize_trait< Fun, State, true > | Specializes the trait for callbacks that take state and error |
| stream_manager | Manages a single stream with any number of in- and outbound paths |
| stream_serializer | Implements the serializer interface with a binary serialization protocol |
| stream_sink_driver | Identifies an unbound sequence of messages |
| stream_sink_trait_base | Base type for all sink traits |
| stream_sink_trait | Defines required type aliases for stream sinks |
| stream_sink_trait< void(State &, In)> | Specializes the trait for element-wise processing |
| stream_sink_trait< void(State &, std::vector< In > &)> | Specializes the trait for batch-wise processing |
| stream_sink_trait< void(State &, const std::vector< In > &)> | Specializes the trait for batch-wise processing with const references |
| stream_slots | Maps two stream_slot values into a pair for storing sender and receiver slot information |
| inbound_stream_slot | Wraps a stream slot ID for inbound paths with the full type information of the path creation |
| outbound_stream_slot | Wraps a stream slot ID for outbound paths with the full type information of the path creation |
| stream_source_driver | Identifies an unbound sequence of messages |
| stream_source_trait | Deduces the output type and the state type for a stream source from its pull implementation |
| stream_stage_driver | Encapsulates user-provided functionality for generating a stream stage |
| stream_stage_trait< void(State &, downstream< Out > &, In)> | Deduces the input type, output type and the state type for a stream stage from its process implementation |
| stream_buffer | The base class for all stream buffer implementations |
| arraybuf | A streambuffer abstraction over a fixed array of bytes |
| containerbuf | A streambuffer abstraction over a contiguous container |
| string_view | Drop-in replacement for C++17 std::string_view |
| sum_type_access | Specializing this trait allows users to enable holds_alternative, get, get_if, and visit for any user-defined sum type |
| has_sum_type_access | Evaluates to true if T specializes sum_type_access |
| exit_msg | Sent to all links when an actor is terminated |
| down_msg | Sent to all actors monitoring an actor when it is terminated |
| group_down_msg | Sent to all members of a group when it goes offline |
| timeout_msg | Signalizes a timeout event |
| open_stream_msg | Demands the receiver to open a new stream from the sender to the receiver |
| thread_hook | Interface to define thread hooks |
| type_erased_tuple | Represents a tuple of type-erased values |
| empty_type_erased_tuple | |
| type_erased_value | Represents a single type-erased value |
| type_nr | Computes the type number for T |
| unit_t | Unit is analogous to void, but can be safely returned, stored, etc |
| upstream_msg | Stream messages that flow upstream, i.e., acks and drop messages |
| ack_batch | Cumulatively acknowledges received batches and signalizes new demand from a sink to its source |
| ack_open | Acknowledges a previous open message and finalizes a stream handshake |
| drop | Asks the source to discard any remaining credit and close this path after receiving an ACK for the last batch |
| forced_drop | Propagates a fatal error from sinks to sources |
| uri | A URI according to RFC 3986 |
| authority_type | Bundles the authority component of the URI, i.e., userinfo, host, and port |
| sum_type_access< variant< Ts...> > | Enable holds_alternative, get, get_if, and visit for variant |
| variant_compare_helper | |
| variant_reader | |
| variant_writer | |
| handle | Base class for IO handles such as accept_handle or connection_handle |
1.8.5
