caf Namespace Reference

Root namespace of libcaf. More...

Namespaces
namespace	mixin
	Contains mixin classes implementing several actor traits.
namespace	exit_reason
	Contains all predefined exit reasons.
namespace	policy
	Contains policies encapsulating characteristics or algorithms.
namespace	io
	Contains all IO-related classes and functions.

Classes
class	abstract_actor
	Base class for all actor implementations. More...
class	abstract_channel
	Interface for all message receivers. More...
class	abstract_composable_behavior
	Marker type that allows CAF to spawn actors from composable states. More...
class	abstract_group
	A multicast group. More...
class	actor
	Identifies an untyped actor. More...
class	actor_addr
	Stores the address of typed as well as untyped actors. More...
class	actor_clock
	A monotonic clock for scheduling timeouts and delayed messages. More...
class	actor_config
	Stores spawn-time flags and groups. More...
class	actor_control_block
	Actors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it. More...
class	actor_ostream
	Provides support for thread-safe output operations on character streams. More...
class	actor_pool
	An actor poool is a lightweight abstraction for a set of workers. More...
class	actor_profiler
	A profiler which provides a set of callbacks for several actor operations in order to collect fine-grained profiling state about the system. More...
class	actor_proxy
	Represents an actor running on a remote machine, or different hardware, or in a separate process. More...
class	actor_registry
	A registry is used to associate actors to IDs or atoms (names). More...
class	actor_system
	Actor environment including scheduler, registry, and optional components such as a middleman. More...
class	actor_system_config
	Configures an actor_system on startup. More...
struct	dynamically_typed_actor_base
	Marker type for dynamically typed actors. More...
struct	statically_typed_actor_base
	Marker type for statically typed actors. More...
struct	blocking_actor_base
	Marker type for blocking actors. More...
struct	non_blocking_actor_base
	Marker type for non-blocking actors. More...
struct	default_actor_traits
	Default implementation of actor_traits for non-actors (SFINAE-friendly). More...
struct	default_actor_traits< T, true >
	Default implementation of actor_traits for regular actors. More...
struct	actor_traits
	Provides uniform access to properties of actor types. More...
struct	allowed_unsafe_message_type
	Template specializations can whitelist individual types for unsafe message passing operations. More...
struct	atom_constant
	Lifts an atom_value to a compile-time constant. More...
class	attachable
	Callback utility class. More...
class	behavior
	Describes the behavior of an actor, i.e., provides a message handler and an optional timeout. More...
class	binary_deserializer
	Implements the deserializer interface with a binary serialization protocol. More...
class	blocking_actor
	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing. More...
class	buffered_downstream_manager
	Mixin for streams with any number of downstreams. More...
class	byte_address
	Base type for addresses based on a byte representation such as IP or Ethernet addresses. More...
class	callback
	Describes a simple callback, usually implemented via lambda expression. More...
class	callback_impl
	Utility class for wrapping a function object of type Base. More...
struct	select_callback
	Utility class for selecting a callback_impl. More...
class	composable_behavior_base
	Generates an interface class that provides operator(). More...
class	composable_behavior
	Base type for composable actor states. More...
class	composable_behavior_based_actor
	Implementation class for spawning composable states directly as actors. More...
struct	composed_type
	Computes the type for f*g (actor composition). More...
class	config_option
	Defines a configuration option for the application. More...
class	config_option_adder
	Adds config options of the same category to a config_option_set. More...
class	config_option_set
	A set of config_option objects that parses CLI arguments into a settings object. More...
class	config_value
	A type for config parameters with similar interface to a variant. More...
struct	select_config_value_access
	Delegates to config_value_access for all specialized versions. More...
struct	select_config_value_access< T, select_config_value_hint::is_integral >
	Catches all non-specialized integer types. More...
struct	select_config_value_access< T, select_config_value_hint::is_list >
	Catches all non-specialized list types. More...
struct	select_config_value_access< T, select_config_value_hint::is_map >
	Catches all non-specialized map types. More...
struct	config_value_access< std::tuple< Ts... > >
	Implements automagic unboxing of std::tuple<Ts...> from a heterogeneous config_value::list. More...
class	config_value_adaptor
	Interfaces between a user-defined type and CAF config values by going through intermediate values. More...
struct	config_value_adaptor_access
	Enables user-defined types in config files and on the CLI by converting them to and from tuples. More...
struct	config_value_adaptor_field
	Describes a field of type T of an adaptor. More...
class	config_value_field
	Describes a field of Object. More...
struct	config_value_object_access
	Enables user-defined types in config files and on the CLI by converting them to and from config_value::dictionary. More...
class	cow_tuple
	A copy-on-write tuple implementation. More...
class	data_processor
	A data processor translates an object into a format that can be stored or vice versa. More...
struct	deep_to_string_t
	Wrapper to deep_to_string for using the function as an inspector. More...
struct	default_downstream_manager
	Selects a downstream manager implementation based on the signature of various handlers. More...
struct	default_sum_type_access
	Allows specializing the sum_type_access trait for any type that simply wraps a variant and exposes it with a get_data() member function. More...
class	delegated
	Helper class to indicate that a request has been forwarded. More...
class	deserializer
	Technology-independent deserialization interface. More...
class	typed_actor
	Identifies a statically typed actor. More...
class	dictionary
	Maps strings to values of type V, but unlike std::map<std::string, V> accepts string_view for looking up keys efficiently. More...
class	downstream
	Grants access to an output stream buffer. More...
class	downstream_manager
	Manages downstream communication for a stream_manager. More...
class	downstream_manager_base
	The default downstream manager base stores outbound paths in an unordered map. More...
struct	downstream_msg
	Stream messages that travel downstream, i.e., batches and close messages. More...
struct	ratio_to_time_unit_helper
	Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes. More...
class	duration
	Time duration consisting of a time_unit and a 64 bit unsigned integer. More...
struct	has_make_error
	Evaluates to true if T is an enum with a free function make_error for converting it to an error. More...
class	error
	A serializable type for storing error codes with category and optional, human-readable context information. More...
class	event_based_actor
	A cooperatively scheduled, event-based actor implementation. More...
class	execution_unit
	Identifies an execution unit, e.g., a worker thread of the scheduler. More...
struct	no_error_t
	Helper class to construct an expected<T> that represents no error. More...
class	expected
	Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error. More...
class	expected< void >
	The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool. More...
struct	extend
	Allows convenient definition of types using mixins. More...
class	forwarding_actor_proxy
	Implements a simple proxy forwarding all operations to a manager. More...
class	function_view
	A function view for an actor hides any messaging from the caller. More...
class	fused_downstream_manager
	A downstream manager that delegates to any number of sub-managers. More...
class	intrusive_cow_ptr
	An intrusive, reference counting smart pointer implementation with copy-on-write optimization. More...
class	intrusive_ptr
	An intrusive, reference counting smart pointer implementation. More...
class	optional
	A C++17 compatible optional implementation. More...
class	param
	Represents a message handler parameter of type T and guarantees copy-on-write semantics. More...
class	serializer_impl
	Implements the serializer interface with a binary serialization protocol. More...
class	span
	A C++11/14 drop-in replacement for C++20's std::span without support for static extents. More...
class	stream
	Empty marker type for streaming handshakes. More...
class	weak_intrusive_ptr
	An intrusive, reference counting smart pointer implementation. More...
struct	parser_state
	Stores all informations necessary for implementing an FSM-based parser. More...
class	typed_event_based_actor
	A cooperatively scheduled, event-based actor implementation with static type-checking. More...
class	typed_response_promise
	A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More...
class	variant
	A variant represents always a valid value of one of the types Ts.... More...
class	stateful_actor
	An event-based actor with managed state. More...
class	group_module
	Interface for user-defined multicast implementations. More...
struct	illegal_message_element
	Marker class identifying classes in CAF that are not allowed to be used as message element. More...
class	inbound_path
	State for a path to an upstream actor (source). More...
struct	index_mapping
	Marker for representing placeholders at runtime. More...
struct	infer_handle_from_fun
	Deduces an actor handle type from a function or function object. More...
struct	infer_handle_from_class
	Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced. More...
class	ipv4_endpoint
	An IP endpoint that contains an ::ipv4_address and a port. More...
class	ipv6_endpoint
	An IP endpoint that contains an ::ipv6_address and a port. More...
struct	is_actor_handle
	Checks whether T is an actor or a typed_actor<...>. More...
struct	is_error_code_enum
	Customization point for enabling conversion from an enum type to an error or error_code. More...
struct	is_typed_actor
	Evaluates to true if T is a typed_actor<...>. More...
class	logger
	Centrally logs events from all actors in an actor system. More...
struct	mailbox_category_corrector
	Corrects the message ID for down- and upstream messages to make sure the category for a mailbox_element matches its content. More...
class	mailbox_element_vals
	Encapsulates arbitrary data in a message element. More...
class	mailbox_element_view
	Provides a view for treating arbitrary data as message element. More...
struct	unbox_message_element
	Unboxes atom constants, i.e., converts atom_constant<V> to V. More...
class	make_sink_result
	Returns a stream sink with the slot ID of its first inbound path. More...
class	make_source_result
	Returns a stream source with the slot ID of its first outbound path. More...
class	make_stage_result
	Returns a stream stage with the slot IDs of its first in- and outbound paths. More...
struct	type_erased_value_factory
	Converts values to type-erased values. More...
class	memory_managed
	This base enables derived classes to enforce a different allocation strategy than new/delete by providing a virtual protected request_deletion() function and non-public destructor. More...
class	message
	Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type. More...
class	message_builder
	Provides a convenient interface for createing message objects from a series of values using the member function append. More...
class	message_handler
	A partial function implementation used to process a message. More...
class	message_id
	Bundles various flags along with an optional request ID. More...
class	message_view
	Represents an object pointing to a type_erased_tuple that is convertible to a message. More...
class	monitorable_actor
	Base class for all actor implementations. More...
struct	named_actor_config
	Stores a flow-control configuration. More...
struct	no_stages_t
	Convenience tag type for producing empty forwarding stacks. More...
class	node_id
	A node ID is an opaque value for representing CAF instances in the network. More...
struct	none_t
	Represents "nothing", e.g., for clearing an optional by assigning none. More...
class	optional< T & >
	Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead. More...
class	outbound_path
	State for a single path to a sink of a downstream_manager. More...
struct	add_param
	Converts T to param<T> unless T is arithmetic, an atom constant, or a stream handshake. More...
struct	remove_param
	Unpacks param<T> to T. More...
struct	param_decay
	Convenience struct for remove_param<std::decay<T>>. More...
class	proxy_registry
	Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages. More...
class	raw_event_based_actor
	A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages. More...
class	ref_counted
	Base class for reference counted objects with an atomic reference count. More...
class	response_handle
	This helper class identifies an expected response message and enables request(...).then(...). More...
class	response_promise
	A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More...
struct	response_type
	Defines: More...
struct	response_type_unbox
	Unboxes Xs and calls response_type. More...
class	resumable
	A cooperatively executed task managed by one or more instances of execution_unit. More...
class	runtime_settings_map
	Thread-safe container for mapping atoms to arbitrary settings. More...
class	scheduled_actor
	A cooperatively scheduled, event-based actor implementation. More...
class	scoped_actor
	A scoped handle to a blocking actor. More...
class	scoped_execution_unit
	Identifies an execution unit, e.g., a worker thread of the scheduler. More...
class	serializer
	Technology-independent serialization interface. More...
