caf Namespace Reference

Namespaces
	exit_reason
	io
	mixin
	policy

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_companion
	An co-existing actor forwarding all messages through a user-defined callback to another object, thus serving as gateway to allow any object to interact with other actors. 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_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	allowed_unsafe_message_type
	Template specializations can whitelist individual types for unsafe message passing operations. More...
class	arraybuf
	A streambuffer abstraction over a fixed array of bytes. 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	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...
class	composable_behavior
	Base type for composable actor states. More...
class	composable_behavior_base
	Generates an interface class that provides operator(). 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 config_value::dictionary. More...
class	config_value
	A type for config parameters with similar interface to a variant. More...
struct	config_value_access< dictionary< V > >
	Implements automagic unboxing of dictionary<V> from a homogeneous config_value::dictionary. More...
struct	config_value_access< std::vector< T > >
	Implements automagic unboxing of std::vector<T> from a homogeneous config_value::list. More...
class	containerbuf
	A streambuffer abstraction over a contiguous container. 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	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
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...
struct	down_msg
	Sent to all actors monitoring an actor when it is terminated. 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...
class	duration
	Time duration consisting of a time_unit and a 64 bit unsigned integer. More...
class	empty_type_erased_tuple
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	exit_msg
	Sent to all links when an actor is terminated. 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...
struct	group_down_msg
	Sent to all members of a group when it goes offline. More...
class	group_module
	Interface for user-defined multicast implementations. More...
class	handle
	Base class for IO handles such as accept_handle or connection_handle. 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...
struct	has_sum_type_access
	Evaluates to true if T specializes sum_type_access. 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...
class	inbound_stream_slot
	Wraps a stream slot ID for inbound paths with the full type information of the path creation. More...
struct	index_mapping
	Marker for representing placeholders at runtime. More...
struct	infer_handle_from_class
	Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced. More...
struct	infer_handle_from_fun
	Deduces an actor handle type from a function or function object. More...
struct	infinite_t
	Represents an infinite amount of timeout for specifying "invalid" timeouts. 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...
struct	is_actor_handle
	Checks whether T is an actor or a typed_actor<...>. 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...
class	make_sink_result
	Returns a stream sink with the slot ID of its first inbound path. More...
struct	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...
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_error_t
	Helper class to construct an expected<T> that represents no error. More...
struct	no_stages_t
	Convenience tag type for producing empty forwarding stacks. More...
class	node_id
	A node ID consists of a host ID and process ID. More...
struct	none_t
	Represents "nothing", e.g., for clearing an optional by assigning none. More...
struct	open_stream_msg
	Demands the receiver to open a new stream from the sender to the receiver. More...
class	optional
	A C++17 compatible optional implementation. 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...
class	outbound_stream_slot
	Wraps a stream slot ID for outbound paths with the full type information of the path creation. More...
class	output_stream
	Empty marker type for type-checking of stream sources and stages. More...
class	param
	Represents a message handler parameter of type T and guarantees copy-on-write semantics. 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...
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	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...
struct	remove_param
	Unpacks param<T> to T. 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...
struct	select_callback
	Utility class for selecting a callback_impl. More...
struct	select_config_value_access
	Delegates to config_value_access for all specialized versions. More...
struct	select_config_value_access< T, true >
	Catches all non-specialized integer types. More...
class	serializer
class	skip_t
class	spawn_options
	Stores options passed to the spawn function family. More...
class	stateful_actor
	An event-based actor with managed state. More...
class	stream
	Empty marker type for streaming handshakes. More...
class	stream_buffer
	The base class for all stream buffer implementations. 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
	Defines required type aliases for stream sinks. More...
struct	stream_sink_trait< void(State &, const std::vector< In > &)>
	Specializes the trait for batch-wise processing with const references. 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_base
	Base type for all sink traits. More...
struct	stream_slots
	Maps two stream_slot values into a pair for storing sender and receiver slot information. 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	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	sum_type_access< variant< Ts... > >
	Enable holds_alternative, get, get_if, and visit for variant. More...
