►Ncaf | Root namespace of libcaf |
►Ndecorator | |
Csequencer | An actor decorator implementing "dot operator"-like compositions, i.e., f.g(x) = f(g(x)) |
Csplitter | An actor decorator implementing "dot operator"-like compositions, i.e., f.g(x) = f(g(x)) |
►Ndetail | |
Cabstract_worker_hub | A central place where workers return to after finishing a task |
Calways_false | Utility for fallbacks calling static_assert |
Ccallable_trait | Defines result_type, arg_types, and fun_type |
Ccomparable | Barton–Nackman trick implementation |
Cconjunction | Joins all bool constants using operator && |
Ccontainer_view | Decorates a container of type T to appear as container of type U |
Cdeconst_kvp | Utility trait for removing const inside a map<K, V>::value_type |
Cdisjunction | Joins all bool constants using operator || |
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_serialize | Checks whether T provides either a free function or a member function for serialization |
Chas_to_string | Checks whether T defines a free function to_string |
Cil_indices | Creates indices for List beginning at Pos |
Cini_category_consumer | Consumes a config category |
Cini_consumer | Consumes a series of dictionaries forming a application configuration |
Cini_value_consumer | Consumes a single value from an INI parser |
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) |
Cinvoke_result_visitor | Inspects the result of message handlers and triggers type-depended actions such as generating result messages |
Cis_builtin | Checks whether T is considered a builtin type |
Cis_byte_sequence | Checks whether T is a contiguous sequence of byte |
Cis_callable | Checks wheter T is a function or member function |
Cis_callable_with | Checks wheter F is callable with arguments of types Ts... |
Cis_comparable | Checks whether T1 is comparable with T2 |
Cis_complete | Checks whether T is a complete type |
Cis_duration | Checks whether T is a std::chrono::duration |
Cis_forward_iterator | Checks wheter 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_inspectable | Checks whether T is inspectable by Inspector |
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_manipulator | Checks wheter F takes mutable references |
Cis_map_like | Checks whether T behaves like std::map |
Cis_mutable_ref | Checks wheter T is a non-const reference |
Cis_one_of | Checks wheter T is in the template parameter pack Ts |
Cis_pair | Utility trait for checking whether T is a std::pair |
Cis_pair< std::pair< First, Second > > | 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_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_serializable | Any inspectable type is considered to be serializable |
Cis_serializable_impl< T, false, false > | Checks whether T is builtin or provides a serialize (free or member) function |
Cis_specialization | Checks whether Tpl is a specialization of T or not |
Cpath_state | Bundles a filter and a buffer |
Cpath_state< unit_t, T > | Compress path_state if Filter is unit |
Cscope_guard | A lightweight scope guard implementation |
Cshared_spinlock | A spinlock implementation providing shared and exclusive locking |
Csingle_arg_wrapper | Enables automagical string conversion for CAF_ARG |
Csquashed_int | Squashes integer types into [u]int_[8|16|32|64]_t equivalents |
Cstatic_error_printer | Generates an error using static_assert on an interface mismatch |
Cstream_distribution_tree | A stream distribution tree consist of peers forming an acyclic graph |
Cstream_sink_driver_impl | Identifies an unbound sequence of messages |
Cstream_source_driver_impl | Identifies an unbound sequence of messages |
Cstream_stage_driver_impl | Default implementation for a stream_stage_driver that hardwires message as result type and implements process and finalize using user-provided function objects (usually lambdas) |
Csync_request_bouncer | Drains a mailbox and sends an error message to each unhandled request |
Ctick_emitter | Converts realtime into a series of ticks, whereas each tick represents a preconfigured timespan |
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_binary_forall | Tests whether a binary predicate holds for all corresponding elements of ListA and ListB |
Ctl_concat | Concatenates lists |
Ctl_concat_impl< type_list< LhsTs... >, type_list< RhsTs... > > | Concatenates two lists |
Ctl_cons | Alias for tl_push_front<List, What> |
Ctl_count | Counts the number of elements in the list which satisfy a predicate |
Ctl_count_not | Counts the number of elements in the list which satisfy a predicate |
Ctl_count_type | Counts the number of elements in the list which are equal to T |
Ctl_distinct | Creates a new list from List without any duplicate elements |
Ctl_empty | Tests whether a list is empty |
Ctl_equal | Tests whether ListA contains the same elements as ListB and vice versa |
Ctl_exists | Tests whether a predicate holds for some of the elements of a list |
Ctl_filter< type_list< T... >, Pred > | Create a new list containing all elements which satisfy Pred |
Ctl_filter_not | Creates a new list containing all elements which do not satisfy Pred |
Ctl_filter_not_type | Creates a new list containing all elements which are not equal to Type |
Ctl_filter_type | Creates a new list containing all elements which are equal to Type |
Ctl_find | Finds the first element satisfying Pred beginning at index Pos |
Ctl_find_impl | Finds the first element of type What beginning at index Pos |
Ctl_forall | Tests whether a predicate holds for all elements of a list |
Ctl_from | Construct a type list from types that take a list of variadic template arguments |
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_index_where | Finds the first element satisfying a given predicate |
Ctl_is_distinct | Tests whether a list is distinct |
Ctl_map | Creates a new list by applying a "template function" to each element |
Ctl_map_conditional | Creates a new list by applying a Fun to each element which returns TraitResult for Trait |
Ctl_pad_left | Resizes the list to contain NewSize elements and uses FillType to initialize prepended elements with |
Ctl_pad_right | Resizes the list to contain NewSize elements and uses FillType to initialize the new elements with |
Ctl_pop_back | Creates a new list wih all but the last element of List |
Ctl_prepend< type_list< T... >, What > | Creates a new list with What prepended to List |
Ctl_push_back< type_list< ListTs... >, What > | Appends What to given list |
Ctl_push_front< type_list< ListTs... >, What > | Appends What to given list |
Ctl_replace_back | Creates a new list with all but the last element of List and append T to the new list |
Ctl_reverse | Creates a new list wih elements in reversed order |
Ctl_right | Creates a new list containing the last N elements |
Ctl_size | Gets the number of template parameters of List |
Ctl_slice | Creates a new list from range (First, Last] |
Ctl_tail | Gets the tail of List |
Ctl_trim | Removes trailing What elements from the end |
Ctl_zip | Zips two lists of equal size |
Ctl_zip_right | Equal to zip(right(ListA, N), right(ListB, N), Fun) |
Ctransfer_const | Transfers const from T to U . U remains unchanged if T is not const |
Ctype_at | Gets the Nth element of the template parameter pack Ts |
Ctype_erased_value_impl | Default implementation for single type-erased values |
Ctype_list | A list of types |
Cunique_function | A move-only replacement for std::function |
Cunordered_flat_map | A map abstraction with an unsorted std::vector providing O(n) lookup |
►Nintrusive | |
Cdrr_cached_queue | A Deficit Round Robin queue with an internal cache for allowing skipping consumers |
Cdrr_queue | A Deficit Round Robin queue |
Cfifo_inbox | A FIFO inbox that combines an efficient thread-safe LIFO inbox with a FIFO queue for re-ordering incoming messages |
Clifo_inbox | An intrusive, thread-safe LIFO queue implementation for a single reader with any number of writers |
Cnew_round_result | Returns the state of a consumer from new_round |
Csingly_linked | Intrusive base for singly linked types that allows queues to use T with dummy nodes |
Ctask_queue | A singly-linked FIFO queue for storing tasks of varying size |
Cwdrr_dynamic_multiplexed_queue | A work queue that internally multiplexes any number of DRR queues |
Cwdrr_fixed_multiplexed_queue | A work queue that internally multiplexes any number of DRR queues |
►Nio | Contains all IO-related classes and functions |
►Nbasp | Contains all classes and functions for the Binary Actor Sytem 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 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 |
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 |
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 |
Ccategorized | Configures a cached WDRR fixed multiplexed queue for dispatching to four nested queue (one for each message category type) |
►Cdownstream_messages | Configures a dynamic WDRR queue for holding downstream messages |
Cnested | Configures a nested DRR queue |
Cnormal_messages | Configures a cached DRR queue for holding asynchronous messages with default priority |
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 |
Ctcp | Policy object for wrapping default TCP operations |
Cudp | Policy object for wrapping default UDP operations |
Cunprofiled | This class is intended to be used as a base class for actual polices |
Cupstream_messages | Configures a DRR queue for holding upstream messages |
Curgent_messages | Configures a cached DRR queue for holding asynchronous messages with default priority |
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 |
►Ntag | |
Cboxing_type | Allows the testing DSL to recognize that subtypes are boxing content types |
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_profiler | A profiler which provides a set of callbacks for several actor operations in order to collect fine-grained profiling state about the system |
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 |
Cactor_traits | Provides uniform access to properties of actor types |
Cadd_param | Converts T to param<T> unless T is arithmetic, an atom constant, or a stream handshake |
Callowed_unsafe_message_type | Template specializations can whitelist individual types for unsafe message passing operations |
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 |
Cbinary_deserializer | Implements the deserializer interface with a binary serialization protocol |
►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 |
Cmailbox_policy | Configures the FIFO inbox with two nested queues: |
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 |
Cbuffered_downstream_manager | Mixin for streams with any number of downstreams |
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 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 | Defines a configuration option for the application |
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_access< std::tuple< Ts... > > | Implements automagic unboxing of std::tuple<Ts...> from a heterogeneous config_value::list |
Cconfig_value_adaptor | Interfaces between a user-defined type and CAF config values by going through intermediate values |
Cconfig_value_adaptor_access | Enables user-defined types in config files and on the CLI by converting them to and from tuples |
Cconfig_value_adaptor_field | Describes a field of type T of an adaptor |
Cconfig_value_field | Describes a field of Object |
Cconfig_value_object_access | Enables user-defined types in config files and on the CLI by converting them to and from config_value::dictionary |
Ccontainerbuf | A streambuffer abstraction over a contiguous container |
Ccow_tuple | A copy-on-write tuple implementation |
Cdata_processor | A data processor translates an object into a format that can be stored or vice versa |
Cdeep_to_string_t | Wrapper to deep_to_string for using the function as an inspector |
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_downstream_manager | Selects a downstream manager implementation based on the signature of various handlers |
Cdefault_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 |
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 string_view for looking up keys efficiently |
Cdown_msg | Sent to all actors monitoring an actor when it is terminated |
Cdownstream | Grants access to an output stream buffer |
►Cdownstream_manager | Manages downstream communication for a stream_manager |
Cpath_predicate | Predicate object for paths |
Cpath_visitor | Function object for iterating over all paths |
Cdownstream_manager_base | The default downstream manager base stores outbound paths in an unordered map |
►Cdownstream_msg | Stream messages that travel downstream, i.e., batches and close messages |
Cbatch | Transmits stream data |
Cclose | Orderly shuts down a stream after receiving an ACK for the last batch |
Cforced_close | Propagates a fatal error from sources to sinks |
Cduration | Time duration consisting of a time_unit and a 64 bit unsigned integer |
Cdynamically_typed_actor_base | Marker type for dynamically typed actors |
Cempty_type_erased_tuple | Dummy objects representing empty tuples |
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_downstream_manager | A downstream manager that delegates to any number of sub-managers |
Cnon_owning_ptr | State held for each slot |
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 |
Chas_sum_type_access | Evaluates to true if T specializes sum_type_access |
Chas_type_id | Evaluates to true if any of these statements holds true: |
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) |
►Cstats_t | Stores statistics for measuring complexity of incoming batches |
Ccalculation_result | Wraps the resulf of stats_t::calculate() |
Cmeasurement | Wraps a time measurement for a single processed batch |
Cinbound_stream_slot | Wraps a stream slot ID for inbound paths with the full type information of the path creation |
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_cow_ptr | An intrusive, reference counting smart pointer implementation with copy-on-write optimization |
Cintrusive_ptr | An intrusive, reference counting smart pointer implementation |
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<...> |
►Clogger | Centrally logs events from all actors in an actor system |
Cconfig | Combines various logging-related flags and parameters into a bitfield |
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_category_corrector | Corrects the message ID for down- and upstream messages to make sure the category for a mailbox_element matches its content |
Cmailbox_element_vals | Encapsulates arbitrary data in a message element |
Cmailbox_element_view | Provides a view for treating arbitrary data as message element |
Cmake_sink_result | Returns a stream sink with the slot ID of its first inbound path |
Cmake_source_result | Returns a stream source with the slot ID of its first outbound path |
Cmake_stage_result | Returns a stream stage with the slot IDs of its first in- and outbound paths |
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 | Bundles various flags along with an optional request ID |
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 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 |
Copen_stream_msg | Demands the receiver to open a new stream from the sender to the receiver |
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 of a downstream_manager |
Coutbound_stream_slot | Wraps a stream slot ID for outbound paths with the full type information of the path creation |
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>> |
Cparser_state | Stores all informations necessary for implementing an FSM-based parser |
►Cproxy_registry | Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages |
Cbackend | Responsible for creating proxy actors |
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 |
Cruntime_settings_map | Thread-safe container for mapping atoms to arbitrary settings |
►Cscheduled_actor | A cooperatively scheduled, event-based actor implementation |
Cmailbox_policy | Configures the FIFO inbox with four nested queues: |
Cmailbox_visitor | Consumes messages from the mailbox |
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 |
Cselect_config_value_access | Delegates to config_value_access for all specialized versions |
Cselect_config_value_access< T, select_config_value_hint::is_integral > | Catches all non-specialized integer types |
Cselect_config_value_access< T, select_config_value_hint::is_list > | Catches all non-specialized list types |
Cselect_config_value_access< T, select_config_value_hint::is_map > | Catches all non-specialized map types |
Cserializer | Technology-independent serialization interface |
Cserializer_impl | Implements the serializer interface with a binary serialization protocol |
Cskip_t | Default handler function that leaves messages in the mailbox |
Cspan | A C++11/14 drop-in replacement for C++20's std::span without support for static extents |
Cspawn_options | Stores options passed to the spawn function family |
Cstateful_actor | An event-based actor with managed state |
Cstatically_typed_actor_base | Marker type for statically typed actors |
Cstream | Empty marker type for streaming handshakes |
Cstream_buffer | The base class for all stream buffer implementations |
Cstream_deserializer | Implements the deserializer interface with a binary serialization protocol |
Cstream_finalize_trait | Dispatches a finalize call to a function taking either one or two arguments |
Cstream_finalize_trait< Fun, State, false > | Specializes the trait for callbacks that only take the state |
Cstream_finalize_trait< Fun, State, true > | Specializes the trait for callbacks that take state and error |
Cstream_manager | Manages a single stream with any number of in- and outbound paths |
Cstream_serializer | Implements the serializer interface with a binary serialization protocol |
Cstream_sink_driver | Identifies an unbound sequence of messages |
Cstream_sink_trait | Defines required type aliases for stream sinks |
Cstream_sink_trait< void(State &, const std::vector< In > &)> | Specializes the trait for batch-wise processing with const references |
Cstream_sink_trait< void(State &, In)> | Specializes the trait for element-wise processing |
Cstream_sink_trait< void(State &, std::vector< In > &)> | Specializes the trait for batch-wise processing |
Cstream_sink_trait_base | Base type for all sink traits |
Cstream_slots | Maps two stream_slot values into a pair for storing sender and receiver slot information |
Cstream_source_driver | Identifies an unbound sequence of messages |
Cstream_source_trait | Deduces the output type and the state type for a stream source from its pull implementation |
Cstream_stage_driver | Encapsulates user-provided functionality for generating a stream stage |
Cstream_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 |
Cstring_view | Drop-in replacement for C++17 std::string_view |
Csum_type_access | Specializing this trait allows users to enable holds_alternative , get , get_if , and visit for any user-defined sum type |
Csum_type_access< variant< Ts... > > | Enable holds_alternative , get , get_if , and visit for variant |
Cthread_hook | Interface to define thread hooks |
Ctimeout_msg | Signalizes a timeout event |
Ctype_by_id | Maps the globally unique ID V to a type (inverse to ::type_id) |
Ctype_erased_tuple | Represents a tuple of type-erased values |
Ctype_erased_value | Represents a single type-erased value |
Ctype_erased_value_factory | Converts values to type-erased values |
Ctype_id | Maps the type T to a globally unique ID |
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 |
Ctype_nr | Computes the type number for T |
Ctyped_actor | Identifies a statically typed actor |
Ctyped_actor_view_base | Tag type for typed_actor_view |
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 |
►Cupstream_msg | Stream messages that flow upstream, i.e., acks and drop messages |
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 |
Cdrop | Asks the source to discard any remaining credit and close this path after receiving an ACK for the last batch |
Cforced_drop | Propagates a fatal error from sinks to sources |
►Curi | A URI according to RFC 3986 |
Cauthority_type | Bundles the authority component of the URI, i.e., userinfo, host, and port |
Cvariant | A variant represents always a valid value of one of the types Ts... |
Cweak_intrusive_ptr | An intrusive, reference counting smart pointer implementation |