class	skip_t
	Default handler function that leaves messages in the mailbox. More...
class	spawn_options
	Stores options passed to the spawn function family. More...
class	stream_deserializer
	Implements the deserializer interface with a binary serialization protocol. More...
struct	stream_finalize_trait
	Dispatches a finalize call to a function taking either one or two arguments. More...
struct	stream_finalize_trait< Fun, State, false >
	Specializes the trait for callbacks that only take the state. More...
struct	stream_finalize_trait< Fun, State, true >
	Specializes the trait for callbacks that take state and error. More...
class	stream_manager
	Manages a single stream with any number of in- and outbound paths. More...
class	stream_serializer
	Implements the serializer interface with a binary serialization protocol. More...
class	stream_sink_driver
	Identifies an unbound sequence of messages. More...
struct	stream_sink_trait_base
	Base type for all sink traits. More...
struct	stream_sink_trait
	Defines required type aliases for stream sinks. More...
struct	stream_sink_trait< void(State &, In)>
	Specializes the trait for element-wise processing. More...
struct	stream_sink_trait< void(State &, std::vector< In > &)>
	Specializes the trait for batch-wise processing. More...
struct	stream_sink_trait< void(State &, const std::vector< In > &)>
	Specializes the trait for batch-wise processing with const references. More...
struct	stream_slots
	Maps two stream_slot values into a pair for storing sender and receiver slot information. More...
class	inbound_stream_slot
	Wraps a stream slot ID for inbound paths with the full type information of the path creation. More...
class	outbound_stream_slot
	Wraps a stream slot ID for outbound paths with the full type information of the path creation. More...
class	stream_source_driver
	Identifies an unbound sequence of messages. More...
struct	stream_source_trait
	Deduces the output type and the state type for a stream source from its pull implementation. More...
class	stream_stage_driver
	Encapsulates user-provided functionality for generating a stream stage. More...
struct	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. More...
class	stream_buffer
	The base class for all stream buffer implementations. More...
class	arraybuf
	A streambuffer abstraction over a fixed array of bytes. More...
class	containerbuf
	A streambuffer abstraction over a contiguous container. More...
class	string_view
	Drop-in replacement for C++17 std::string_view. More...
struct	sum_type_access
	Specializing this trait allows users to enable holds_alternative, get, get_if, and visit for any user-defined sum type. More...
struct	has_sum_type_access
	Evaluates to true if T specializes sum_type_access. More...
struct	exit_msg
	Sent to all links when an actor is terminated. More...
struct	down_msg
	Sent to all actors monitoring an actor when it is terminated. More...
struct	group_down_msg
	Sent to all members of a group when it goes offline. More...
struct	timeout_msg
	Signalizes a timeout event. More...
struct	open_stream_msg
	Demands the receiver to open a new stream from the sender to the receiver. More...
class	thread_hook
	Interface to define thread hooks. More...
struct	infinite_t
	Represents an infinite amount of timeout for specifying "invalid" timeouts. More...
class	type_erased_tuple
	Represents a tuple of type-erased values. More...
class	empty_type_erased_tuple
	Dummy objects representing empty tuples. More...
class	type_erased_value
	Represents a single type-erased value. More...
struct	type_id
	Maps the type T to a globally unique ID. More...
struct	type_by_id
	Maps the globally unique ID V to a type (inverse to ::type_id). More...
struct	type_name
	Convenience type that resolves to type_name_by_id<type_id_v<T>>. More...
struct	type_name< void >
	Convenience specialization that enables generic code to not treat void manually. More...
struct	type_name_by_id
	Maps the globally unique ID V to a type name. More...
struct	has_type_id
	Evaluates to true if any of these statements holds true: More...
struct	type_nr
	Computes the type number for T. More...
struct	typed_actor_view_base
	Tag type for typed_actor_view. More...
struct	unit_t
	Unit is analogous to void, but can be safely returned, stored, etc. More...
struct	upstream_msg
	Stream messages that flow upstream, i.e., acks and drop messages. More...
class	uri
	A URI according to RFC 3986. More...
struct	sum_type_access< variant< Ts... > >
	Enable holds_alternative, get, get_if, and visit for variant. More...
class	handle
	Base class for IO handles such as accept_handle or connection_handle. More...

Typedefs
using	actor_factory_result = std::pair<strong_actor_ptr, std::set<std::string>>
using	actor_factory = std::function<actor_factory_result (actor_config&, message&)>
using	selfptr_mode_token = spawn_mode_token<spawn_mode::function_with_selfptr>
using	void_mode_token = spawn_mode_token<spawn_mode::function>
using	binary_serializer = serializer_impl<std::vector<char>>
template<class T>
using	signatures_of_t = typename signatures_of<T>::type
using	top_level_cli_parsing_t = std::false_type
	Type of the top_level_cli_parsing constant.
using	nested_cli_parsing_t = std::true_type
	Type of the top_level_cli_parsing constant.
template<class T>
using	select_config_value_access_t
template<class T>
using	deduce_mpi_t = typename detail::dmfou<typename param_decay<T>::type>::type
	Deduces the message passing interface from a function object.
template<class F>
using	default_downstream_manager_t
template<class T, class U = void>
using	enable_if_has_make_error_t
	Convenience alias to detect enums that provide make_error overloads.
template<class T>
using	function_view_flattened_result_t
using	actor_id = uint64_t
using	ip_address = ipv6_address
	An IP address. The address family is IPv6 unless embeds_v4 returns true.
using	ip_endpoint = ipv6_endpoint
	An IP endpoint that contains an ::ipv6_address and a port.
using	ip_subnet = ipv6_subnet
	An IP subnetwork.
using	settings = dictionary<config_value>
using	stream_slot = uint16_t
	Identifies a single stream path in the same way a TCP port identifies a connection over IP.
using	weak_actor_ptr = weak_intrusive_ptr<actor_control_block>
using	strong_actor_ptr = intrusive_ptr<actor_control_block>
using	stream_manager_ptr = intrusive_ptr<stream_manager>
using	type_erased_value_ptr = std::unique_ptr<type_erased_value>
using	mailbox_element_ptr = std::unique_ptr<mailbox_element, detail::disposer>
template<spawn_mode X>
using	spawn_mode_token = std::integral_constant<spawn_mode, X>
template<class Found, class Expected>
using	interface_mismatch_t
	Scans two typed MPI lists for compatibility, returning the index of the first mismatch.
template<class Lockable>
using	unique_lock = std::unique_lock<Lockable>
template<class SharedLockable>
using	upgrade_lock = shared_lock<SharedLockable>
template<class In, class DownstreamManager, class... Ts>
using	make_stage_result_t
	Helper type for defining a make_stage_result from a downstream manager plus additional handshake types.
template<class T>
using	param_t = typename add_param<T>::type
	Convenience alias that wraps T into param<T> unless T is arithmetic, a stream handshake or an atom constant.
using	string_parser_state = parser_state<string_view::iterator>
	Specialization for parsers operating on string views.
using	primitive_variant
template<class... Is>
using	reacts_to = typed_mpi<detail::type_list<Is...>, output_tuple<void>>
template<class Ts, class... Xs>
using	response_type_t = typename response_type<Ts, Xs...>::type
	Computes the response message for input Xs... from the list of message passing interfaces Ts.
template<class Ts, class Xs>
using	response_type_unbox_t = typename response_type_unbox<Ts, Xs>::type
	Computes the response message for input Xs from the list of message passing interfaces Ts.
using	rtti_pair = std::pair<uint16_t, const std::type_info*>
	Bundles the type number with its C++ type_info object.
template<class In>
using	stream_sink_ptr = intrusive_ptr<stream_sink<In>>
template<class Fun>
using	stream_sink_trait_t
	Derives a sink trait from the signatures of Fun and Fin.
template<class DownstreamManager>
using	stream_source_ptr = intrusive_ptr<stream_source<DownstreamManager>>
template<class Pull>
using	stream_source_trait_t
	Convenience alias for extracting the function signature from Pull and passing it to stream_source_trait.
template<class In, class DownstreamManager>
using	stream_stage_ptr = intrusive_ptr<stream_stage<In, DownstreamManager>>
template<class Process>
using	stream_stage_trait_t
	Convenience alias for extracting the function signature from Process and passing it to stream_stage_trait.
using	charbuf = arraybuf<char>
using	vectorbuf = containerbuf<std::vector<char>>
template<class F, class... Ts>
using	sum_type_visit_result_t
using	generic_timeout_definition = timeout_definition<std::function<void()>>
using	timespan = std::chrono::duration<int64_t, std::nano>
	A portable timespan type with nanosecond resolution.
using	timestamp = std::chrono::time_point<std::chrono::system_clock, timespan>
	A portable timestamp with nanosecond resolution anchored at the UNIX epoch.
using	type_id_t = uint16_t
	Internal representation of a type ID.
using	sorted_builtin_types
	Compile-time list of all built-in types.
template<class... Ts>
using	is_variant_t = typename is_variant<Ts...>::type
template<class F, class... Ts>
using	variant_visit_result_t

Enumerations
enum class	atom_value : uint64_t
	The value type of atoms.
enum class	byte : uint8_t
	A C++11/14 drop-in replacement for C++17's std::byte.
enum class	select_config_value_hint {   is_integral ,   is_map ,   is_list ,   is_custom ,   is_missing }
enum class	time_unit : uint32_t
	SI time units to specify timeouts.
enum class	exit_reason : uint8_t {   normal = 0 ,   unhandled_exception ,   unknown ,   out_of_workers ,   user_shutdown ,   kill ,   remote_link_unreachable ,   unreachable }
	This error category represents fail conditions for actors. More...
enum class	spawn_mode {   function ,   function_with_selfptr ,   clazz }
enum class	invoke_message_result {   consumed ,   skipped ,   dropped }
	Stores the result of a message invocation. More...
enum class	message_priority {   high = 0 ,   normal = 1 }
	Denotes the urgency of asynchronous messages.
enum class	pec : uint8_t {   success = 0 ,   trailing_character = 1 ,   unexpected_eof ,   unexpected_character ,   timespan_overflow ,   fractional_timespan = 5 ,   too_many_characters ,   illegal_escape_sequence ,   unexpected_newline ,   integer_overflow ,   integer_underflow = 10 ,   exponent_underflow ,   exponent_overflow ,   type_mismatch ,   not_an_option ,   illegal_argument = 15 ,   missing_argument ,   illegal_category ,   invalid_field_name ,   repeated_field_name ,   missing_field }
	PEC stands for "Parser Error Code". More...
enum	result_runtime_type {   rt_value ,   rt_error ,   rt_delegated ,   rt_skip }
enum class	sec : uint8_t {   none = 0 ,   unexpected_message = 1 ,   unexpected_response ,   request_receiver_down ,   request_timeout ,   no_such_group_module = 5 ,   no_actor_published_at_port ,   unexpected_actor_messaging_interface ,   state_not_serializable ,   unsupported_sys_key ,   unsupported_sys_message = 10 ,   disconnect_during_handshake ,   cannot_forward_to_invalid_actor ,   no_route_to_receiving_node ,   failed_to_assign_scribe_from_handle ,   failed_to_assign_doorman_from_handle = 15 ,   cannot_close_invalid_port ,   cannot_connect_to_node ,   cannot_open_port ,   network_syscall_failed ,   invalid_argument = 20 ,   invalid_protocol_family ,   cannot_publish_invalid_actor ,   cannot_spawn_actor_from_arguments ,   end_of_stream ,   no_context = 25 ,   unknown_type ,   no_proxy_registry ,   runtime_error ,   remote_linking_failed ,   cannot_add_upstream = 30 ,   upstream_already_exists ,   invalid_upstream ,   cannot_add_downstream ,   downstream_already_exists ,   invalid_downstream = 35 ,   no_downstream_stages_defined ,   stream_init_failed ,   invalid_stream_state ,   unhandled_stream_error ,   bad_function_call = 40 ,   feature_disabled ,   cannot_open_file ,   socket_invalid ,   socket_disconnected ,   socket_operation_failed = 45 ,   unavailable_or_would_block ,   incompatible_versions ,   incompatible_application_ids ,   malformed_basp_message ,   serializing_basp_payload_failed = 50 ,   redundant_connection ,   remote_lookup_failed ,   connection_timeout }
	SEC stands for "System Error Code". More...