class	thread_hook
	Interface to define thread hooks. More...
struct	timeout_msg
	Signalizes a timeout event. More...
class	type_erased_tuple
	Represents a tuple of type-erased values. More...
class	type_erased_value
	Represents a single type-erased value. More...
struct	type_erased_value_factory
struct	type_nr
	Computes the type number for T. More...
class	typed_actor
	Identifies a statically typed actor. 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...
struct	unbox_message_element
	Unboxes atom constants, i.e., converts atom_constant<V> to V. More...
struct	unit_t
	Unit is analogous to void, but can be safely returned, stored, etc. More...
struct	unsafe_actor_handle_init_t
	Tag type to select the unsafe constructor of actor handles. 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...
class	variant
	A variant represents always a valid value of one of the types Ts.... More...
class	weak_intrusive_ptr
	An intrusive, reference counting smart pointer implementation. 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 >
template<class T >
using	is_statically_typed = std::is_base_of< statically_typed_actor_base, T >
template<class T >
using	is_dynamically_typed = std::is_base_of< dynamically_typed_actor_base, T >
using	rtti_pair = std::pair< uint16_t, const std::type_info * >
using	rtti_pair_vec = std::vector< rtti_pair >
using	rtti_pair_vec_triple = std::tuple< rtti_pair_vec, rtti_pair_vec, rtti_pair_vec >
using	add_atom = atom_constant< atom("add")>
	Used for request operations.
using	get_atom = atom_constant< atom("get")>
	Used for request operations.
using	put_atom = atom_constant< atom("put")>
	Used for request operations.
using	update_atom = atom_constant< atom("update")>
	Used for signalizing updates, e.g., in a key-value store.
using	delete_atom = atom_constant< atom("delete")>
	Used for request operations.
using	ok_atom = atom_constant< atom("ok")>
	Used for response messages.
using	sys_atom = atom_constant< atom("sys")>
	Used for triggering system-level message handling.
using	join_atom = atom_constant< atom("join")>
	Used for signaling group subscriptions.
using	leave_atom = atom_constant< atom("leave")>
	Used for signaling group unsubscriptions.
using	forward_atom = atom_constant< atom("forward")>
	Used for signaling forwarding paths.
using	flush_atom = atom_constant< atom("flush")>
	Used for buffer management.
using	redirect_atom = atom_constant< atom("redirect")>
	Used for I/O redirection.
using	link_atom = atom_constant< atom("link")>
	Used for link requests over network.
using	unlink_atom = atom_constant< atom("unlink")>
	Used for removing networked links.
using	publish_atom = atom_constant< atom("publish")>
	Used for publishing actors at a given port.
using	publish_udp_atom = atom_constant< atom("pub_udp")>
	Used for publishing actors at a given port.
using	unpublish_atom = atom_constant< atom("unpublish")>
	Used for removing an actor/port mapping.
using	unpublish_udp_atom = atom_constant< atom("unpub_udp")>
	Used for removing an actor/port mapping.
using	subscribe_atom = atom_constant< atom("subscribe")>
	Used for signalizing group membership.
using	unsubscribe_atom = atom_constant< atom("unsubscrib")>
	Used for withdrawing group membership.
using	connect_atom = atom_constant< atom("connect")>
	Used for establishing network connections.
using	contact_atom = atom_constant< atom("contact")>
	Used for contacting a remote UDP endpoint.
using	open_atom = atom_constant< atom("open")>
	Used for opening ports or files.
using	close_atom = atom_constant< atom("close")>
	Used for closing ports or files.
using	spawn_atom = atom_constant< atom("spawn")>
	Used for spawning remote actors.
using	migrate_atom = atom_constant< atom("migrate")>
	Used for migrating actors to other nodes.
using	tick_atom = atom_constant< atom("tick")>
	Used for triggering periodic operations.
using	pending_atom = atom_constant< atom("pending")>
	Used for pending out of order messages.
using	receive_atom = atom_constant< atom("receive")>
	Used as timeout type for timeout_msg.
