CAF  0.17.6
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 Ccaf::abstract_channelInterface for all message receivers
 Ccaf::abstract_composable_behaviorMarker type that allows CAF to spawn actors from composable states
 Ccaf::actor_clockA monotonic clock for scheduling timeouts and delayed messages
 Ccaf::actor_companionAn 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
 Ccaf::actor_configStores spawn-time flags and groups
 Ccaf::actor_control_blockActors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it
 Ccaf::actor_ostreamProvides support for thread-safe output operations on character streams
 Ccaf::actor_profilerA profiler which provides a set of callbacks for several actor operations in order to collect fine-grained profiling state about the system
 Ccaf::actor_registryA registry is used to associate actors to IDs or atoms (names)
 Ccaf::actor_systemActor environment including scheduler, registry, and optional components such as a middleman
 Ccaf::actor_system::moduleAn (optional) component of the actor system
 Ccaf::actor_system_configConfigures an actor_system on startup
 Ccaf::add_param< T >Converts T to param<T> unless T is arithmetic, an atom constant, or a stream handshake
 Ccaf::allowed_unsafe_message_type< T >Template specializations can whitelist individual types for unsafe message passing operations
 Ccaf::atom_constant< V >Lifts an atom_value to a compile-time constant
 Ccaf::attachableCallback utility class
 Ccaf::attachable::tokenRepresents a pointer to a value with its subtype as type ID number
 Ccaf::behaviorDescribes the behavior of an actor, i.e., provides a message handler and an optional timeout
 Ccaf::blocking_actor::do_receive_helperImplementation helper for blocking_actor::do_receive
 Ccaf::blocking_actor::mailbox_policyConfigures the FIFO inbox with two nested queues:
 Ccaf::blocking_actor::receive_condRepresents pre- and postconditions for receive loops
 Ccaf::blocking_actor::receive_for_helper< T >Implementation helper for blocking_actor::receive_for
 Ccaf::blocking_actor::receive_while_helperImplementation helper for blocking_actor::receive_while
 Ccaf::blocking_actor_baseMarker type for blocking actors
 Ccaf::callback< Ts >Describes a simple callback, usually implemented via lambda expression
 Ccaf::composable_behavior< TypedActor >Base type for composable actor states
 Ccaf::composable_behavior_base< MPI >Generates an interface class that provides operator()
 Ccaf::composed_type< Xs, Ys, Zs, Rs >Computes the type for f*g (actor composition)
 Ccaf::config_optionDefines a configuration option for the application
 Ccaf::config_option::meta_stateCustom vtable-like struct for delegating to type-specific functions and storing type-specific information shared by several config options
 Ccaf::config_option_adderAdds config options of the same category to a config_option_set
 Ccaf::config_option_setA set of config_option objects that parses CLI arguments into a settings object
 Ccaf::config_valueA type for config parameters with similar interface to a variant
 Ccaf::config_value_access< std::tuple< Ts... > >Implements automagic unboxing of std::tuple<Ts...> from a heterogeneous config_value::list
 Ccaf::config_value_adaptor< Ts >Interfaces between a user-defined type and CAF config values by going through intermediate values
 Ccaf::config_value_adaptor_access< Trait >Enables user-defined types in config files and on the CLI by converting them to and from tuples
 Ccaf::config_value_adaptor_field< T >Describes a field of type T of an adaptor
 Ccaf::config_value_field< Object >Describes a field of Object
 Ccaf::config_value_object_access< Trait >Enables user-defined types in config files and on the CLI by converting them to and from config_value::dictionary
 Ccaf::data_processor< Derived >A data processor translates an object into a format that can be stored or vice versa
 Ccaf::deep_to_string_tWrapper to deep_to_string for using the function as an inspector
 Ccaf::default_actor_traits< T, ExtendsAbstractActor >Default implementation of actor_traits for non-actors (SFINAE-friendly)
 Ccaf::default_actor_traits< T, true >Default implementation of actor_traits for regular actors
 Ccaf::default_downstream_manager< F >Selects a downstream manager implementation based on the signature of various handlers
 Ccaf::default_sum_type_access< T >Allows specializing the sum_type_access trait for any type that simply wraps a variant and exposes it with a get_data() member function
 Ccaf::delegated< Ts >Helper class to indicate that a request has been forwarded
 Ccaf::detail::abstract_worker_hubA central place where workers return to after finishing a task
 Ccaf::detail::always_false< class >Utility for fallbacks calling static_assert
 Ccaf::detail::callable_trait< Functor >Defines result_type, arg_types, and fun_type
 Ccaf::detail::comparable< Subclass, T >Barton–Nackman trick implementation
 Ccaf::detail::conjunction< BoolConstants >Joins all bool constants using operator &&
 Ccaf::detail::container_view< F, Container >Decorates a container of type T to appear as container of type U
 Ccaf::detail::deconst_kvp< T >Utility trait for removing const inside a map<K, V>::value_type
 Ccaf::detail::disjunction< BoolConstants >Joins all bool constants using operator ||
 Ccaf::detail::get_callable_trait< T >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
 Ccaf::detail::has_serialize< T, Ignore >Checks whether T provides either a free function or a member function for serialization
 Ccaf::detail::has_to_string< T >Checks whether T defines a free function to_string
 Ccaf::detail::il_indices< List, Pos, Indices >Creates indices for List beginning at Pos
 Ccaf::detail::ini_category_consumerConsumes a config category
 Ccaf::detail::ini_consumerConsumes a series of dictionaries forming a application configuration
 Ccaf::detail::ini_value_consumerConsumes a single value from an INI parser
 Ccaf::detail::init_fun_factory_helper< Base, F, ArgsPtr, ReturnsBehavior, HasSelfPtr >Wraps a user-defined function and gives it a uniform signature
 Ccaf::detail::int_list< Is >A list of integers (wraps a long... template parameter pack)
 Ccaf::detail::invoke_result_visitorInspects the result of message handlers and triggers type-depended actions such as generating result messages
 Ccaf::detail::is_builtin< T >Checks whether T is considered a builtin type
 Ccaf::detail::is_byte_sequence< T >Checks whether T is a contiguous sequence of byte
 Ccaf::detail::is_callable< T >Checks wheter T is a function or member function
 Ccaf::detail::is_callable_with< F, Ts >Checks wheter F is callable with arguments of types Ts...
 Ccaf::detail::is_comparable< T1, T2 >Checks whether T1 is comparable with T2
 Ccaf::detail::is_complete< T >Checks whether T is a complete type
 Ccaf::detail::is_duration< T >Checks whether T is a std::chrono::duration
 Ccaf::detail::is_forward_iterator< T >Checks wheter T behaves like a forward iterator
 Ccaf::detail::is_handler_for< F, T >Checks whether F is convertible to either std::function<void (T&)> or std::function<void (const T&)>
 Ccaf::detail::is_inspectable< Inspector, T >Checks whether T is inspectable by Inspector
 Ccaf::detail::is_iterable< T >Checks whether T has begin() and end() member functions returning forward iterators
 Ccaf::detail::is_list_like< T >Checks whether T behaves like std::vector, std::list, or std::set
 Ccaf::detail::is_manipulator< F >Checks wheter F takes mutable references
 Ccaf::detail::is_map_like< T >Checks whether T behaves like std::map
 Ccaf::detail::is_mutable_ref< T >Checks wheter T is a non-const reference
 Ccaf::detail::is_one_of< T, Ts >Checks wheter T is in the template parameter pack Ts
 Ccaf::detail::is_pair< T >Utility trait for checking whether T is a std::pair
 Ccaf::detail::is_pair< std::pair< First, Second > >Utility trait for checking whether T is a std::pair
 Ccaf::detail::is_primitive< T >Checks whether T is primitive, i.e., either an arithmetic type or convertible to one of STL's string types
 Ccaf::detail::is_same_ish< T, U >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
 Ccaf::detail::is_serializable< T >Any inspectable type is considered to be serializable
 Ccaf::detail::is_serializable_impl< T, false, false >Checks whether T is builtin or provides a serialize (free or member) function
 Ccaf::detail::is_specialization< Tpl, T >Checks whether Tpl is a specialization of T or not
 Ccaf::detail::path_state< Filter, T >Bundles a filter and a buffer
 Ccaf::detail::path_state< unit_t, T >Compress path_state if Filter is unit
 Ccaf::detail::scope_guard< Fun >A lightweight scope guard implementation
 Ccaf::detail::shared_spinlockA spinlock implementation providing shared and exclusive locking
 Ccaf::detail::simple_actor_clock::eventBase class for clock events
 Ccaf::detail::single_arg_wrapper< T >Enables automagical string conversion for CAF_ARG
 Ccaf::detail::squashed_int< T >Squashes integer types into [u]int_[8|16|32|64]_t equivalents
 Ccaf::detail::static_error_printer< NumMessageHandlers, Pos, RemainingXs, RemainingYs >Generates an error using static_assert on an interface mismatch
 Ccaf::detail::sync_request_bouncerDrains a mailbox and sends an error message to each unhandled request
 Ccaf::detail::tick_emitterConverts realtime into a series of ticks, whereas each tick represents a preconfigured timespan
 Ccaf::detail::tl_apply< List, VarArgTemplate >Applies the types of the list to VarArgTemplate
 Ccaf::detail::tl_at< type_list< E... >, N >Gets element at index N of List
 Ccaf::detail::tl_back< List >Gets the last element in List
 Ccaf::detail::tl_binary_forall< ListA, ListB, Pred >Tests whether a binary predicate holds for all corresponding elements of ListA and ListB
 Ccaf::detail::tl_concat< Lists >Concatenates lists
 Ccaf::detail::tl_concat_impl< type_list< LhsTs... >, type_list< RhsTs... > >Concatenates two lists
 Ccaf::detail::tl_cons< What, List >Alias for tl_push_front<List, What>
 Ccaf::detail::tl_count< List, Pred >Counts the number of elements in the list which satisfy a predicate
 Ccaf::detail::tl_count_not< List, Pred >Counts the number of elements in the list which satisfy a predicate
 Ccaf::detail::tl_count_type< List, T >Counts the number of elements in the list which are equal to T
 Ccaf::detail::tl_distinct< List >Creates a new list from List without any duplicate elements
 Ccaf::detail::tl_empty< List >Tests whether a list is empty
 Ccaf::detail::tl_equal< ListA, ListB >Tests whether ListA contains the same elements as ListB and vice versa
 Ccaf::detail::tl_exists< List, Pred >Tests whether a predicate holds for some of the elements of a list
 Ccaf::detail::tl_filter< type_list< T... >, Pred >Create a new list containing all elements which satisfy Pred
 Ccaf::detail::tl_filter_not< List, Pred >Creates a new list containing all elements which do not satisfy Pred
 Ccaf::detail::tl_filter_not_type< List, Type >Creates a new list containing all elements which are not equal to Type
 Ccaf::detail::tl_filter_type< List, Type >Creates a new list containing all elements which are equal to Type
 Ccaf::detail::tl_find< List, Pred >Finds the first element satisfying Pred beginning at index Pos
 Ccaf::detail::tl_find_impl< Pred, Ts >Finds the first element of type What beginning at index Pos
 Ccaf::detail::tl_forall< List, Pred >Tests whether a predicate holds for all elements of a list
 Ccaf::detail::tl_from< class >Construct a type list from types that take a list of variadic template arguments
 Ccaf::detail::tl_head< List >Gets the first element of List
 Ccaf::detail::tl_index_of< List, T >Finds the first element satisfying Pred beginning at index Pos
 Ccaf::detail::tl_index_of_impl< Pos, X, Ts >Finds the first element of type What beginning at index Pos
 Ccaf::detail::tl_index_where< List, Pred >Finds the first element satisfying a given predicate
 Ccaf::detail::tl_is_distinct< List >Tests whether a list is distinct
 Ccaf::detail::tl_map< List, Funs >Creates a new list by applying a "template function" to each element
 Ccaf::detail::tl_map_conditional< List, Trait, TRes, Funs >Creates a new list by applying a Fun to each element which returns TraitResult for Trait
 Ccaf::detail::tl_pad_left< List, NewSize, FillType >Resizes the list to contain NewSize elements and uses FillType to initialize prepended elements with
 Ccaf::detail::tl_pad_right< List, NewSize, FillType >Resizes the list to contain NewSize elements and uses FillType to initialize the new elements with
 Ccaf::detail::tl_pop_back< List >Creates a new list wih all but the last element of List
 Ccaf::detail::tl_prepend< type_list< T... >, What >Creates a new list with What prepended to List
 Ccaf::detail::tl_push_back< type_list< ListTs... >, What >Appends What to given list
 Ccaf::detail::tl_push_front< type_list< ListTs... >, What >Appends What to given list
 Ccaf::detail::tl_replace_back< List, Back, Intermediate >Creates a new list with all but the last element of List and append T to the new list
 Ccaf::detail::tl_reverse< List >Creates a new list wih elements in reversed order
 Ccaf::detail::tl_right< List, NewSize, OldSize >Creates a new list containing the last N elements
 Ccaf::detail::tl_size< List >Gets the number of template parameters of List
 Ccaf::detail::tl_slice< List, First, Last >Creates a new list from range (First, Last]
 Ccaf::detail::tl_tail< List >Gets the tail of List
 Ccaf::detail::tl_trim< List, What >Removes trailing What elements from the end
 Ccaf::detail::tl_zip< ListA, ListB, Fun >Zips two lists of equal size
 Ccaf::detail::tl_zip_right< ListA, ListB, Fun, N >Equal to zip(right(ListA, N), right(ListB, N), Fun)
 Ccaf::detail::transfer_const< T, U >Transfers const from T to U. U remains unchanged if T is not const
 Ccaf::detail::type_at< N, Ts >Gets the Nth element of the template parameter pack Ts
 Ccaf::detail::type_list< Ts >A list of types
 Ccaf::detail::unique_function< Signature >A move-only replacement for std::function
 Ccaf::detail::unique_function< R(Ts...)>::wrapperFunction object that dispatches application with a virtual member function
 Ccaf::detail::unordered_flat_map< Key, T, Allocator >A map abstraction with an unsorted std::vector providing O(n) lookup
 Ccaf::dictionary< V >Maps strings to values of type V, but unlike std::map<std::string, V> accepts string_view for looking up keys efficiently
 Ccaf::down_msgSent to all actors monitoring an actor when it is terminated
 Ccaf::downstream< T >Grants access to an output stream buffer
 Ccaf::downstream_managerManages downstream communication for a stream_manager
 Ccaf::downstream_manager::path_predicatePredicate object for paths
 Ccaf::downstream_manager::path_visitorFunction object for iterating over all paths
 Ccaf::downstream_msg::batchTransmits stream data
 Ccaf::downstream_msg::closeOrderly shuts down a stream after receiving an ACK for the last batch
 Ccaf::downstream_msg::forced_closePropagates a fatal error from sources to sinks
 Ccaf::durationTime duration consisting of a time_unit and a 64 bit unsigned integer
 Ccaf::dynamically_typed_actor_baseMarker type for dynamically typed actors
 Ccaf::execution_unitIdentifies an execution unit, e.g., a worker thread of the scheduler
 Ccaf::exit_msgSent to all links when an actor is terminated
 Ccaf::expected< T >Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error
 Ccaf::expected< void >The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool
 Ccaf::extend< Base, Derived >Allows convenient definition of types using mixins
 Ccaf::function_view< Actor >A function view for an actor hides any messaging from the caller
 Ccaf::fused_downstream_manager< T, Ts >::non_owning_ptrState held for each slot
 Ccaf::group_down_msgSent to all members of a group when it goes offline
 Ccaf::group_moduleInterface for user-defined multicast implementations
 Ccaf::has_make_error< T >Evaluates to true if T is an enum with a free function make_error for converting it to an error
 Ccaf::has_sum_type_access< T >Evaluates to true if T specializes sum_type_access
 Ccaf::has_type_id< T >Evaluates to true if any of these statements holds true:
 Ccaf::illegal_message_elementMarker class identifying classes in CAF that are not allowed to be used as message element
 Ccaf::inbound_pathState for a path to an upstream actor (source)
 Ccaf::inbound_path::stats_tStores statistics for measuring complexity of incoming batches
 Ccaf::inbound_path::stats_t::calculation_resultWraps the resulf of stats_t::calculate()
 Ccaf::inbound_path::stats_t::measurementWraps a time measurement for a single processed batch
 Ccaf::inbound_stream_slot< In >Wraps a stream slot ID for inbound paths with the full type information of the path creation
 Ccaf::index_mappingMarker for representing placeholders at runtime
 Ccaf::infer_handle_from_class< T, bool >Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced
 Ccaf::infer_handle_from_fun< F, Trait >Deduces an actor handle type from a function or function object
 Ccaf::infinite_tRepresents an infinite amount of timeout for specifying "invalid" timeouts
 Ccaf::intrusive::drr_cached_queue< Policy >A Deficit Round Robin queue with an internal cache for allowing skipping consumers
 Ccaf::intrusive::fifo_inbox< Policy >A FIFO inbox that combines an efficient thread-safe LIFO inbox with a FIFO queue for re-ordering incoming messages
 Ccaf::intrusive::lifo_inbox< Policy >An intrusive, thread-safe LIFO queue implementation for a single reader with any number of writers
 Ccaf::intrusive::new_round_resultReturns the state of a consumer from new_round
 Ccaf::intrusive::singly_linked< T >Intrusive base for singly linked types that allows queues to use T with dummy nodes
 Ccaf::intrusive::task_queue< Policy >A singly-linked FIFO queue for storing tasks of varying size
 Ccaf::intrusive::wdrr_dynamic_multiplexed_queue< Policy >A work queue that internally multiplexes any number of DRR queues
 Ccaf::intrusive::wdrr_fixed_multiplexed_queue< Policy, Q, Qs >A work queue that internally multiplexes any number of DRR queues
 Ccaf::intrusive_cow_ptr< T >An intrusive, reference counting smart pointer implementation with copy-on-write optimization
 Ccaf::intrusive_ptr< T >An intrusive, reference counting smart pointer implementation
 Ccaf::io::acceptor_closed_msgSignalizes that a broker acceptor has been closed
 Ccaf::io::acceptor_passivated_msgSignalizes that an acceptor has entered passive mode
 Ccaf::io::basp::headerThe header of a Binary Actor System Protocol (BASP) message
 Ccaf::io::basp::instanceDescribes a protocol instance managing multiple connections
 Ccaf::io::basp::instance::calleeProvides a callback-based interface for certain BASP events
 Ccaf::io::basp::message_queueEnforces strict order of message delivery, i.e., deliver messages in the same order as if they were deserialized by a single thread
 Ccaf::io::basp::message_queue::actor_msgRequest for sending a message to an actor at a later time
 Ccaf::io::basp::routing_tableStores routing information for a single broker participating as BASP peer and provides both direct and indirect paths
 Ccaf::io::basp::routing_table::routeDescribes a routing path to a node
 Ccaf::io::basp::workerDeserializes payloads for BASP messages asynchronously
 Ccaf::io::broker_servant< Base, Handle, SysMsgType >Base class for scribe and doorman
 Ccaf::io::connection_closed_msgSignalizes that a broker connection has been closed
 Ccaf::io::connection_passivated_msgSignalizes that a connection has entered passive mode
 Ccaf::io::data_transferred_msgSignalizes that a certain amount of bytes has been written
 Ccaf::io::datagram_sent_msgSignalizes that a datagram with a certain size has been sent
 Ccaf::io::datagram_servant_closed_msgSignalizes that a datagram endpoint has entered passive mode
 Ccaf::io::datagram_servant_passivated_msgSignalizes that a datagram sink has entered passive mode
 Ccaf::io::network::datagram_handler_impl< ProtocolPolicy >A concrete datagram_handler with a technology-dependent policy
 Ccaf::io::network::event_handlerA socket I/O event handler
 Ccaf::io::network::event_handler::stateStores various status flags and user-defined config parameters
 Ccaf::io::network::interfacesUtility class bundling access to network interface names and addresses
 Ccaf::io::network::ip_endpointA hashable wrapper for a sockaddr storage
 Ccaf::io::network::multiplexer::supervisorMakes sure the multipler does not exit its event loop until the destructor of supervisor has been called
 Ccaf::io::network::protocolBundles protocol information for network and transport layer communication
 Ccaf::io::network::receive_bufferA container that does not call constructors and destructors for its values
 Ccaf::io::new_connection_msgSignalizes a newly accepted connection from a broker
 Ccaf::io::new_data_msgSignalizes newly arrived data for a broker
 Ccaf::io::new_datagram_msgSignalizes that a datagram with a certain size has been sent
 Ccaf::is_actor_handle< T >Checks whether T is an actor or a typed_actor<...>
 Ccaf::is_error_code_enum< T >Customization point for enabling conversion from an enum type to an error or error_code
 Ccaf::is_typed_actor< T >Evaluates to true if T is a typed_actor<...>
 Ccaf::logger::configCombines various logging-related flags and parameters into a bitfield
 Ccaf::logger::eventEncapsulates a single logging event
 Ccaf::logger::fieldRepresents a single format string field
 Ccaf::logger::line_builderUtility class for building user-defined log messages with CAF_ARG
 Ccaf::mailbox_category_corrector<... >Corrects the message ID for down- and upstream messages to make sure the category for a mailbox_element matches its content
 Ccaf::mailbox_element_vals< Ts >Encapsulates arbitrary data in a message element
 Ccaf::mailbox_element_view< Ts >Provides a view for treating arbitrary data as message element
 Ccaf::memory_managedThis 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
 Ccaf::message::cli_argStores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback
 Ccaf::message::cli_resStores the result of message::extract_opts
 Ccaf::message_builderProvides a convenient interface for createing message objects from a series of values using the member function append
 Ccaf::message_handlerA partial function implementation used to process a message
 Ccaf::message_viewRepresents an object pointing to a type_erased_tuple that is convertible to a message
 Ccaf::meta::annotationType tag for all meta annotations in CAF
 Ccaf::mixin::behavior_changer< Base, Subtype >A behavior_changer is an actor that supports self->become(...) and self->unbecome()
 Ccaf::mixin::requester< Base, Subtype >A requester is an actor that supports self->request(...)
 Ccaf::mixin::sender< Base, Subtype >A sender is an actor that supports self->send(...)
 Ccaf::mixin::subscriber_baseMarker for subscriber
 Ccaf::named_actor_configStores a flow-control configuration
 Ccaf::no_error_tHelper class to construct an expected<T> that represents no error
 Ccaf::no_stages_tConvenience tag type for producing empty forwarding stacks
 Ccaf::node_idA node ID is an opaque value for representing CAF instances in the network
 Ccaf::non_blocking_actor_baseMarker type for non-blocking actors
 Ccaf::open_stream_msgDemands the receiver to open a new stream from the sender to the receiver
 Ccaf::optional< T >A C++17 compatible optional implementation
 Ccaf::optional< T & >Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead
 Ccaf::outbound_pathState for a single path to a sink of a downstream_manager
 Ccaf::outbound_stream_slot< OutputType, HandshakeArgs >Wraps a stream slot ID for outbound paths with the full type information of the path creation
 Ccaf::param< T >Represents a message handler parameter of type T and guarantees copy-on-write semantics
 Ccaf::param_decay< T >Convenience struct for remove_param<std::decay<T>>
 Ccaf::parser_state< Iterator, Sentinel >Stores all informations necessary for implementing an FSM-based parser
 Ccaf::policy::arg< Ts >Provides a wrapper to pass policy types as values to functions
 Ccaf::policy::categorizedConfigures a cached WDRR fixed multiplexed queue for dispatching to four nested queue (one for each message category type)
 Ccaf::policy::downstream_messagesConfigures a dynamic WDRR queue for holding downstream messages
 Ccaf::policy::downstream_messages::nestedConfigures a nested DRR queue
 Ccaf::policy::normal_messagesConfigures a cached DRR queue for holding asynchronous messages with default priority
 Ccaf::policy::profiled< Policy >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
 Ccaf::policy::scheduler_policyThis concept class describes a policy for worker and coordinator of the scheduler
 Ccaf::policy::scheduler_policy::coordinator_dataPolicy-specific data fields for the coordinator
 Ccaf::policy::scheduler_policy::worker_dataPolicy-specific data fields for the worker
 Ccaf::policy::tcpPolicy object for wrapping default TCP operations
 Ccaf::policy::udpPolicy object for wrapping default UDP operations
 Ccaf::policy::unprofiledThis class is intended to be used as a base class for actual polices
 Ccaf::policy::upstream_messagesConfigures a DRR queue for holding upstream messages
 Ccaf::policy::urgent_messagesConfigures a cached DRR queue for holding asynchronous messages with default priority
 Ccaf::proxy_registryGroups a (distributed) set of actors and allows actors in the same namespace to exchange messages
 Ccaf::proxy_registry::backendResponsible for creating proxy actors
 Ccaf::ratio_to_time_unit_helper< Num, Denom >Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes
 Ccaf::remove_param< T >Unpacks param<T> to T
 Ccaf::response_handle< Self, Output, IsBlocking >This helper class identifies an expected response message and enables request(...).then(...)
 Ccaf::response_promiseA response promise can be used to deliver a uniquely identifiable response message from the server (i.e
 Ccaf::response_type< Ts, Xs >Defines:
 Ccaf::response_type_unbox< Ts, Xs >Unboxes Xs and calls response_type
 Ccaf::resumableA cooperatively executed task managed by one or more instances of execution_unit
 Ccaf::runtime_settings_mapThread-safe container for mapping atoms to arbitrary settings
 Ccaf::scheduled_actor::mailbox_policyConfigures the FIFO inbox with four nested queues:
 Ccaf::scheduled_actor::mailbox_visitorConsumes messages from the mailbox
 Ccaf::scheduler::profiled_coordinator< Policy >A coordinator which keeps fine-grained profiling state about its workers and their jobs
 Ccaf::scoped_actorA scoped handle to a blocking actor
 Ccaf::select_callback< F, Args >Utility class for selecting a callback_impl
 Ccaf::select_config_value_access< T, Hint >Delegates to config_value_access for all specialized versions
 Ccaf::select_config_value_access< T, select_config_value_hint::is_integral >Catches all non-specialized integer types
 Ccaf::select_config_value_access< T, select_config_value_hint::is_list >Catches all non-specialized list types
 Ccaf::select_config_value_access< T, select_config_value_hint::is_map >Catches all non-specialized map types
 Ccaf::serializer_impl< Container >Implements the serializer interface with a binary serialization protocol
 Ccaf::skip_tDefault handler function that leaves messages in the mailbox
 Ccaf::span< T >A C++11/14 drop-in replacement for C++20's std::span without support for static extents
 Ccaf::spawn_optionsStores options passed to the spawn function family
 Ccaf::stateful_actor< State, Base >An event-based actor with managed state
 Ccaf::statically_typed_actor_baseMarker type for statically typed actors
 Ccaf::stream< T >Empty marker type for streaming handshakes
 Ccaf::stream_buffer< CharT, Traits >The base class for all stream buffer implementations
 Ccaf::stream_finalize_trait< Fun, State, AcceptsTwoArgs >Dispatches a finalize call to a function taking either one or two arguments
 Ccaf::stream_finalize_trait< Fun, State, false >Specializes the trait for callbacks that only take the state
 Ccaf::stream_finalize_trait< Fun, State, true >Specializes the trait for callbacks that take state and error
 Ccaf::stream_sink_driver< Input >Identifies an unbound sequence of messages
 Ccaf::stream_sink_trait< Fun >Defines required type aliases for stream sinks
 Ccaf::stream_sink_trait_base< State, In >Base type for all sink traits
 Ccaf::stream_source_driver< DownstreamManager >Identifies an unbound sequence of messages
 Ccaf::stream_source_trait< Pull >Deduces the output type and the state type for a stream source from its pull implementation
 Ccaf::stream_stage_driver< Input, DownstreamManager >Encapsulates user-provided functionality for generating a stream stage
 Ccaf::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
 Ccaf::sum_type_access< T >Specializing this trait allows users to enable holds_alternative, get, get_if, and visit for any user-defined sum type
 Ccaf::tag::boxing_typeAllows the testing DSL to recognize that subtypes are boxing content types
 Ccaf::thread_hookInterface to define thread hooks
 Ccaf::timeout_msgSignalizes a timeout event
 Ccaf::type_by_id< V >Maps the globally unique ID V to a type (inverse to ::type_id)
 Ccaf::type_erased_tupleRepresents a tuple of type-erased values
 Ccaf::type_erased_valueRepresents a single type-erased value
 Ccaf::type_erased_value_factoryConverts values to type-erased values
 Ccaf::type_id< T >Maps the type T to a globally unique ID
 Ccaf::type_name< T >Convenience type that resolves to type_name_by_id<type_id_v<T>>
 Ccaf::type_name< void >Convenience specialization that enables generic code to not treat void manually
 Ccaf::type_name_by_id< V >Maps the globally unique ID V to a type name
 Ccaf::type_nr< T, IsIntegral >Computes the type number for T
 Ccaf::typed_actor< Sigs >Identifies a statically typed actor
 Ccaf::typed_actor_view_baseTag type for typed_actor_view
 Ccaf::typed_behavior< Sigs >::unsafe_initEmpty struct tag for constructing from an untyped behavior
 Ccaf::typed_event_based_actor< Sigs >A cooperatively scheduled, event-based actor implementation with static type-checking
 Ccaf::typed_response_promise< Ts >A response promise can be used to deliver a uniquely identifiable response message from the server (i.e
 Ccaf::unbox_message_element< T, IsPlaceholderRes >Unboxes atom constants, i.e., converts atom_constant<V> to V
 Ccaf::upstream_msg::ack_batchCumulatively acknowledges received batches and signalizes new demand from a sink to its source
 Ccaf::upstream_msg::ack_openAcknowledges a previous open message and finalizes a stream handshake
 Ccaf::upstream_msg::dropAsks the source to discard any remaining credit and close this path after receiving an ACK for the last batch
 Ccaf::upstream_msg::forced_dropPropagates a fatal error from sinks to sources
 Ccaf::uri::authority_typeBundles the authority component of the URI, i.e., userinfo, host, and port
 Ccaf::variant< Ts >A variant represents always a valid value of one of the types Ts...
 Ccaf::weak_intrusive_ptr< T >An intrusive, reference counting smart pointer implementation
 Ccaf::detail::callable_trait< R(Ts...)>
 Ccaf::callback< Ts... >
 Ccaf::detail::comparable< accept_handle >
 Ccaf::detail::comparable< accept_handle, invalid_accept_handle_t >
 Ccaf::detail::comparable< actor >
 Ccaf::detail::comparable< actor, actor_addr >
 Ccaf::detail::comparable< actor, strong_actor_ptr >
 Ccaf::detail::comparable< actor_addr >
 Ccaf::detail::comparable< actor_addr, abstract_actor * >
 Ccaf::detail::comparable< actor_addr, actor_control_block * >
 Ccaf::detail::comparable< actor_addr, strong_actor_ptr >
 Ccaf::detail::comparable< actor_addr, weak_actor_ptr >
 Ccaf::detail::comparable< connection_handle >
 Ccaf::detail::comparable< connection_handle, invalid_connection_handle_t >
 Ccaf::detail::comparable< cow_tuple< Ts... > >
 Ccaf::detail::comparable< cow_tuple< Ts... >, std::tuple< Ts... > >
 Ccaf::detail::comparable< datagram_handle >
 Ccaf::detail::comparable< datagram_handle, invalid_datagram_handle_t >
 Ccaf::detail::comparable< Derived >
 Ccaf::detail::comparable< error >
 Ccaf::detail::comparable< group >
 Ccaf::detail::comparable< group, invalid_group_t >
 Ccaf::detail::comparable< ipv4_address >
 Ccaf::detail::comparable< ipv4_endpoint >
 Ccaf::detail::comparable< ipv4_subnet >
 Ccaf::detail::comparable< ipv6_address >
 Ccaf::detail::comparable< ipv6_address, ipv4_address >
 Ccaf::detail::comparable< ipv6_endpoint >
 Ccaf::detail::comparable< ipv6_endpoint, ipv4_endpoint >
 Ccaf::detail::comparable< ipv6_subnet >
 Ccaf::detail::comparable< message_id >
 Ccaf::detail::comparable< none_t >
 Ccaf::detail::comparable< stream_slots >
 Ccaf::detail::comparable< string_view >
 Ccaf::detail::comparable< Subtype >
 Ccaf::detail::comparable< Subtype, InvalidType >
 Ccaf::detail::comparable< unit_t >
 Ccaf::detail::comparable< uri >
 Ccaf::detail::comparable< uri, string_view >
 Ccaf::composable_behavior_base< Clauses >
 Ccaf::composed_type< detail::type_list< typed_mpi< In, Out >, Xs... >, Ys, detail::type_list< Zs... >, Rs >
 Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, detail::type_list< Rs..., typed_mpi< detail::type_list< In... >, output_tuple< MapsTo... > > > >
 Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, Rs >
 Ccaf::config_value_field< config_value_field_trait< Get >::object_type >
 Ccaf::config_value_field< object_type >
 Ccaf::config_value_field< T >
 Ccaf::config_value_field< value_type >
 Ccaf::data_processor< deserializer >
 Ccaf::data_processor< serializer >
 Ccaf::io::network::datagram_handler_impl< caf::policy::udp >
 Ccaf::default_actor_traits< T, std::is_base_of< abstract_actor, T >::value >
 Ccaf::default_sum_type_access< variant< Ts... > >
 Ccaf::delegated< stream< DownstreamManager::output_type >, Ts... >
 Ccaf::delegated< void >
 Ccaf::dictionary< config_value >
 Ccaf::expected< caf::config_value >
 Ccaf::intrusive::fifo_inbox< mailbox_policy >
 Ccaf::intrusive_cow_ptr< detail::dynamic_message_data >
 Ccaf::intrusive_cow_ptr< impl >
 Ccaf::intrusive_ptr< abstract_group >
 Ccaf::intrusive_ptr< actor_control_block >
 Ccaf::intrusive_ptr< caf::io::scribe >
 Ccaf::intrusive_ptr< caf::logger >
 Ccaf::intrusive_ptr< caf::ref_counted >
 Ccaf::intrusive_ptr< caf::resumable >
 Ccaf::intrusive_ptr< const detail::uri_impl >
 Ccaf::intrusive_ptr< data >
 Ccaf::intrusive_ptr< datagram_manager >
 Ccaf::intrusive_ptr< datagram_servant >
 Ccaf::intrusive_ptr< detail::behavior_impl >
 Ccaf::intrusive_ptr< detail::dynamic_message_data >
 Ccaf::intrusive_ptr< detail::uri_impl >
 Ccaf::intrusive_ptr< doorman >
 Ccaf::intrusive_ptr< impl >
 Ccaf::intrusive_ptr< manager_type >
 Ccaf::intrusive_ptr< scribe >
 Ccaf::intrusive_ptr< sink_type >
 Ccaf::intrusive_ptr< source_type >
 Ccaf::intrusive_ptr< stage_type >
 Ccaf::intrusive_ptr< stream_manager >
 Ccaf::detail::is_one_of< T, Ts... >
 Ccaf::intrusive::lifo_inbox< policy_type >
 Ccaf::mailbox_element_vals< SysMsgType >
 Ccaf::optional< caf::response_promise >
 Ccaf::optional< size_t >
 Ccaf::optional< value_type >
 Ccaf::detail::path_state< caf::unit_t, T >
 Ccaf::response_type< detail::type_list< Ts... >, Xs... >
 Ccaf::response_type< Ts, message >
 Ccaf::response_type< Ts, Xs... >
 Ccaf::intrusive::singly_linked< mailbox_element >
 Ccaf::stateful_actor< State, typename State::actor_base >
 Ccaf::stream_buffer< char, std::char_traits< char > >
 Ccaf::stream_buffer< Container::value_type, std::char_traits< Container::value_type > >
 Ccaf::intrusive::task_queue< policy_type >
 Ccaf::detail::tl_apply< signatures, typed_actor_pointer >
 Ccaf::detail::tl_replace_back< type_list< T1, Ts... >, Back, type_list< Us..., T0 > >
 Ccaf::typed_actor< replies_to< publish_atom, uint16_t, strong_actor_ptr, std::set< std::string >, std::string, bool > ::with< uint16_t >, replies_to< open_atom, uint16_t, std::string, bool > ::with< uint16_t >, replies_to< connect_atom, std::string, uint16_t > ::with< node_id, strong_actor_ptr, std::set< std::string > >, reacts_to< unpublish_atom, actor_addr, uint16_t >, reacts_to< close_atom, uint16_t >, replies_to< spawn_atom, node_id, std::string, message, std::set< std::string > > ::with< strong_actor_ptr >, replies_to< get_atom, node_id >::with< node_id, std::string, uint16_t > >
 Ccaf::typed_actor< Ts... >
 Ccaf::detail::unique_function< caf::behavior(local_actor *)>
 Ccaf::detail::unique_function< R(Ts...)>
 Ccaf::detail::unique_function< void(local_actor *)>
 Ccaf::detail::unordered_flat_map< caf::message_id, caf::behavior >
 Ccaf::detail::unordered_flat_map< std::string, std::string >
 Ccaf::detail::unordered_flat_map< stream_slot, non_owning_ptr >
 Ccaf::detail::unordered_flat_map< stream_slot, path_state >
 Ccaf::detail::unordered_flat_map< stream_slot, unique_path_ptr >
 Ccaf::variant< ack_open, ack_batch, drop, forced_drop >
 Ccaf::variant< batch, close, forced_close >
 Ccaf::variant< std::string, ip_address >
 Ccaf::weak_intrusive_ptr< actor_control_block >