enum class	stream_priority {   very_high ,   high ,   normal ,   low ,   very_low }
	Categorizes individual streams. More...
enum class	term {   reset ,   reset_endl ,   black ,   red ,   green ,   yellow ,   blue ,   magenta ,   cyan ,   white ,   bold_black ,   bold_red ,   bold_green ,   bold_yellow ,   bold_blue ,   bold_magenta ,   bold_cyan ,   bold_white }
	Terminal color and font face options. More...

Functions
actor	operator* (actor f, actor g)
	Combine f and g so that (f*g)(x) = f(g(x)).
bool	operator== (const actor_addr &x, std::nullptr_t)
bool	operator== (std::nullptr_t, const actor_addr &x)
bool	operator!= (const actor_addr &x, std::nullptr_t)
bool	operator!= (std::nullptr_t, const actor_addr &x)
template<class T, class U>
T	actor_cast (U &&what)
	Converts actor handle what to a different actor handle or raw pointer of type T.
error	load_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid)
error	save_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid)
template<class Inspector>
auto	context_of (Inspector *f) -> decltype(f->context())
execution_unit *	context_of (void *)
std::string	to_string (const strong_actor_ptr &x)
void	append_to_string (std::string &x, const strong_actor_ptr &y)
std::string	to_string (const weak_actor_ptr &x)
void	append_to_string (std::string &x, const weak_actor_ptr &y)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, strong_actor_ptr &x)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, weak_actor_ptr &x)
template<class F>
actor_factory	make_actor_factory (F fun)
template<class T, class... Ts>
actor_factory_result	dyn_spawn_class (actor_config &cfg, message &msg)
template<class T, class... Ts>
actor_factory	make_actor_factory ()
actor_ostream	aout (local_actor *self)
	Convenience factory function for creating an actor output stream.
actor_ostream	aout (scoped_actor &self)
	Convenience factory function for creating an actor output stream.
template<class... Sigs>
actor_ostream	aout (const typed_actor_pointer< Sigs... > &ptr)
	Convenience factory function for creating an actor output stream.
template<class T>
std::string	get_mpi_field (const uniform_type_info_map &types)
template<class T>
std::string	get_rtti_from_mpi (const uniform_type_info_map &types)
const settings &	content (const actor_system_config &cfg)
	Returns all user-provided configuration parameters.
constexpr timeout_definition_builder	after (duration d)
	Returns a generator for timeouts.
template<class Rep, class Period>
constexpr timeout_definition_builder	after (std::chrono::duration< Rep, Period > d)
	Returns a generator for timeouts.
template<size_t Size>
constexpr atom_value	atom (char const (&str)[Size])
	Creates an atom from given string literal.
template<size_t Size>
constexpr uint64_t	atom_uint (char const (&str)[Size])
	Creates an atom from given string literal and return an integer representation of the atom.
constexpr uint64_t	atom_uint (atom_value x)
	Converts an atom to its integer representation.
template<atom_value V>
std::string	to_string (const atom_constant< V > &)
template<class Driver, class... Ts>
Driver::source_ptr_type	attach_continuous_stream_source (scheduled_actor *self, Ts &&... xs)
	Creates a new continuous stream source by instantiating the default source implementation with Driver.