using	stream_atom = atom_constant< atom("stream")>
	Used as timeout type for timeout_msg.
using	binary_deserializer = stream_deserializer< charbuf >
	A stream serializer that writes into an unbounded contiguous character sequence.
using	binary_serializer = stream_serializer< vectorbuf >
	A stream serializer that writes into an unbounded contiguous character sequence.
template<class T >
using	signatures_of_t = typename signatures_of< T >::type
template<class T >
using	select_config_value_access_t = typename select_config_value_access< T >::type
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 = typename default_downstream_manager< F >::type
template<class T , class U = void>
using	enable_if_has_make_error_t = typename std::enable_if< has_make_error< T >::value, U >::type
	Convenience alias for std::enable_if<has_make_error<T>::value, U>::type.
template<class T >
using	function_view_flattened_result_t = typename function_view_flattened_result< T >::type
using	actor_id = uint64_t uint64_t
using	ip_address = ipv6_address
	An IP address. The address family is IPv6 unless embeds_v4 returns true.
using	ip_subnet = ipv6_subnet
	An IP subnetwork. More...
using	stream_slot = uint16_t
	Identifies a single stream path in the same way a TCP port identifies a connection over IP.
using	config_value_map = dictionary< dictionary< config_value > >
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 = detail::imi< 0, Found, Expected, detail::type_list<> >
	Scans two typed MPI lists for compatibility, returning the index of the first mismatch. More...
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 = 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. More...
template<class T >
using	param_t = typename std::conditional< std::is_arithmetic< T >::value||is_atom_constant< T >::value, T, param< T > >::type
	Convenience alias that wraps T into param<T> unless T is arithmetic or an atom constant.
using	primitive_variant = 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 >
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.
template<class In >
using	stream_sink_ptr = intrusive_ptr< stream_sink< In > >
template<class Fun >
using	stream_sink_trait_t = stream_sink_trait< typename detail::get_callable_trait< Fun >::fun_sig >
	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 = 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.
template<class In , class DownstreamManager >
using	stream_stage_ptr = intrusive_ptr< stream_stage< In, DownstreamManager > >
template<class Process >
using	stream_stage_trait_t = 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.
using	charbuf = arraybuf< char >
using	vectorbuf = containerbuf< std::vector< char > >
template<class F , class... Ts>
using	sum_type_visit_result_t = typename sum_type_visit_result< detail::decay_t< F >, detail::decay_t< Ts >... >::type
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	sorted_builtin_types = detail::type_list< actor, std::vector< actor >, actor_addr, std::vector< actor_addr >, atom_value, std::vector< char >, down_msg, downstream_msg, duration, error, exit_msg, group, group_down_msg, int16_t, int32_t, int64_t, int8_t, long double, message, message_id, node_id, open_stream_msg, std::string, std::map< std::string, std::string >, strong_actor_ptr, std::set< std::string >, std::vector< std::string >, timeout_msg, timespan, timestamp, uint16_t, std::u16string, uint32_t, std::u32string, uint64_t, uint8_t, unit_t, upstream_msg, weak_actor_ptr, bool, double, float >
	Compile-time list of all built-in types. More...
template<class... Ts>
using	is_variant_t = typename is_variant< Ts... >::type
template<class F , class... Ts>
using	variant_visit_result_t = typename variant_visit_result< detail::decay_t< F >, detail::decay_t< Ts >... >::type

Enumerations
enum	atom_value : uint64_t
	The value type of atoms.
enum	time_unit : uint32_t
	SI time units to specify timeouts.
enum	exit_reason : uint8_t {   exit_reason::normal = 0,   exit_reason::unhandled_exception,   exit_reason::unknown,   exit_reason::out_of_workers,   exit_reason::user_shutdown,   exit_reason::kill,   exit_reason::remote_link_unreachable,   exit_reason::unreachable }
	This error category represents fail conditions for actors. More...
