Class List

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

[detail level 12345]

►Ncaf
►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_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