template<class Init, class Pull, class Done, class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>
stream_source_ptr< DownstreamManager >	attach_continuous_stream_source (scheduled_actor *self, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
	Creates a new continuous stream source by instantiating the default source implementation with Driver.
template<class Driver, class... Ts>
Driver::stage_ptr_type	attach_continuous_stream_stage (scheduled_actor *self, Ts &&... xs)
	Returns a stream manager (implementing a continuous stage) without in- or outbound path.
template<class Init, class Fun, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
stream_stage_ptr< typename Trait::input, DownstreamManager >	attach_continuous_stream_stage (scheduled_actor *self, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
template<class Driver, class... Ts>
make_sink_result< typename Driver::input_type >	attach_stream_sink (scheduled_actor *self, stream< typename Driver::input_type > in, Ts &&... xs)
	Attaches a new stream sink to self by creating a default stream sink / manager from given callbacks.
template<class In, class Init, class Fun, class Finalize = unit_t, class Trait = stream_sink_trait_t<Fun>>
make_sink_result< In >	attach_stream_sink (scheduled_actor *self, stream< In > in, Init init, Fun fun, Finalize fin={})
	Attaches a new stream sink to self by creating a default stream sink manager from given callbacks.
template<class Driver, class... Ts, class... CtorArgs>
make_source_result_t< typename Driver::downstream_manager_type, Ts... >	attach_stream_source (scheduled_actor *self, std::tuple< Ts... > xs, CtorArgs &&... ctor_args)
	Attaches a new stream source to self by creating a default stream source manager with Driver.
template<class... Ts, class Init, class Pull, class Done, class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>
make_source_result_t< DownstreamManager, Ts... >	attach_stream_source (scheduled_actor *self, std::tuple< Ts... > xs, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
	Attaches a new stream source to self by creating a default stream source manager with the default driver.
template<class Init, class Pull, class Done, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t<!is_actor_handle< Init >::value &&Trait::valid, make_source_result_t< DownstreamManager > >	attach_stream_source (scheduled_actor *self, Init init, Pull pull, Done done, Finalize finalize={}, policy::arg< DownstreamManager > token={})
	Attaches a new stream source to self by creating a default stream source manager with the default driver.
template<class ActorHandle, class... Ts, class Init, class Pull, class Done, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t< is_actor_handle< ActorHandle >::value, make_source_result_t< DownstreamManager > >	attach_stream_source (scheduled_actor *self, const ActorHandle &dest, std::tuple< Ts... > xs, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
	Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately.
template<class ActorHandle, class Init, class Pull, class Done, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t< is_actor_handle< ActorHandle >::value &&Trait::valid, make_source_result_t< DownstreamManager > >	attach_stream_source (scheduled_actor *self, const ActorHandle &dest, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager > token={})
	Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately.
template<class Driver, class In, class... Ts, class... Us>
make_stage_result_t< In, typename Driver::downstream_manager_type, Ts... >	attach_stream_stage (scheduled_actor *self, const stream< In > &in, std::tuple< Ts... > xs, Us &&... ys)
	Attaches a new stream stage to self by creating a default stream stage manager with Driver.
template<class In, class... Ts, class Init, class Fun, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t< In, DownstreamManager, Ts... >	attach_stream_stage (scheduled_actor *self, const stream< In > &in, std::tuple< Ts... > xs, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
	Attaches a new stream stage to self by creating a default stream stage manager from given callbacks.
template<class In, class Init, class Fun, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t< In, DownstreamManager >	attach_stream_stage (scheduled_actor *self, const stream< In > &in, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
	Attaches a new stream stage to self by creating a default stream stage manager from given callbacks.
template<class IntegerType, class = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr IntegerType	to_integer (byte x) noexcept
template<class IntegerType, class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byte &	operator<<= (byte &x, IntegerType shift) noexcept
template<class IntegerType, class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byte	operator<< (byte x, IntegerType shift) noexcept
template<class IntegerType, class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byte &	operator>>= (byte &x, IntegerType shift) noexcept
template<class IntegerType, class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byte	operator>> (byte x, IntegerType shift) noexcept
byte &	operator|= (byte &x, byte y) noexcept
constexpr byte	operator| (byte x, byte y) noexcept
byte &	operator&= (byte &x, byte y) noexcept
constexpr byte	operator& (byte x, byte y) noexcept
byte &	operator^= (byte &x, byte y) noexcept
constexpr byte	operator^ (byte x, byte y) noexcept
constexpr byte	operator~ (byte x) noexcept
template<class T>
constexpr bool	statically_typed ()
template<class ForwardIterator, class Sentinel>
std::pair< ForwardIterator, string_view >	find_by_long_name (const config_option &x, ForwardIterator first, Sentinel last)
	Finds config_option string with a matching long name in (first, last], where each entry is a pointer to a string.
	CAF_DEFAULT_CONFIG_VALUE_ACCESS (bool, "boolean")
	CAF_DEFAULT_CONFIG_VALUE_ACCESS (double, "real64")
	CAF_DEFAULT_CONFIG_VALUE_ACCESS (atom_value, "atom")
	CAF_DEFAULT_CONFIG_VALUE_ACCESS (timespan, "timespan")
	CAF_DEFAULT_CONFIG_VALUE_ACCESS (uri, "uri")
	CAF_DEFAULT_CONFIG_VALUE_ACCESS (config_value::list, "list")
	CAF_DEFAULT_CONFIG_VALUE_ACCESS (config_value::dictionary, "dictionary")
template<class T>
constexpr select_config_value_hint	select_config_value_oracle ()
template<class... Ts>
config_value	make_config_value_list (Ts &&... xs)
template<class... Ts>
config_value_adaptor< typename Ts::value_type... >	make_config_value_adaptor (Ts... fields)
template<class... Ts>
std::string	deep_to_string (const Ts &... xs)
	Unrolls collections such as vectors/maps, decomposes tuples/pairs/arrays, auto-escapes strings and calls to_string for user-defined types via argument-dependent loopkup (ADL).
template<class... Ts>
std::string	deep_to_string_as_tuple (const Ts &... xs)
	Convenience function for deep_to_string(std::forward_as_tuple(xs...)).
template<class... Ts>
bool	operator== (const delegated< Ts... > &, const delegated< Ts... > &)
template<class T>
std::enable_if< std::is_same< error, decltype(std::declval< deserializer & >().apply(std::declval< T & >()))>::value >::type	operator& (deserializer &source, T &x)
template<class T>
std::enable_if< std::is_same< error, decltype(std::declval< deserializer & >().apply(std::declval< T & >()))>::value, deserializer & >::type	operator>> (deserializer &source, T &x)
template<class T>
std::string	to_string (const dictionary< T > &xs)
template<class T>
bool	operator== (const dictionary< T > &xs, const dictionary< T > &ys)
template<class T>
bool	operator!= (const dictionary< T > &xs, const dictionary< T > &ys)
template<class T>
bool	operator< (const dictionary< T > &xs, const dictionary< T > &ys)
template<class T>
bool	operator<= (const dictionary< T > &xs, const dictionary< T > &ys)
template<class T>
bool	operator> (const dictionary< T > &xs, const dictionary< T > &ys)
template<class T>
bool	operator>= (const dictionary< T > &xs, const dictionary< T > &ys)
template<class T>
std::ostream &	operator<< (std::ostream &out, const dictionary< T > &xs)
template<class T>
const T &	get (const downstream_msg &x)
	Allows the testing DSL to unbox downstream_msg automagically.
template<class T>
bool	is (const downstream_msg &x)
	Allows the testing DSL to check whether downstream_msg holds a T.
std::string	to_string (time_unit x)
	Relates time_unit.
constexpr intmax_t	denom_to_unit_index (intmax_t x, intmax_t offset=2)
constexpr time_unit	denom_to_time_unit (intmax_t x)
template<class... Ts, class F = void (*)(actor_system&)>
int	exec_main (F fun, int argc, char **argv, const char *config_file_name="caf-application.ini")
std::string	to_string (exit_reason)
	Returns a string representation of given exit reason.
template<class T>
std::string	to_string (const expected< T > &x)
std::string	to_string (const expected< void > &x)
template<class T>
config_option	make_config_option (string_view category, string_view name, string_view description)
	Creates a config option that synchronizes with storage.
template<class T>
config_option	make_config_option (T &storage, string_view category, string_view name, string_view description)
	Creates a config option that synchronizes with storage.
bool	operator== (const index_mapping &x, const index_mapping &y)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, index_mapping &x)
template<class T>
std::string	to_string (const intrusive_ptr< T > &x)
std::string	to_string (const ipv4_endpoint &ep)
error	parse (string_view str, ipv6_address &dest)
std::string	to_string (const ipv6_endpoint &ep)
template<class T, class R = infer_handle_from_class_t<T>, class... Ts>
R	make_actor (actor_id aid, node_id nid, actor_system *sys, Ts &&... xs)
config_option	make_negated_config_option (bool &storage, string_view category, string_view name, string_view description)
config_option	make_us_resolution_config_option (size_t &storage, string_view category, string_view name, string_view description)
config_option	make_ms_resolution_config_option (size_t &storage, string_view category, string_view name, string_view description)
template<class T, class U, class... Args>
detail::config_value_field_impl< U T::* >	make_config_value_field (string_view name, U T::*ptr, Args &&... xs)
	Creates a field with direct access to a member in T via member-to-object pointer.
template<class Getter, class Setter, class E = detail::enable_if_t<!std::is_member_pointer<Getter>::value>, class... Args>
detail::config_value_field_impl< std::pair< Getter, Setter > >	make_config_value_field (string_view name, Getter getter, Setter setter, Args &&... xs)
	Creates a field with access to a member in T via getter and setter.
template<class... Ts>
config_value_field_storage< Ts... >	make_config_value_field_storage (Ts... fields)
template<class... Ts>
message	make_message_from_tuple (std::tuple< Ts... > xs)
	Converts the tuple xs to a message.
bool	operator< (const match_case_info &x, const match_case_info &y)
template<class F>
std::enable_if<!std::is_base_of< match_case, F >::value, std::tuple< trivial_match_case< F > > >::type	to_match_case_tuple (F fun)
template<class MatchCase>
std::enable_if< std::is_base_of< match_case, MatchCase >::value, std::tuple< constMatchCase & > >::type	to_match_case_tuple (const MatchCase &x)
template<class... Ts>
const std::tuple< Ts... > &	to_match_case_tuple (const std::tuple< Ts... > &x)
template<class T, class U>
std::enable_if< std::is_base_of< match_case, T >::value||std::is_base_of< match_case, U >::value >::type	operator, (T, U)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, named_actor_config &x)
template<class Inspector, class T>
std::enable_if< Inspector::reads_state, typenameInspector::result_type >::type	inspect (Inspector &f, optional< T > &x)
template<class Inspector, class T>
std::enable_if< Inspector::writes_state, typenameInspector::result_type >::type	inspect (Inspector &f, optional< T > &x)
template<class Iterator, class Sentinel>
auto	make_error (const parser_state< Iterator, Sentinel > &ps) -> decltype(make_error(ps.code, ps.line, ps.column))
	Returns an error object from the current code in ps as well as its current position.
error	make_error (pec code)
	Returns an error object from given error code.
error	make_error (pec code, int32_t line, int32_t column)
	Returns an error object from given error code with additional context information for where the parser stopped in the input.
error	make_error (pec code, string_view argument)
	Returns an error object from given error code with additional context information for where the parser stopped in the argument.
template<class... Ts>
result< detail::decay_t< Ts >... >	make_result (Ts &&... xs)
	Convenience function for wrapping the parameter pack xs... into a result.
template<class T>
std::enable_if< std::is_same< T *, resumable * >::value >::type	intrusive_ptr_add_ref (T *ptr)
template<class T>
std::enable_if< std::is_same< T *, resumable * >::value >::type	intrusive_ptr_release (T *ptr)
template<message_priority P = message_priority::normal, class Source = actor, class Dest = actor, class... Ts>
void	send_as (const Source &src, const Dest &dest, Ts &&... xs)
	Sends to a message under the identity of from with priority prio.
template<message_priority P = message_priority::normal, class Source, class Dest, class... Ts>
void	unsafe_send_as (Source *src, const Dest &dest, Ts &&... xs)
template<class... Ts>
void	unsafe_response (local_actor *self, strong_actor_ptr src, std::vector< strong_actor_ptr > stages, message_id mid, Ts &&... xs)
template<message_priority P = message_priority::normal, class Dest = actor, class... Ts>
void	anon_send (const Dest &dest, Ts &&... xs)
	Anonymously sends dest a message.
template<message_priority P = message_priority::normal, class Dest = actor, class Rep = int, class Period = std::ratio<1>, class... Ts>
detail::enable_if_t<!std::is_same< Dest, group >::value >	delayed_anon_send (const Dest &dest, std::chrono::duration< Rep, Period > rtime, Ts &&... xs)
template<class Rep = int, class Period = std::ratio<1>, class... Ts>
void	delayed_anon_send (const group &dest, std::chrono::duration< Rep, Period > rtime, Ts &&... xs)
template<class Dest>
void	anon_send_exit (const Dest &dest, exit_reason reason)
	Anonymously sends dest an exit message.
void	anon_send_exit (const actor_addr &to, exit_reason reason)
	Anonymously sends to an exit message.
void	anon_send_exit (const weak_actor_ptr &to, exit_reason reason)
	Anonymously sends to an exit message.
template<class T>
std::enable_if< std::is_same< error, decltype(std::declval< serializer & >().apply(std::declval< T & >()))>::value >::type	operator& (serializer &sink, const T &x)
template<class T>
std::enable_if< std::is_same< error, decltype(std::declval< serializer & >().apply(std::declval< T & >()))>::value, serializer & >::type	operator<< (serializer &sink, const T &x)
template<class T>
T	get (const settings &xs, string_view name)
template<class T, class = typename std::enable_if< !std::is_pointer<T>::value && !std::is_convertible<T, string_view>::value>::type>
T	get_or (const settings &xs, string_view name, T default_value)
std::string	get_or (const settings &xs, string_view name, string_view default_value)
template<class T>
config_value &	put (settings &dict, string_view key, T &&value)
	Converts value to a config_value and assigns it to key.
template<class T>
void	put_missing (settings &xs, string_view key, T &&value)
	Converts value to a config_value and assigns it to key unless xs already contains key (does nothing in this case).
config_value::list &	put_list (settings &xs, std::string name)
	Inserts a new list named name into the dictionary xs and returns a reference to it.
config_value::dictionary &	put_dictionary (settings &xs, std::string name)
	Inserts a new list named name into the dictionary xs and returns a reference to it.
template<class T>
auto	begin (const span< T > &xs) -> decltype(xs.begin())
template<class T>
auto	cbegin (const span< T > &xs) -> decltype(xs.cbegin())
template<class T>
auto	end (const span< T > &xs) -> decltype(xs.end())
template<class T>
auto	cend (const span< T > &xs) -> decltype(xs.cend())
template<class T>
span< const byte >	as_bytes (span< T > xs)
template<class T>
span< byte >	as_writable_bytes (span< T > xs)
template<class T>
auto	make_span (T &xs) -> span< detail::remove_reference_t< decltype(xs[0])> >
	Convenience function to make using caf::span more convenient without the deduction guides.
template<class T, size_t N>
span< T >	make_span (T(&xs)[N])
	Convenience function to make using caf::span more convenient without the deduction guides.
template<class T>
span< T >	make_span (T *first, size_t size)
	Convenience function to make using caf::span more convenient without the deduction guides.
template<class T>
span< T >	make_span (T *first, T *last)
	Convenience function to make using caf::span more convenient without the deduction guides.
attachable_ptr	make_stream_aborter (actor_addr observed, actor_addr observer, stream_slot slot, stream_aborter::mode m)
string_view	is_any_of (string_view arg)
void	split (std::vector< std::string > &result, string_view str, string_view delims, bool keep_all=true)
void	split (std::vector< string_view > &result, string_view str, string_view delims, bool keep_all=true)
void	split (std::vector< std::string > &result, string_view str, char delim, bool keep_all=true)
void	split (std::vector< string_view > &result, string_view str, char delim, bool keep_all=true)
template<class InputIterator>
std::string	join (InputIterator first, InputIterator last, string_view glue)
template<class Container>
std::string	join (const Container &c, string_view glue)
void	replace_all (std::string &str, string_view what, string_view with)
	Replaces all occurrences of what by with in str.
bool	starts_with (string_view str, string_view prefix)
	Returns whether str begins with prefix.
bool	ends_with (string_view str, string_view suffix)
	Returns whether str ends with suffix.
template<class T>
constexpr bool	SumType ()
	Concept for checking whether T supports the sum type API by specializing sum_type_access.
template<class... Ts>
constexpr bool	SumTypes ()
	Concept for checking whether all Ts support the sum type API by specializing sum_type_access.
template<class Trait, class T>
constexpr sum_type_token< T, sum_type_index< Trait, T >::value >	make_sum_type_token ()
template<class T, int Pos>
constexpr std::integral_constant< int, Pos >	pos (sum_type_token< T, Pos >)
std::ostream &	operator<< (std::ostream &out, term x)
constexpr bool	is_infinite (infinite_t)
template<class Rep, class Period>
constexpr bool	is_infinite (std::chrono::duration< Rep, Period >)
timestamp	make_timestamp ()
	Convenience function for returning a timestamp representing the current system time.
std::string	timestamp_to_string (timestamp x)
	Prints x in ISO 8601 format, e.g., 2018-11-15T06:25:01.462.
void	append_timestamp_to_string (std::string &x, timestamp y)
	Appends the timestamp x in ISO 8601 format, e.g., 2018-11-15T06:25:01.462, to y.
template<class T, class E = typename std::enable_if< detail::is_inspectable< detail::stringification_inspector, T >::value >::type>
std::string	to_string (const T &x)
template<class... Ts>
constexpr uint32_t	make_type_token ()
constexpr uint32_t	add_to_type_token (uint32_t token, uint16_t tnr)
template<class T>
constexpr uint32_t	make_type_token_from_list ()
template<class... Xs, class... Ts>
detail::mpi_splice< typed_actor, detail::type_list< Xs... >, typenameTs::signatures... >::type	splice (const typed_actor< Xs... > &x, const Ts &... xs)
template<class... Fs>
typed_behavior< deduce_mpi_t< Fs >... >	make_typed_behavior (Fs... fs)
	Creates a typed behavior from given function objects.
template<class T>
const T &	get (const upstream_msg &x)
	Allows the testing DSL to unbox upstream_msg automagically.
template<class T>
bool	is (const upstream_msg &x)
	Allows the testing DSL to check whether upstream_msg holds a T.
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, uri::authority_type &x)
template<class... Ts>
actor	splice (const actor &x, const actor &y, const Ts &... zs)
bool	operator== (const actor &lhs, abstract_actor *rhs)
bool	operator== (abstract_actor *lhs, const actor &rhs)
bool	operator!= (const actor &lhs, abstract_actor *rhs)
bool	operator!= (abstract_actor *lhs, const actor &rhs)
std::string	to_string (const actor_config &x)
bool	intrusive_ptr_upgrade_weak (actor_control_block *x)
void	intrusive_ptr_add_weak_ref (actor_control_block *x)
void	intrusive_ptr_release_weak (actor_control_block *x)
void	intrusive_ptr_add_ref (actor_control_block *x)
void	intrusive_ptr_release (actor_control_block *x)
template<class T>
bool	intrusive_ptr_upgrade_weak (actor_storage< T > *x)
template<class T>
void	intrusive_ptr_add_weak_ref (actor_storage< T > *x)
template<class T>
void	intrusive_ptr_release_weak (actor_storage< T > *x)
template<class T>
void	intrusive_ptr_add_ref (actor_storage< T > *x)
template<class T>
void	intrusive_ptr_release (actor_storage< T > *x)
template<class T>
optional< T >	get_if (const actor_system_config *cfg, string_view name)
	Tries to retrieve the value associated to name from cfg.
template<class T>
T	get (const actor_system_config &cfg, string_view name)
	Retrieves the value associated to name from cfg.
template<class T, class = typename std::enable_if< !std::is_pointer<T>::value && !std::is_convertible<T, string_view>::value>::type>
T	get_or (const actor_system_config &cfg, string_view name, T default_value)
	Retrieves the value associated to name from cfg or returns default_value.
std::string	get_or (const actor_system_config &cfg, string_view name, string_view default_value)
	Retrieves the value associated to name from cfg or returns default_value.
template<class T>
bool	holds_alternative (const actor_system_config &cfg, string_view name)
	Returns whether xs associates a value of type T to name.
template<class F>
select_callback< F >::type	make_callback (F fun)
	Creates a callback from a lambda expression.
bool	operator< (const config_value &x, const config_value &y)
bool	operator== (const config_value &x, const config_value &y)
bool	operator>= (const config_value &x, const config_value &y)
bool	operator!= (const config_value &x, const config_value &y)
std::string	to_string (const config_value &x)
std::ostream &	operator<< (std::ostream &out, const config_value &x)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, config_value &x)
template<class T>
config_value_adaptor_field< T >	make_config_value_adaptor_field (string_view name, optional< T > default_value=none, bool(*predicate)(const T &)=nullptr)
	Convenience function for creating a config_value_adaptor_field.
template<class Inspector, class... Ts>
std::enable_if< Inspector::reads_state, typenameInspector::result_type >::type	inspect (Inspector &f, const cow_tuple< Ts... > &x)
template<class Inspector, class... Ts>
std::enable_if< Inspector::writes_state, typenameInspector::result_type >::type	inspect (Inspector &f, cow_tuple< Ts... > &x)
template<class... Ts>
cow_tuple< typename std::decay< Ts >::type... >	make_cow_tuple (Ts &&... xs)
	Creates a new copy-on-write tuple from given arguments.
template<size_t N, class... Ts>
auto	get (const cow_tuple< Ts... > &xs) -> decltype(std::get< N >(xs.data()))
	Convenience function for calling get<N>(xs.data()).
template<class T, class... Ts>
detail::enable_if_tt< detail::tl_contains< downstream_msg::alternatives, T >, downstream_msg >	make (stream_slots slots, actor_addr addr, Ts &&... xs)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, downstream_msg &x)
template<class Period>
constexpr time_unit	get_time_unit_from_period ()
	Converts an STL time period to a time_unit.
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, duration &x)
std::string	to_string (const duration &x)
bool	operator== (const duration &lhs, const duration &rhs)
bool	operator!= (const duration &lhs, const duration &rhs)
template<class T>
bool	is_infinite (duration x)
template<class Clock, class Duration>
std::chrono::time_point< Clock, Duration > &	operator+= (std::chrono::time_point< Clock, Duration > &lhs, const duration &rhs)
std::string	to_string (const error &x)
bool	operator== (const error &x, none_t)
bool	operator== (none_t, const error &x)
template<class E, class = enable_if_has_make_error_t<E>>
bool	operator== (const error &x, E y)
template<class E, class = enable_if_has_make_error_t<E>>
bool	operator== (E x, const error &y)
bool	operator!= (const error &x, none_t)
bool	operator!= (none_t, const error &x)
template<class E, class = enable_if_has_make_error_t<E>>
bool	operator!= (const error &x, E y)
template<class E, class = enable_if_has_make_error_t<E>>
bool	operator!= (E x, const error &y)
template<class Code, class... Ts>
enable_if_has_error_factory_t< Code, error >	make_error (Code code, Ts &&... xs)
template<class T>
auto	operator== (const expected< T > &x, const expected< T > &y) -> decltype(*x==*y)
template<class T, class U>
auto	operator== (const expected< T > &x, const U &y) -> decltype(*x==y)
template<class T, class U>
auto	operator== (const T &x, const expected< U > &y) -> decltype(x==*y)
template<class T>
bool	operator== (const expected< T > &x, const error &y)
template<class T>
bool	operator== (const error &x, const expected< T > &y)
template<class T, class E>
enable_if_has_make_error_t< E, bool >	operator== (const expected< T > &x, E y)
template<class T, class E>
enable_if_has_make_error_t< E, bool >	operator== (E x, const expected< T > &y)
template<class T>
auto	operator!= (const expected< T > &x, const expected< T > &y) -> decltype(*x==*y)
template<class T, class U>
auto	operator!= (const expected< T > &x, const U &y) -> decltype(*x==y)
template<class T, class U>
auto	operator!= (const T &x, const expected< U > &y) -> decltype(x==*y)
template<class T>
bool	operator!= (const expected< T > &x, const error &y)
template<class T>
bool	operator!= (const error &x, const expected< T > &y)
template<class T, class E>
enable_if_has_make_error_t< E, bool >	operator!= (const expected< T > &x, E y)
template<class T, class E>
enable_if_has_make_error_t< E, bool >	operator!= (E x, const expected< T > &y)
bool	operator== (const expected< void > &x, const expected< void > &y)
bool	operator!= (const expected< void > &x, const expected< void > &y)
template<class T>
bool	operator== (const function_view< T > &x, std::nullptr_t)
template<class T>
bool	operator== (std::nullptr_t x, const function_view< T > &y)
template<class T>
bool	operator!= (const function_view< T > &x, std::nullptr_t y)
template<class T>
bool	operator!= (std::nullptr_t x, const function_view< T > &y)
template<class T>
function_view< T >	make_function_view (const T &x, duration t=infinite)
	Creates a new function view for x.