enum	spawn_mode {   function,   function_with_selfptr,   clazz }
enum	invoke_message_result {   im_success,   im_skipped,   im_dropped }
enum	message_priority {   high = 0,   normal = 1 }
	Denotes the urgency of asynchronous messages.
enum	pec : uint8_t {   pec::success = 0,   pec::trailing_character = 1,   pec::unexpected_eof,   pec::unexpected_character,   pec::timespan_overflow,   pec::fractional_timespan = 5,   pec::too_many_characters,   pec::illegal_escape_sequence,   pec::unexpected_newline,   pec::integer_overflow,   pec::integer_underflow = 10,   pec::exponent_underflow,   pec::exponent_overflow,   pec::type_mismatch,   pec::not_an_option,   pec::illegal_argument = 15,   pec::missing_argument,   pec::illegal_category }
	PEC stands for "Parser Error Code". More...
enum	result_runtime_type {   rt_value,   rt_error,   rt_delegated,   rt_skip }
enum	sec : uint8_t {   sec::none = 0,   sec::unexpected_message = 1,   sec::unexpected_response,   sec::request_receiver_down,   sec::request_timeout,   sec::no_such_group_module = 5,   sec::no_actor_published_at_port,   sec::unexpected_actor_messaging_interface,   sec::state_not_serializable,   sec::unsupported_sys_key,   sec::unsupported_sys_message = 10,   sec::disconnect_during_handshake,   sec::cannot_forward_to_invalid_actor,   sec::no_route_to_receiving_node,   sec::failed_to_assign_scribe_from_handle,   sec::failed_to_assign_doorman_from_handle = 15,   sec::cannot_close_invalid_port,   sec::cannot_connect_to_node,   sec::cannot_open_port,   sec::network_syscall_failed,   sec::invalid_argument = 20,   sec::invalid_protocol_family,   sec::cannot_publish_invalid_actor,   sec::cannot_spawn_actor_from_arguments,   sec::end_of_stream,   sec::no_context = 25,   sec::unknown_type,   sec::no_proxy_registry,   sec::runtime_error,   sec::remote_linking_failed,   sec::cannot_add_upstream = 30,   sec::upstream_already_exists,   sec::invalid_upstream,   sec::cannot_add_downstream,   sec::downstream_already_exists,   sec::invalid_downstream = 35,   sec::no_downstream_stages_defined,   sec::stream_init_failed,   sec::invalid_stream_state,   sec::unhandled_stream_error,   sec::bad_function_call = 40,   sec::feature_disabled }
	SEC stands for "System Error Code". More...
enum	stream_priority {   stream_priority::very_high,   stream_priority::high,   stream_priority::normal,   stream_priority::low,   stream_priority::very_low }
	Categorizes individual streams. More...
enum	term {   term::reset,   term::reset_endl,   term::black,   term::red,   term::green,   term::yellow,   term::blue,   term::magenta,   term::cyan,   term::white,   term::bold_black,   term::bold_red,   term::bold_green,   term::bold_yellow,   term::bold_blue,   term::bold_magenta,   term::bold_cyan,   term::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)
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.
atom_value	atom_from_string (string_view x)
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. More...
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 T >
constexpr bool	statically_typed ()
std::string	get_or (const actor_system_config &cfg, string_view name, const char *default_value)
template<class T >
void	put (dictionary< config_value::dictionary > &dict, string_view key, T &&value)
	Converts value to a config_value and assigns it to key. More...
config_value::list &	put_list (config_value::dictionary &xs, std::string name)
	Inserts a new list named name into the dictionary xs and returns a reference to it. More...
config_value::dictionary &	put_dictionary (config_value::dictionary &xs, std::string name)
	Inserts a new list named name into the dictionary xs and returns a reference to it. More...
template<class... Ts>
config_value	make_config_value_list (Ts &&... xs)
template<class... Ts>
std::string	deep_to_string_as_tuple (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 >
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 , class V >
void	put (dictionary< T > &dict, string_view key, V &&value)
	Convenience function for calling dict.insert_or_assign(key, value).
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 x)
	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 (invoke_message_result x)
error	parse (string_view str, ipv6_address &dest)
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... 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< const MatchCase & >>::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)
bool	operator== (const node_id &lhs, const node_id &rhs)
bool	operator!= (const node_id &lhs, const node_id &rhs)
bool	operator< (const node_id &lhs, const node_id &rhs)
template<class Inspector , class T >
std::enable_if< Inspector::reads_state, typename Inspector::result_type >::type	inspect (Inspector &f, optional< T > &x)
template<class Inspector , class T >
std::enable_if< Inspector::writes_state, typename Inspector::result_type >::type	inspect (Inspector &f, optional< T > &x)
error	make_error (pec code)
error	make_error (pec code, size_t line, size_t column)
const char *	to_string (pec x)
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)
std::string	to_string (const scoped_actor &x)
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<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)
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 ()
std::ostream &	operator<< (std::ostream &out, term x)
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... >, typename Ts::signatures... >::type	splice (const typed_actor< Xs... > &x, const Ts &... xs)
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)

Variables
constexpr actor_id	invalid_actor_id = 0
	Denotes an ID that is never used by an actor.
constexpr deep_to_string_t	deep_to_string = deep_to_string_t{}
	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). More...
static constexpr infinite_t	infinite = infinite_t{}
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	monitored = spawn_options::monitor_flag
	Causes spawn to call `self->monitor(...) immediately after the new actor was spawned.
constexpr spawn_options	linked = spawn_options::link_flag
	Causes spawn to call `self->link_to(...) immediately after the new actor was spawned.
constexpr spawn_options	detached = spawn_options::detach_flag
	Causes the new actor to opt out of the cooperative scheduling.
constexpr spawn_options	hidden = spawn_options::hide_flag
	Causes the runtime to ignore the new actor in await_all_actors_done().
constexpr spawn_options priority_aware	CAF_DEPRECATED
	Causes the new actor to evaluate message priorities. More...
constexpr spawn_options	lazy_init = spawn_options::lazy_init_flag
	Causes the new actor to delay its initialization until a message arrives.
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 size_t	type_nrs
	The number of built-in types. More...
const char *	numbered_type_names []
	List of all type names, indexed via type_nr.
static constexpr unit_t	unit = unit_t{}
static constexpr unsafe_actor_handle_init_t	unsafe_actor_handle_init = unsafe_actor_handle_init_t{}
constexpr size_t	variant_npos = static_cast<size_t>(-1)

Detailed Description

Root namespace of libcaf.

Typedef Documentation

interface_mismatch_t

template<class Found , class Expected >

using caf::interface_mismatch_t = typedef 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

typedef ipv6_subnet caf::ip_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 = typedef 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.

sorted_builtin_types

using caf::sorted_builtin_types = typedef detail::type_list< actor, std::vector<actor>, actor_addr, std::vector<actor_addr>, atom_value, std::vector<char>, down_msg, downstream_msg, duration, error, exit_msg, group, group_down_msg, int16_t, int32_t, int64_t, int8_t, long double, message, message_id, node_id, open_stream_msg, std::string, std::map<std::string, std::string>, strong_actor_ptr, std::set<std::string>, std::vector<std::string>, timeout_msg, timespan, timestamp, uint16_t, std::u16string, uint32_t, std::u32string, uint64_t, uint8_t, unit_t, upstream_msg, weak_actor_ptr, bool, double, float >

Compile-time list of all built-in types.

Warning

Types are sorted by uniform name.

Enumeration Type Documentation

exit_reason

enum 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.

pec

enum 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.

sec

enum 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.

stream_priority

enum 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 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>

constexpr 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.

put()

template<class T >

void caf::put	(	dictionary< config_value::dictionary > &	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	(	config_value::dictionary &	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	(	config_value::dictionary &	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.

Variable Documentation

deep_to_string

constexpr deep_to_string_t caf::deep_to_string = deep_to_string_t{}

constexpr

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>.

type_nrs

constexpr size_t caf::type_nrs

staticconstexpr

Initial value:

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

The number of built-in types.