const settings &	content (const actor_system_config &)
std::string	to_string (const group &x)
template<class Inspector>
Inspector::return_type	inspect (Inspector &f, inbound_path &x)
template<class I>
input_range_impl< I >	make_input_range (I first, I last)
template<class T>
T *	default_intrusive_cow_ptr_unshare (T *&ptr)
	Default implementation for unsharing values.
template<class T>
T *	intrusive_cow_ptr_unshare (T *&ptr)
	Customization point for allowing intrusive_cow_ptr<T> with a forward declared T.
template<class T>
std::string	to_string (const intrusive_cow_ptr< T > &x)
template<class T>
bool	operator== (const intrusive_ptr< T > &x, std::nullptr_t)
template<class T>
bool	operator== (std::nullptr_t, const intrusive_ptr< T > &x)
template<class T>
bool	operator!= (const intrusive_ptr< T > &x, std::nullptr_t)
template<class T>
bool	operator!= (std::nullptr_t, const intrusive_ptr< T > &x)
template<class T>
bool	operator== (const intrusive_ptr< T > &x, const T *y)
template<class T>
bool	operator== (const T *x, const intrusive_ptr< T > &y)
template<class T>
bool	operator!= (const intrusive_ptr< T > &x, const T *y)
template<class T>
bool	operator!= (const T *x, const intrusive_ptr< T > &y)
template<class T, class U>
detail::enable_if_t< detail::is_comparable< T *, U * >::value, bool >	operator== (const intrusive_ptr< T > &x, const intrusive_ptr< U > &y)
template<class T, class U>
detail::enable_if_t< detail::is_comparable< T *, U * >::value, bool >	operator!= (const intrusive_ptr< T > &x, const intrusive_ptr< U > &y)
template<class T>
bool	operator< (const intrusive_ptr< T > &x, const intrusive_ptr< T > &y)
template<class T>
bool	operator< (const intrusive_ptr< T > &x, const T *y)
template<class T>
bool	operator< (const T *x, const intrusive_ptr< T > &y)
ipv4_address	make_ipv4_address (uint8_t oct1, uint8_t oct2, uint8_t oct3, uint8_t oct4)
	Convenience function for creating an IPv4 address from octets.
std::string	to_string (const ipv4_address &x)
	Returns a human-readable string representation of the address.
error	parse (string_view str, ipv4_address &dest)
	Tries to parse the content of str into dest.
std::string	to_string (ipv4_subnet x)
std::string	to_string (ipv6_subnet x)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, mailbox_element &x)
mailbox_element_ptr	make_mailbox_element (strong_actor_ptr sender, message_id id, mailbox_element::forwarding_stack stages, message msg)
template<class T, class... Ts>
std::enable_if<!std::is_same< typenamestd::decay< T >::type, message >::value||(sizeof...(Ts)>0), mailbox_element_ptr >::type	make_mailbox_element (strong_actor_ptr sender, message_id id, mailbox_element::forwarding_stack stages, T &&x, Ts &&... xs)
template<class T, class... Ts>
intrusive_cow_ptr< T >	make_copy_on_write (Ts &&... xs)
	Constructs an object of type T in an intrusive_cow_ptr.
template<class T, class... Ts>
intrusive_ptr< T >	make_counted (Ts &&... xs)
	Constructs an object of type T in an intrusive_ptr.
template<class T, class... Ts>
std::enable_if<!std::is_same< message, typenamestd::decay< T >::type >::value||(sizeof...(Ts)>0), message >::type	make_message (T &&x, Ts &&... xs)
	Returns a new message containing the values (x, xs...).
message	make_message (message other)
	Returns a copy of other.
message	make_message ()
	Returns an empty message.
template<class... Ts>
detail::type_erased_tuple_view< Ts... >	make_type_erased_tuple_view (Ts &... xs)
template<class T, class... Ts>
type_erased_value_ptr	make_type_erased_value (Ts &&... xs)
	Creates a type-erased value of type T from xs.
template<class T>
detail::type_erased_value_impl< std::reference_wrapper< T > >	make_type_erased_view (T &x)
	Creates a type-erased view for x.
error	inspect (serializer &sink, message &msg)
error	inspect (deserializer &source, message &msg)
std::string	to_string (const message &msg)
message	operator+ (const message &lhs, const message &rhs)
constexpr message_id	make_message_id (normal_message_priority_constant, uint64_t value)
	Generates a message_id with given integer value.
constexpr message_id	make_message_id (high_message_priority_constant, uint64_t value)
	Generates a message_id with given integer value.
template<message_priority P = message_priority::normal>
constexpr message_id	make_message_id (uint64_t value=0)
	Generates a message_id with given integer value.
constexpr message_id	make_message_id (message_priority p)
	Generates a message_id with given priority.
bool	wraps_uri (const node_id &x) noexcept
	Returns whether x contains an URI.
bool	operator== (const node_id &x, const node_id &y) noexcept
bool	operator!= (const node_id &x, const node_id &y) noexcept
bool	operator< (const node_id &x, const node_id &y) noexcept
bool	operator<= (const node_id &x, const node_id &y) noexcept
bool	operator> (const node_id &x, const node_id &y) noexcept
bool	operator>= (const node_id &x, const node_id &y) noexcept
bool	operator== (const node_id &x, const none_t &) noexcept
bool	operator== (const none_t &, const node_id &x) noexcept
bool	operator!= (const node_id &x, const none_t &) noexcept
bool	operator!= (const none_t &, const node_id &x) noexcept
error	inspect (serializer &sink, const node_id &x)
error	inspect (deserializer &source, node_id &x)
void	append_to_string (std::string &str, const node_id &x)
	Appends x in human-readable string representation to str.
std::string	to_string (const node_id &x)
	Converts x into a human-readable string representation.
node_id	make_node_id (uri from)
	Creates a node ID from the URI from.
node_id	make_node_id (uint32_t process_id, const node_id::default_data::host_id_type &host_id)
	Creates a node ID from process_id and host_id.
optional< node_id >	make_node_id (uint32_t process_id, string_view host_hash)
	Creates a node ID from process_id and host_hash.
error	parse (string_view str, node_id &dest)
std::string	to_string (const none_t &)
template<class T>
std::string	to_string (const optional< T > &x)
template<class T>
T &&	move_if_optional (optional< T > &x)
	Returns an rvalue to the value managed by x.
template<class T>
T &	move_if_optional (T *x)
	Returns *x.
template<class T>
bool	operator== (const optional< T > &lhs, const optional< T > &rhs)
template<class T>
bool	operator!= (const optional< T > &lhs, const optional< T > &rhs)
template<class T>
bool	operator< (const optional< T > &lhs, const optional< T > &rhs)
template<class T>
bool	operator<= (const optional< T > &lhs, const optional< T > &rhs)
template<class T>
bool	operator>= (const optional< T > &lhs, const optional< T > &rhs)
template<class T>
bool	operator> (const optional< T > &lhs, const optional< T > &rhs)
template<class T>
bool	operator== (const optional< T > &lhs, none_t)
template<class T>
bool	operator== (none_t, const optional< T > &rhs)
template<class T>
bool	operator!= (const optional< T > &lhs, none_t)
template<class T>
bool	operator!= (none_t, const optional< T > &rhs)
template<class T>
bool	operator< (const optional< T > &, none_t)
template<class T>
bool	operator< (none_t, const optional< T > &rhs)
template<class T>
bool	operator<= (const optional< T > &lhs, none_t)
template<class T>
bool	operator<= (none_t, const optional< T > &)
template<class T>
bool	operator> (const optional< T > &lhs, none_t)
template<class T>
bool	operator> (none_t, const optional< T > &)
template<class T>
bool	operator>= (const optional< T > &, none_t)
template<class T>
bool	operator>= (none_t, const optional< T > &)
template<class T>
bool	operator== (const optional< T > &lhs, const T &rhs)
template<class T>
bool	operator== (const T &lhs, const optional< T > &rhs)
template<class T>
bool	operator!= (const optional< T > &lhs, const T &rhs)
template<class T>
bool	operator!= (const T &lhs, const optional< T > &rhs)
template<class T>
bool	operator< (const optional< T > &lhs, const T &rhs)
template<class T>
bool	operator< (const T &lhs, const optional< T > &rhs)
template<class T>
bool	operator<= (const optional< T > &lhs, const T &rhs)
template<class T>
bool	operator<= (const T &lhs, const optional< T > &rhs)
template<class T>
bool	operator> (const optional< T > &lhs, const T &rhs)
template<class T>
bool	operator> (const T &lhs, const optional< T > &rhs)
template<class T>
bool	operator>= (const optional< T > &lhs, const T &rhs)
template<class T>
bool	operator>= (const T &lhs, const optional< T > &rhs)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, outbound_path &x)
void	intrusive_ptr_add_ref (const ref_counted *p)
void	intrusive_ptr_release (const ref_counted *p)
result< message >	reflect (scheduled_actor *, message_view &)
	Default handler function that sends the message back to the sender.
result< message >	reflect_and_quit (scheduled_actor *, message_view &)
	Default handler function that sends the message back to the sender and then quits.
result< message >	print_and_drop (scheduled_actor *, message_view &)
	Default handler function that prints messages message via aout and drops them afterwards.
result< message >	drop (scheduled_actor *, message_view &)
	Default handler function that simply drops messages.
std::string	to_string (const scoped_actor &x)
const config_value *	get_if (const settings *xs, string_view name)
	Tries to retrieve the value associated to name from xs.
template<class T>
optional< T >	get_if (const settings *xs, string_view name)
	Tries to retrieve the value associated to name from xs.
template<class T>
bool	holds_alternative (const settings &xs, string_view name)
	Returns whether xs associates a value of type T to name.
constexpr spawn_options	operator+ (const spawn_options &lhs, const spawn_options &rhs)
	Concatenates two spawn_options.
constexpr bool	has_spawn_option (spawn_options haystack, spawn_options needle)
	Checks wheter haystack contains needle.
constexpr bool	has_detach_flag (spawn_options opts)
	Checks wheter the detached flag is set in opts.
constexpr bool	has_priority_aware_flag (spawn_options)
	Checks wheter the priority_aware flag is set in opts.
constexpr bool	has_hide_flag (spawn_options opts)
	Checks wheter the hidden flag is set in opts.
constexpr bool	has_link_flag (spawn_options opts)
	Checks wheter the linked flag is set in opts.
constexpr bool	has_monitor_flag (spawn_options opts)
	Checks wheter the monitored flag is set in opts.
constexpr bool	has_lazy_init_flag (spawn_options opts)
	Checks wheter the lazy_init flag is set in opts.
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, stream_slots &x)
bool	operator== (const exit_msg &x, const exit_msg &y) noexcept
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, exit_msg &x)
bool	operator== (const down_msg &x, const down_msg &y) noexcept
bool	operator!= (const down_msg &x, const down_msg &y) noexcept
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, down_msg &x)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, group_down_msg &x)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, timeout_msg &x)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, open_stream_msg &x)
template<class Processor>
std::enable_if< Processor::reads_state >::type	serialize (Processor &proc, type_erased_tuple &x)
template<class Processor>
std::enable_if< Processor::writes_state >::type	serialize (Processor &proc, type_erased_tuple &x)
std::string	to_string (const type_erased_tuple &x)
template<class... Xs, class... Ys>
bool	operator== (const typed_actor< Xs... > &x, const typed_actor< Ys... > &y) noexcept
template<class... Xs, class... Ys>
bool	operator!= (const typed_actor< Xs... > &x, const typed_actor< Ys... > &y) noexcept
template<class... Xs>
bool	operator== (const typed_actor< Xs... > &x, std::nullptr_t) noexcept
template<class... Xs>
bool	operator== (std::nullptr_t, const typed_actor< Xs... > &x) noexcept
template<class... Xs>
bool	operator!= (const typed_actor< Xs... > &x, std::nullptr_t) noexcept
template<class... Xs>
bool	operator!= (std::nullptr_t, const typed_actor< Xs... > &x) noexcept
template<class... Xs, class... Ys>
composed_type_t< detail::type_list< Xs... >, detail::type_list< Ys... > >	operator* (typed_actor< Xs... > f, typed_actor< Ys... > g)
	Returns a new actor that implements the composition f.g(x) = f(g(x)).
template<class Processor>
void	serialize (Processor &, const unit_t &, unsigned int)
std::string	to_string (const unit_t &)
template<class T, class... Ts>
detail::enable_if_tt< detail::tl_contains< upstream_msg::alternatives, T >, upstream_msg >	make (stream_slots slots, actor_addr addr, Ts &&... xs)
template<class Inspector>
Inspector::result_type	inspect (Inspector &f, upstream_msg &x)
std::string	to_string (const uri &x)
std::string	to_string (const uri::authority_type &x)
error	parse (string_view str, uri &dest)
expected< uri >	make_uri (string_view str)
template<class... Ts>
bool	operator== (const variant< Ts... > &x, const variant< Ts... > &y)
template<class... Ts>
bool	operator!= (const variant< Ts... > &x, const variant< Ts... > &y)
template<class... Ts>
bool	operator< (const variant< Ts... > &x, const variant< Ts... > &y)
template<class... Ts>
bool	operator> (const variant< Ts... > &x, const variant< Ts... > &y)
template<class... Ts>
bool	operator<= (const variant< Ts... > &x, const variant< Ts... > &y)
template<class... Ts>
bool	operator>= (const variant< Ts... > &x, const variant< Ts... > &y)
template<class Inspector, class... Ts>
Inspector::result_type	inspect (Inspector &f, variant_reader< variant< Ts... > > &x)
template<class Inspector, class... Ts>
std::enable_if< Inspector::reads_state, typenameInspector::result_type >::type	inspect (Inspector &f, variant< Ts... > &x)
template<class Inspector, class... Ts>
Inspector::result_type	inspect (Inspector &f, variant_writer< variant< Ts... > > &x)
template<class Inspector, class... Ts>
std::enable_if< Inspector::writes_state, typenameInspector::result_type >::type	inspect (Inspector &f, variant< Ts... > &x)
template<class X, typename Y>
bool	operator== (const weak_intrusive_ptr< X > &lhs, const weak_intrusive_ptr< Y > &rhs)
template<class X, typename Y>
bool	operator!= (const weak_intrusive_ptr< X > &lhs, const weak_intrusive_ptr< Y > &rhs)

Variables
constexpr actor_id	invalid_actor_id = 0
	Denotes an ID that is never used by an actor.
template<atom_value V>
const atom_constant< V >	atom_constant< V >::value = atom_constant<V>{}
constexpr auto	top_level_cli_parsing = top_level_cli_parsing_t{}
	Signals parsing of top-level config values when used as third argument to parse_cli.
constexpr auto	nested_cli_parsing = nested_cli_parsing_t{}
	Signals parsing of nested config values when used as third argument to parse_cli.
constexpr invalid_stream_t	invalid_stream = invalid_stream_t{}
constexpr no_stages_t	no_stages = no_stages_t{}
	Convenience tag for producing empty forwarding stacks.
static constexpr none_t	none = none_t{}
constexpr others_t	others = others_t{}
constexpr skip_t	skip = skip_t{}
	Tells the runtime system to skip a message when used as message handler, i.e., causes the runtime to leave the message in the mailbox of an actor.
constexpr spawn_options	no_spawn_options = spawn_options::no_flags
	Denotes default settings.
constexpr spawn_options	lazy_init = spawn_options::lazy_init_flag
	Causes spawn to call `self->monitor(...) immediately after the new actor was spawned.
static constexpr size_t	stream_priorities = 5
	Stores the number of stream_priority classes.
constexpr stream_slot	invalid_stream_slot = 0
	Identifies an invalid slot.
constexpr bool	token_compress_on = false
static constexpr infinite_t	infinite = infinite_t{}
	Constant for passing "no timeout" to functions such as request.
constexpr type_id_t	first_custom_type_id = 200
	The first type ID not reserved by CAF and its modules.
static constexpr size_t	type_nrs
	The number of built-in types.
const char *	numbered_type_names []
	List of all type names, indexed via type_nr.
static constexpr unit_t	unit = unit_t{}
constexpr size_t	variant_npos = static_cast<size_t>(-1)

Detailed Description

Root namespace of libcaf.

Typedef Documentation

default_downstream_manager_t

template<class F>

using caf::default_downstream_manager_t

Initial value:

 
  typename default_downstream_manager<F>::type

enable_if_has_make_error_t

template<class T, class U = void>

using caf::enable_if_has_make_error_t

Initial value:

 typename std::enable_if<
  !detail::error_factory<T>::specialized && has_make_error<T>::value, U>::type

Convenience alias to detect enums that provide make_error overloads.

function_view_flattened_result_t

template<class T>

using caf::function_view_flattened_result_t

Initial value:

 
  typename function_view_flattened_result<T>::type

interface_mismatch_t

template<class Found, class Expected>

using caf::interface_mismatch_t

Initial value:

 detail::imi<0, Found, Expected,
                                         detail::type_list<>>

Scans two typed MPI lists for compatibility, returning the index of the first mismatch.

Returns the number of elements on a match.

Precondition

len(Found) == len(Expected)

ip_subnet

using caf::ip_subnet = ipv6_subnet

An IP subnetwork.

The address family is IPv6 unless embeds_v4 returns true.

make_stage_result_t

template<class In, class DownstreamManager, class... Ts>

using caf::make_stage_result_t

Initial value:

 
  make_stage_result<In, DownstreamManager, detail::strip_and_convert_t<Ts>...>

Helper type for defining a make_stage_result from a downstream manager plus additional handshake types.

Hardwires message as result type.

primitive_variant

using caf::primitive_variant

Initial value:

 variant<int8_t, int16_t, int32_t, int64_t,
                                  uint8_t, uint16_t, uint32_t, uint64_t,
                                  float, double, long double,
                                  std::string, std::u16string, std::u32string,
                                  atom_value, bool>

rtti_pair

using caf::rtti_pair = std::pair<uint16_t, const std::type_info*>

Bundles the type number with its C++ type_info object.

The type number is non-zero for builtin types and the pointer to the type_info object is non-null for custom types.

select_config_value_access_t

template<class T>

using caf::select_config_value_access_t

Initial value:

 typename select_config_value_access<
  T>::type

sorted_builtin_types

using caf::sorted_builtin_types

Compile-time list of all built-in types.

Warning

Types are sorted by uniform name.

stream_sink_trait_t

template<class Fun>

using caf::stream_sink_trait_t

Initial value:

 
  stream_sink_trait<typename detail::get_callable_trait<Fun>::fun_sig>

Derives a sink trait from the signatures of Fun and Fin.

stream_source_trait_t

template<class Pull>

using caf::stream_source_trait_t

Initial value:

 
  stream_source_trait<typename detail::get_callable_trait<Pull>::fun_sig>

Convenience alias for extracting the function signature from Pull and passing it to stream_source_trait.

stream_stage_trait_t

template<class Process>

using caf::stream_stage_trait_t

Initial value:

 
  stream_stage_trait<typename detail::get_callable_trait<Process>::fun_sig>

Convenience alias for extracting the function signature from Process and passing it to stream_stage_trait.

sum_type_visit_result_t

template<class F, class... Ts>

using caf::sum_type_visit_result_t

Initial value:

 
  typename sum_type_visit_result<detail::decay_t<F>,
                                 detail::decay_t<Ts>...>::type

variant_visit_result_t

template<class F, class... Ts>

using caf::variant_visit_result_t

Initial value:

 
  typename variant_visit_result<detail::decay_t<F>,
                                detail::decay_t<Ts>...>::type

Enumeration Type Documentation

exit_reason

enum class caf::exit_reason : uint8_t

strong

This error category represents fail conditions for actors.

Enumerator
normal	Indicates that an actor finished execution without error.
unhandled_exception	Indicates that an actor died because of an unhandled exception.
unknown	Indicates that the exit reason for this actor is unknown, i.e., the actor has been terminated and no longer exists.
out_of_workers	Indicates that an actor pool unexpectedly ran out of workers.
user_shutdown	Indicates that an actor was forced to shutdown by a user-generated event.
kill	Indicates that an actor was killed unconditionally.
remote_link_unreachable	Indicates that an actor finishied execution because a connection to a remote link was closed unexpectedly.
unreachable	Indicates that an actor was killed because it became unreachable.

invoke_message_result

enum class caf::invoke_message_result

strong

Stores the result of a message invocation.

Enumerator
consumed	Indicates that the actor consumed the message.
skipped	Indicates that the actor left the message in the mailbox.
dropped	Indicates that the actor discarded the message based on meta data. For example, timeout messages for already received requests usually get dropped without calling any user-defined code.

pec

enum class caf::pec : uint8_t

strong

PEC stands for "Parser Error Code".

This enum contains error codes used by various CAF parsers.

Enumerator
success	Not-an-error.
trailing_character	Parser succeeded but found trailing character(s).
unexpected_eof	Parser stopped after reaching the end while still expecting input.
unexpected_character	Parser stopped after reading an unexpected character.
timespan_overflow	Parsed integer exceeds the number of available bits of a timespan.
fractional_timespan	Tried constructing a timespan with from a floating point number.
too_many_characters	Too many characters for an atom.
illegal_escape_sequence	Unrecognized character after escaping \.
unexpected_newline	Misplaced newline, e.g., inside a string.
integer_overflow	Parsed positive integer exceeds the number of available bits.
integer_underflow	Parsed negative integer exceeds the number of available bits.
exponent_underflow	Exponent of parsed double is less than the minimum supported exponent.
exponent_overflow	Exponent of parsed double is greater than the maximum supported exponent.
type_mismatch	Parsed type does not match the expected type.
not_an_option	Stopped at an unrecognized option name.
illegal_argument	Stopped at an unparseable argument.
missing_argument	Stopped because an argument was omitted.
illegal_category	Stopped because the key of a category was taken.
invalid_field_name	Stopped at an unexpected field name while reading a user-defined type.
repeated_field_name	Stopped at a repeated field name while reading a user-defined type.
missing_field	Stopped while reading a user-defined type with one or more missing mandatory fields.

sec

enum class caf::sec : uint8_t

strong

SEC stands for "System Error Code".

This enum contains error codes for ::actor_system and its modules.

Enumerator
none	No error.
unexpected_message	Indicates that an actor dropped an unexpected message.
unexpected_response	Indicates that a response message did not match the provided handler.
request_receiver_down	Indicates that the receiver of a request is no longer alive.
request_timeout	Indicates that a request message timed out.
no_such_group_module	Indicates that requested group module does not exist.
no_actor_published_at_port	Unpublishing or connecting failed: no actor bound to given port.
unexpected_actor_messaging_interface	Connecting failed because a remote actor had an unexpected interface.
state_not_serializable	Migration failed because the state of an actor is not serializable.
unsupported_sys_key	An actor received an unsupported key for ('sys', 'get', key) messages.
unsupported_sys_message	An actor received an unsupported system message.
disconnect_during_handshake	A remote node disconnected during CAF handshake.
cannot_forward_to_invalid_actor	Tried to forward a message via BASP to an invalid actor handle.
no_route_to_receiving_node	Tried to forward a message via BASP to an unknown node ID.
failed_to_assign_scribe_from_handle	Middleman could not assign a connection handle to a broker.
failed_to_assign_doorman_from_handle	Middleman could not assign an acceptor handle to a broker.
cannot_close_invalid_port	User requested to close port 0 or to close a port not managed by CAF.
cannot_connect_to_node	Middleman could not connect to a remote node.
cannot_open_port	Middleman could not open requested port.
network_syscall_failed	A C system call in the middleman failed.
invalid_argument	A function received one or more invalid arguments.
invalid_protocol_family	A network socket reported an invalid network protocol family.
cannot_publish_invalid_actor	Middleman could not publish an actor because it was invalid.
cannot_spawn_actor_from_arguments	A remote spawn failed because the provided types did not match.
end_of_stream	Serialization failed because there was not enough data to read.
no_context	Serialization failed because no CAF context is available.
unknown_type	Serialization failed because CAF misses run-time type information.
no_proxy_registry	Serialization of actors failed because no proxy registry is available.
runtime_error	An exception was thrown during message handling.
remote_linking_failed	Linking to a remote actor failed because actor no longer exists.
cannot_add_upstream	Adding an upstream to a stream failed.
upstream_already_exists	Adding an upstream to a stream failed because it already exists.
invalid_upstream	Unable to process upstream messages because upstream is invalid.
cannot_add_downstream	Adding a downstream to a stream failed.
downstream_already_exists	Adding a downstream to a stream failed because it already exists.
invalid_downstream	Unable to process downstream messages because downstream is invalid.
no_downstream_stages_defined	Cannot start streaming without next stage.
stream_init_failed	Actor failed to initialize state after receiving a stream handshake.
invalid_stream_state	Unable to process a stream since due to missing state.
unhandled_stream_error	Stream aborted due to unexpected error.
bad_function_call	A function view was called without assigning an actor first.
feature_disabled	Feature is disabled in the actor system config.
cannot_open_file	Failed to open file.
socket_invalid	A socket descriptor argument is invalid.
socket_disconnected	A socket became disconnected from the remote host (hang up).
socket_operation_failed	An operation on a socket (e.g. poll) failed.
unavailable_or_would_block	A resource is temporarily unavailable or would block.
incompatible_versions	Connection refused because of incompatible CAF versions.
incompatible_application_ids	Connection refused because of incompatible application IDs.
malformed_basp_message	The middleman received a malformed BASP message from another node.
serializing_basp_payload_failed	The middleman closed a connection because it failed to serialize or deserialize a payload.
redundant_connection	The middleman closed a connection to itself or an already connected node.
remote_lookup_failed	Resolving a path on a remote node failed.
connection_timeout	Disconnected from a BASP node after reaching the connection timeout.

stream_priority

enum class caf::stream_priority

strong

Categorizes individual streams.

Enumerator
very_high	Denotes soft-realtime traffic.
high	Denotes time-sensitive traffic.
normal	Denotes traffic with moderate timing requirements.
low	Denotes uncritical traffic without timing requirements.
very_low	Denotes best-effort traffic.

term

enum class caf::term

strong

Terminal color and font face options.

Enumerator
reset	Resets the color to the default color and the font weight to normal.
reset_endl	Like reset but also prints a newline.
black	Sets the terminal color to black.
red	Sets the terminal color to red.
green	Sets the terminal color to green.
yellow	Sets the terminal color to yellow.
blue	Sets the terminal color to blue.
magenta	Sets the terminal color to magenta.
cyan	Sets the terminal color to cyan.
white	Sets the terminal color to white.
bold_black	Sets the terminal color to black and the font weight to bold.
bold_red	Sets the terminal color to red and the font weight to bold.
bold_green	Sets the terminal color to green and the font weight to bold.
bold_yellow	Sets the terminal color to yellow and the font weight to bold.
bold_blue	Sets the terminal color to blue and the font weight to bold.
bold_magenta	Sets the terminal color to magenta and the font weight to bold.
bold_cyan	Sets the terminal color to cyan and the font weight to bold.
bold_white	Sets the terminal color to white and the font weight to bold.

Function Documentation

atom_uint()

template<size_t Size>

uint64_t caf::atom_uint ( char const (&) str[Size] )

constexpr

Creates an atom from given string literal and return an integer representation of the atom.

attach_continuous_stream_source() [1/2]

template<class Init, class Pull, class Done, class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>

stream_source_ptr< DownstreamManager > caf::attach_continuous_stream_source	(	scheduled_actor *	self,
		Init	init,
		Pull	pull,
		Done	done,
		Finalize	fin = {},
		policy::arg< DownstreamManager >	= {} )

Creates a new continuous stream source by instantiating the default source implementation with Driver.

The returned manager is not connected to any slot and thus not stored by the actor automatically.

Parameters

self	Points to the hosting actor.
init	Function object for initializing the state of the source.
pull	Generator function object for producing downstream messages.
done	Predicate returning true when generator is done.
fin	Cleanup handler.

Returns

The new stream_manager.

attach_continuous_stream_source() [2/2]

template<class Driver, class... Ts>

Driver::source_ptr_type caf::attach_continuous_stream_source	(	scheduled_actor *	self,
		Ts &&...	xs )

Creates a new continuous stream source by instantiating the default source implementation with Driver.

The returned manager is not connected to any slot and thus not stored by the actor automatically.

Parameters

self	Points to the hosting actor.
init	Function object for initializing the state of the source.
pull	Generator function object for producing downstream messages.
done	Predicate returning true when generator is done.
fin	Cleanup handler.

Returns

The new stream_manager.

attach_continuous_stream_stage() [1/2]

template<class Init, class Fun, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>

stream_stage_ptr< typename Trait::input, DownstreamManager > caf::attach_continuous_stream_stage	(	scheduled_actor *	self,
		Init	init,
		Fun	fun,
		Finalize	fin = {},
		policy::arg< DownstreamManager >	token = {} )

Parameters

self	Points to the hosting actor.
init	Function object for initializing the state of the stage.
fun	Processing function.
fin	Optional cleanup handler.
token	Policy token for selecting a downstream manager implementation.

attach_continuous_stream_stage() [2/2]

template<class Driver, class... Ts>

Driver::stage_ptr_type caf::attach_continuous_stream_stage	(	scheduled_actor *	self,
		Ts &&...	xs )

Returns a stream manager (implementing a continuous stage) without in- or outbound path.

The returned manager is not connected to any slot and thus not stored by the actor automatically.

Parameters

self	Points to the hosting actor.
xs	User-defined arguments for the downstream handshake.

Returns

The new stream_manager.

attach_stream_sink() [1/2]

template<class In, class Init, class Fun, class Finalize = unit_t, class Trait = stream_sink_trait_t<Fun>>

make_sink_result< In > caf::attach_stream_sink	(	scheduled_actor *	self,
		stream< In >	in,
		Init	init,
		Fun	fun,
		Finalize	fin = {} )

Attaches a new stream sink to self by creating a default stream sink manager from given callbacks.

Parameters

self	Points to the hosting actor.
in	Stream handshake from upstream path.
init	Function object for initializing the state of the sink.
fun	Processing function.
fin	Optional cleanup handler.

Returns

The new stream_manager and the inbound slot.

attach_stream_sink() [2/2]

template<class Driver, class... Ts>

make_sink_result< typename Driver::input_type > caf::attach_stream_sink	(	scheduled_actor *	self,
		stream< typename Driver::input_type >	in,
		Ts &&...	xs )

Attaches a new stream sink to self by creating a default stream sink / manager from given callbacks.

Parameters

self	Points to the hosting actor.
xs	Additional constructor arguments for Driver.

Returns

The new stream_manager, an inbound slot, and an outbound slot.

attach_stream_source() [1/5]

template<class ActorHandle, class Init, class Pull, class Done, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>

detail::enable_if_t< is_actor_handle< ActorHandle >::value &&Trait::valid, make_source_result_t< DownstreamManager > > caf::attach_stream_source	(	scheduled_actor *	self,
		const ActorHandle &	dest,
		Init	init,
		Pull	pull,
		Done	done,
		Finalize	fin = {},
		policy::arg< DownstreamManager >	token = {} )

Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately.

Parameters

self	Points to the hosting actor.
dest	Handle to the next stage in the pipeline.
init	Function object for initializing the state of the source.
pull	Generator function object for producing downstream messages.
done	Predicate returning true when generator is done.
fin	Cleanup handler.

Returns

The allocated stream_manager and the output slot.

attach_stream_source() [2/5]

template<class ActorHandle, class... Ts, class Init, class Pull, class Done, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>

detail::enable_if_t< is_actor_handle< ActorHandle >::value, make_source_result_t< DownstreamManager > > caf::attach_stream_source	(	scheduled_actor *	self,
		const ActorHandle &	dest,
		std::tuple< Ts... >	xs,
		Init	init,
		Pull	pull,
		Done	done,
		Finalize	fin = {},
		policy::arg< DownstreamManager >	= {} )

Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately.

Parameters

self	Points to the hosting actor.
dest	Handle to the next stage in the pipeline.
xs	User-defined arguments for the stream handshake.
init	Function object for initializing the state of the source.
pull	Generator function object for producing downstream messages.
done	Predicate returning true when generator is done.
fin	Cleanup handler.

Returns

The allocated stream_manager and the output slot.

attach_stream_source() [3/5]

template<class Init, class Pull, class Done, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>

detail::enable_if_t<!is_actor_handle< Init >::value &&Trait::valid, make_source_result_t< DownstreamManager > > caf::attach_stream_source	(	scheduled_actor *	self,
		Init	init,
		Pull	pull,
		Done	done,
		Finalize	finalize = {},
		policy::arg< DownstreamManager >	token = {} )

Attaches a new stream source to self by creating a default stream source manager with the default driver.

Parameters

self	Points to the hosting actor.
init	Function object for initializing the state of the source.
pull	Generator function object for producing downstream messages.
done	Predicate returning true when generator is done.
fin	Cleanup handler.

Returns

The allocated stream_manager and the output slot.

attach_stream_source() [4/5]

template<class Driver, class... Ts, class... CtorArgs>

make_source_result_t< typename Driver::downstream_manager_type, Ts... > caf::attach_stream_source	(	scheduled_actor *	self,
		std::tuple< Ts... >	xs,
		CtorArgs &&...	ctor_args )

Attaches a new stream source to self by creating a default stream source manager with Driver.

Parameters

self	Points to the hosting actor.
xs	User-defined arguments for the stream handshake.
init	Function object for initializing the state of the source.
pull	Function object for generating downstream messages.
done	Predicate returning true when generator is done.
fin	Optional cleanup handler.

Returns

The allocated stream_manager and the output slot.

attach_stream_source() [5/5]

template<class... Ts, class Init, class Pull, class Done, class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>

make_source_result_t< DownstreamManager, Ts... > caf::attach_stream_source	(	scheduled_actor *	self,
		std::tuple< Ts... >	xs,
		Init	init,
		Pull	pull,
		Done	done,
		Finalize	fin = {},
		policy::arg< DownstreamManager >	= {} )

Attaches a new stream source to self by creating a default stream source manager with the default driver.

Parameters

self	Points to the hosting actor.
xs	User-defined arguments for the stream handshake.
init	Function object for initializing the state of the source.
pull	Generator function object for producing downstream messages.
done	Predicate returning true when generator is done.
fin	Cleanup handler.

Returns

The allocated stream_manager and the output slot.

attach_stream_stage() [1/3]

template<class In, class Init, class Fun, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>

make_stage_result_t< In, DownstreamManager > caf::attach_stream_stage	(	scheduled_actor *	self,
		const stream< In > &	in,
		Init	init,
		Fun	fun,
		Finalize	fin = {},
		policy::arg< DownstreamManager >	token = {} )

Attaches a new stream stage to self by creating a default stream stage manager from given callbacks.

Parameters

self	Points to the hosting actor.
in	Stream handshake from upstream path.
init	Function object for initializing the state of the stage.
fun	Processing function.
fin	Optional cleanup handler.
token	Policy token for selecting a downstream manager implementation.

Returns

The new stream_manager, an inbound slot, and an outbound slot.

attach_stream_stage() [2/3]

template<class In, class... Ts, class Init, class Fun, class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>

make_stage_result_t< In, DownstreamManager, Ts... > caf::attach_stream_stage	(	scheduled_actor *	self,
		const stream< In > &	in,
		std::tuple< Ts... >	xs,
		Init	init,
		Fun	fun,
		Finalize	fin = {},
		policy::arg< DownstreamManager >	token = {} )

Attaches a new stream stage to self by creating a default stream stage manager from given callbacks.

Parameters

self	Points to the hosting actor.
in	Stream handshake from upstream path.
xs	User-defined arguments for the downstream handshake.
init	Function object for initializing the state of the stage.
fun	Processing function.
fin	Optional cleanup handler.
token	Policy token for selecting a downstream manager implementation.

Returns

The new stream_manager, an inbound slot, and an outbound slot.

attach_stream_stage() [3/3]

template<class Driver, class In, class... Ts, class... Us>

make_stage_result_t< In, typename Driver::downstream_manager_type, Ts... > caf::attach_stream_stage	(	scheduled_actor *	self,
		const stream< In > &	in,
		std::tuple< Ts... >	xs,
		Us &&...	ys )

Attaches a new stream stage to self by creating a default stream stage manager with Driver.

Parameters

self	Points to the hosting actor.
in	Stream handshake from upstream path.
xs	User-defined arguments for the downstream handshake.
ys	Additional constructor arguments for Driver.

Returns

The new stream_manager, an inbound slot, and an outbound slot.

deep_to_string()

template<class... Ts>

std::string caf::deep_to_string

(

const Ts &...

xs

)

Unrolls collections such as vectors/maps, decomposes tuples/pairs/arrays, auto-escapes strings and calls to_string for user-defined types via argument-dependent loopkup (ADL).

Any user-defined type that does not provide a to_string is mapped to <unprintable>.

find_by_long_name()

template<class ForwardIterator, class Sentinel>

std::pair< ForwardIterator, string_view > caf::find_by_long_name	(	const config_option &	x,
		ForwardIterator	first,
		Sentinel	last )

Finds config_option string with a matching long name in (first, last], where each entry is a pointer to a string.

Returns a ForwardIterator to the match and a caf::string_view of the option value if the entry is found and a ForwardIterator to last with an empty string_view otherwise.

put()

template<class T>

config_value & caf::put	(	settings &	dict,
		string_view	key,
		T &&	value )

Converts value to a config_value and assigns it to key.

Parameters

dict	Dictionary of key-value pairs.
key	Human-readable nested keys in the form category.key.
value	New value for given key.

put_dictionary()

config_value::dictionary & caf::put_dictionary	(	settings &	xs,
		std::string	name )

Inserts a new list named name into the dictionary xs and returns a reference to it.

Overrides existing entries with the same name.

put_list()

config_value::list & caf::put_list	(	settings &	xs,
		std::string	name )

Inserts a new list named name into the dictionary xs and returns a reference to it.

Overrides existing entries with the same name.

put_missing()

template<class T>

void caf::put_missing	(	settings &	xs,
		string_view	key,
		T &&	value )

Converts value to a config_value and assigns it to key unless xs already contains key (does nothing in this case).

Parameters

xs	Dictionary of key-value pairs.
key	Human-readable nested keys in the form category.key.
value	New value for given key.

Variable Documentation

type_nrs

size_t caf::type_nrs

staticconstexpr

Initial value:

= detail::tl_size<sorted_builtin_types>::value
                                   + 1

The number of built-in types.