Root namespace of libcaf. More...

Namespaces
	exit_reason
	Contains all predefined exit reasons.

	io
	Contains all IO-related classes and functions.

	mixin
	Contains mixin classes implementing several actor traits.

	policy
	Contains policies encapsulating characteristics or algorithms.

Classes
class	abstract_actor
	Base class for all actor implementations. More...

class	abstract_channel
	Interface for all message receivers. More...

class	abstract_group
	A multicast group. More...

class	action
	A functional interface similar to `std::function<void()>` with dispose semantics. More...

class	actor
	Identifies an untyped actor. More...

class	actor_addr
	Stores the address of typed as well as untyped actors. More...

class	actor_cast_access

class	actor_cast_access< actor_control_block *, From, raw_ptr_cast >

class	actor_cast_access< To *, From, raw_ptr_cast >

class	actor_cast_access< To, From, neutral_cast >

class	actor_cast_access< To, From, raw_ptr_cast >

class	actor_cast_access< To, From, weak_ptr_downgrade_cast >

class	actor_cast_access< To, From, weak_ptr_upgrade_cast >

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_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 names. More...

class	actor_storage

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	actor_traits
	Provides uniform access to properties of actor types. More...

struct	actor_traits< typed_actor_view< Sigs... > >

struct	allowed_unsafe_message_type
	Template specializations can whitelist individual types for unsafe message passing operations. More...

class	attachable
	Callback utility class. More...

class	basic_cow_string
	A copy-on-write string implementation that wraps a `std::basic_string`. More...

class	behavior
	Describes the behavior of an actor, i.e., provides a message handler and an optional timeout. More...

class	behavior_type_of

class	behavior_type_of< actor_companion >

class	behavior_type_of< event_based_actor >

class	behavior_type_of< io::broker >

class	behavior_type_of< io::typed_broker< Sigs... > >

class	behavior_type_of< typed_event_based_actor< Sigs... > >

class	binary_deserializer
	Deserializes C++ objects from sequence of bytes. More...

class	binary_serializer
	Serializes C++ objects into a sequence of bytes. More...

class	blocking_actor
	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing. More...

struct	blocking_actor_base
	Marker type for blocking actors. 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< Result(Ts...)>

class	callback_impl
	Utility class for wrapping a function object of type `F`. More...

class	callback_impl< F, Result(Ts...)>

struct	catch_all

struct	composed_type
	Computes the type for f*g (actor composition). More...

struct	composed_type< detail::type_list< Out(In...), Xs... >, Ys, detail::type_list< MapsTo(Out), Zs... >, detail::type_list< Rs... > >

struct	composed_type< detail::type_list< Out(In...), Xs... >, Ys, detail::type_list< MapsTo(Unrelated...), Zs... >, Rs >

struct	composed_type< detail::type_list< result< Out... >(In...), Xs... >, Ys, detail::type_list< MapsTo(Out...), Zs... >, detail::type_list< Rs... > >

struct	composed_type< detail::type_list< X, Xs... >, Ys, detail::type_list<>, Rs >

struct	composed_type< detail::type_list<>, Ys, Zs, detail::type_list< Rs... > >

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

class	config_value_reader
	Extracts objects from a config_value. More...

class	config_value_writer
	Serializes an objects into a config_value. More...

class	const_typed_message_view

class	cow_tuple
	A copy-on-write tuple implementation. More...

class	cow_vector
	A copy-on-write vector implementation that wraps a `std::vector`. More...

struct	deep_to_string_t
	Wraps `deep_to_string` into a function object. 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...

class	default_attachable

class	default_type_id_mapper
	Dispatches to query_type_name and query_type_id. More...

class	delegated
	Helper class to indicate that a request has been forwarded. More...

class	deserializer
	Technology-independent deserialization interface. More...

class	dictionary
	Maps strings to values of type `V`, but unlike `std::map<std::string, V>` accepts `std::string_view` for looking up keys efficiently. More...

class	disposable
	Represents a disposable resource. More...

struct	down_msg
	Sent to all actors monitoring an actor when it is terminated. More...

struct	dyn_spawn_class_helper

struct	dynamically_typed_actor_base
	Marker type for dynamically typed actors. More...

class	error
	A serializable type for storing error codes with category and optional, human-readable context information. More...

class	error_code
	A lightweight wrapper around an error code enum. More...

class	event_based_actor
	A cooperatively scheduled, event-based actor implementation. More...

class	event_based_mtl
	Enables event-based actors to generate messages from a user-defined data exchange format such as JSON and to send the generated messages to another (typed) actor. More...

struct	exec_main_helper

struct	exec_main_helper< detail::type_list< actor_system & > >

struct	exec_main_helper< detail::type_list< actor_system &, const T & > >

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	fun_decorator

class	fun_decorator< F, T, Bhvr, spawn_mode::function, R, detail::type_list< Ts... > >

class	fun_decorator< F, T, Bhvr, spawn_mode::function_with_selfptr, R, detail::type_list< T *, Ts... > >

class	function_view
	A function view for an actor hides any messaging from the caller. More...

struct	function_view_flattened_result

struct	function_view_flattened_result< std::tuple< T > >

struct	function_view_result

struct	function_view_result< typed_actor< Ts... > >

class	function_view_storage

class	function_view_storage< message >

class	function_view_storage< std::tuple< Ts... > >

struct	function_view_storage_catch_all

struct	get_or_auto_deduce
	Configures get_or to uses the get_or_deduction_guide. More...

struct	get_or_deduction_guide
	Customization point for configuring automatic mappings from default value types to deduced types. More...

struct	get_or_deduction_guide< const char * >

struct	get_or_deduction_guide< span< T > >

struct	get_or_deduction_guide< std::string_view >

class	group

struct	group_down_msg
	Sent to all members of a group when it goes offline. More...

class	group_manager

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

class	hashed_node_id

struct	illegal_message_element
	Marker class identifying classes in CAF that are not allowed to be used as message element. More...

struct	infer_handle_from_behavior

struct	infer_handle_from_behavior< typed_behavior< Sigs... > >

struct	infer_handle_from_class
	Deduces `actor` for dynamically typed actors, otherwise `typed_actor<...>` is deduced. More...

struct	infer_handle_from_class< T, false >

struct	infer_handle_from_fun
	Deduces an actor handle type from a function or function object. More...

struct	infer_handle_from_fun_impl

struct	infer_handle_from_fun_impl< behavior, Impl *, true >

struct	infer_handle_from_fun_impl< typed_behavior< Sigs... >, Impl *, true >

struct	infer_handle_from_fun_impl< typed_behavior< Sigs... >, Impl, false >

struct	infer_handle_from_fun_impl< void, Impl *, true >

class	input_range

class	input_range_impl

struct	inspector_access
	Customization point for adding support for a custom type. More...

struct	inspector_access< config_value >

struct	inspector_access< cow_tuple< Ts... > >

struct	inspector_access< optional< T > >

struct	inspector_access< shape_ptr >

struct	inspector_access< std::byte >

struct	inspector_access< std::chrono::duration< Rep, Period > >

struct	inspector_access< std::chrono::time_point< std::chrono::system_clock, Duration > >

struct	inspector_access< std::optional< T > >

struct	inspector_access< std::unique_ptr< error::data > >

struct	inspector_access< std::variant< Ts... > >

struct	inspector_access< uri >

struct	inspector_access_base
	Provides default implementations for `save_field` and `load_field`. More...

struct	inspector_access_type
	Wraps tag types for static dispatching. 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	intrusive_ptr_access
	Policy for adding and releasing references in an intrusive_ptr. More...

struct	invalid_group_t

class	ipv4_address

class	ipv4_endpoint
	An IP endpoint that contains an ::ipv4_address and a port. More...

class	ipv4_subnet

class	ipv6_address

class	ipv6_endpoint
	An IP endpoint that contains an ::ipv6_address and a port. More...

class	ipv6_subnet

struct	is_actor_handle
	Checks whether `T` is an `actor` or a `typed_actor<...>`. More...

struct	is_actor_handle< actor >

struct	is_actor_handle< typed_actor< Ts... > >

struct	is_allowed_unsafe_message_type

struct	is_allowed_unsafe_message_type< const T & >

struct	is_allowed_unsafe_message_type< T & >

struct	is_allowed_unsafe_message_type< T && >

struct	is_catch_all

struct	is_catch_all< catch_all< T > >

struct	is_error_code_enum
	Customization point for enabling conversion from an enum type to an error or error_code. More...

struct	is_handle

struct	is_handle< actor >

struct	is_handle< strong_actor_ptr >

struct	is_handle< typed_actor< Ts... > >

struct	is_illegal_message_element

struct	is_result

struct	is_result< result< Ts... > >

struct	is_timeout_definition

struct	is_timeout_definition< timeout_definition< T > >

struct	is_timeout_or_catch_all

struct	is_timeout_or_catch_all< catch_all< T > >

struct	is_timeout_or_catch_all< timeout_definition< T > >

struct	is_typed_actor
	Evaluates to true if `T` is a `typed_actor<...>`. More...

struct	is_typed_actor< typed_actor< Ts... > >

struct	is_typed_behavior

struct	is_typed_behavior< typed_behavior< Sigs... > >

struct	is_variant_wrapper
	Customization point. More...

struct	is_variant_wrapper< config_value >

struct	is_variant_wrapper< result< Ts... > >

struct	is_variant_wrapper< skippable_result >

struct	is_void_response

struct	is_void_response< detail::type_list< void > >

struct	is_void_response< none_t >

struct	is_void_response< void >

class	json_array
	Represents a JSON array. More...

class	json_builder
	Serializes an inspectable object to a json_value. More...

class	json_object
	Represents a JSON object. More...

class	json_reader
	Deserializes an inspectable object from a JSON-formatted string. More...

class	json_value
	Represents an immutable JSON value. More...

class	json_writer
	Serializes an inspectable object to a JSON-formatted string. More...

struct	keep_behavior_t

struct	lift_void

struct	lift_void< void >

class	load_inspector
	Base type for inspectors that load objects from some input source. More...

class	load_inspector_base

class	local_actor
	Base class for actors running on this node, either living in an own thread or cooperatively scheduled. More...

class	logger
	Centrally logs events from all actors in an actor system. More...

class	mailbox_element

struct	may_have_timeout

struct	may_have_timeout< behavior >

struct	may_have_timeout< timeout_definition< F > >

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

struct	message_verifier

struct	message_verifier< spawn_mode::function, detail::type_list< Ts... > >

struct	message_verifier< spawn_mode::function_with_selfptr, detail::type_list< Self *, Ts... > >

class	monitorable_actor
	Base class for all actor implementations. More...

struct	no_stages_t
	Convenience tag type for producing empty forwarding stacks. More...

struct	node_down_msg
	Sent to all actors monitoring a node when CAF loses connection to it. More...

class	node_id
	A node ID is an opaque value for representing CAF instances in the network. More...

class	node_id_data

struct	non_blocking_actor_base
	Marker type for non-blocking actors. More...

struct	none_t
	Represents "nothing", e.g., for clearing an `optional` by assigning `none`. 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	optional< void >

struct	optional_inspector_access
	Provides inspector access for types that represent optional values. More...

struct	optional_inspector_traits

struct	optional_inspector_traits< intrusive_cow_ptr< T > >

struct	optional_inspector_traits< intrusive_ptr< T > >

struct	optional_inspector_traits< optional< T > >

struct	optional_inspector_traits< std::optional< T > >

struct	optional_inspector_traits< std::shared_ptr< T > >

struct	optional_inspector_traits< std::unique_ptr< T > >

struct	optional_inspector_traits_base

struct	others_t

class	param

struct	parser_state
	Stores all information necessary for implementing an FSM-based parser. More...

struct	partial_behavior_init_t
	Tag type for constructing a `typed_behavior` with an incomplete list of message handlers, delegating to the default handler for all unmatched inputs. More...

struct	prohibit_top_level_spawn_marker

class	proxy_registry
	Groups a (distributed) set of actors and allows actors in the same namespace to exchange 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
	Enables actors to delay a response message by capturing the context of a request message. More...

struct	response_type
	Defines: More...

struct	response_type< detail::type_list< Out(In...), Fs... >, In... >

struct	response_type< detail::type_list< Out(In...), Fs... >, Xs... >

struct	response_type< detail::type_list< result< Out... >(In...), Fs... >, In... >

struct	response_type< detail::type_list<>, Xs... >

struct	response_type< none_t, Xs... >

struct	response_type_unbox
	Unboxes `Xs` and calls `response_type`. More...

struct	response_type_unbox< Ts, detail::type_list< Xs... > >

struct	response_type_unbox< Ts, message >

class	result
	Wraps the result of a message handler to represent either a value (wrapped into a `message`), a `delegated<Ts...>` (indicates that another actor is going to respond), or an `error`. More...

class	result< message >

class	result< T >

class	result< T0, T1, Ts... >

class	result< unit_t >

class	result< void >

class	result_base
	Base type for all specializations of `result`. More...

class	resumable
	A cooperatively executed task managed by one or more instances of `execution_unit`. More...

class	save_inspector
	Base type for inspectors that save objects to some output sink. More...

class	save_inspector_base

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

struct	signatures_of

class	skip_t

class	skippable_result
	Similar to `result<message>`, but also allows to skip a message. More...

class	span
	A C++11/14 drop-in replacement for C++20's `std::span` without support for static extents. More...

class	stateful_actor
	An event-based actor with managed state. More...

struct	statically_typed_actor_base
	Marker type for statically typed actors. More...

class	stream
	Provides access to a potentially unbound sequence of items emitted by an actor. More...

struct	stream_abort_msg
	Informs the sink that a stream has been aborted due to an unrecoverable error. More...

struct	stream_ack_msg
	Informs the sink that the source has added it to the flow. More...

struct	stream_batch_msg
	Transfers items from a source to a sink. More...

struct	stream_cancel_msg
	Informs the source that the sender is no longer interest in receiving items from this stream. More...

struct	stream_close_msg
	Informs the sink that a stream has reached the end. More...

struct	stream_demand_msg
	Asks the source for more data. More...

struct	stream_open_msg
	Asks a source to add another sink. More...

class	string_view
	Drop-in replacement for C++17 std::string_view. More...

class	thread_hook
	Interface to define thread hooks. More...

struct	timeout_definition

class	timeout_definition_builder

class	tracing_data
	Marker interface for application-specific tracing data. More...

class	tracing_data_factory
	Creates instances of tracing_data. More...

struct	type_by_id
	Maps the globally unique ID `V` to a type (inverse to ::type_id). More...

struct	type_id
	Maps the type `T` to a globally unique ID. More...

class	type_id_list
	A list of type IDs, stored in a size-prefix, contiguous memory block. More...

class	type_id_mapper
	Translates between human-readable type names and type IDs. 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...

class	typed_actor
	Identifies a statically typed actor. More...

class	typed_actor_pointer
	Provides a view to an actor that implements this messaging interface without knowledge of the actual type. More...

class	typed_actor_view
	Decorates a pointer to a scheduled_actor with a statically typed actor interface. More...

struct	typed_actor_view_base
	Tag type for typed_actor_view. More...

class	typed_behavior

class	typed_event_based_actor
	A cooperatively scheduled, event-based actor implementation with static type-checking. More...

class	typed_message_view

class	typed_response_promise
	Enables statically typed actors to delay a response message by capturing the context of a request message. More...

class	typed_stream
	Provides access to a statically typed, potentially unbound sequence of items emitted by an actor. More...

struct	unit_t
	Unit is analogous to `void`, but can be safely returned, stored, etc. More...

struct	unlift_void

struct	unlift_void< unit_t >

class	unordered_flat_map
	A map abstraction with an unsorted `std::vector` providing `O(n)` lookup. More...

struct	unsafe_behavior_init_t
	Empty struct tag for constructing a typed behavior from an untyped behavior. More...

class	uri
	A URI according to RFC 3986. More...

class	uri_builder

class	uuid
	A universally unique identifier according to RFC 4122. More...

struct	variant_inspector_access

struct	variant_inspector_traits

struct	variant_inspector_traits< config_value >

struct	variant_inspector_traits< shape_ptr >

struct	variant_inspector_traits< std::variant< Ts... > >

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 >

using	byte_buffer = std::vector< std::byte >
	A buffer for storing binary data.

using	byte_span = span< std::byte >
	Convenience alias for referring to a writable sequence of bytes.

using	const_byte_span = span< const std::byte >
	Convenience alias for referring to a read-only sequence of bytes.

template<class Signature >
using	unique_callback_ptr = std::unique_ptr< callback< Signature > >
	Smart pointer type for heap-allocated callbacks with unique ownership.

template<class Signature >
using	shared_callback_ptr = std::shared_ptr< callback< Signature > >
	Smart pointer type for heap-allocated callbacks with shared ownership.

template<class T >
using	signatures_of_t = typename signatures_of< T >::type

template<class T >
using	deduce_mpi_t = typename detail::dmfou< std::decay_t< T > >::type
	Deduces the message passing interface from a function object.

template<class T >
using	function_view_flattened_result_t = typename function_view_flattened_result< T >::type

using	actor_id = uint64_t

using	instead = std::byte

using	cow_string = basic_cow_string< char >

using	cow_u16string = basic_cow_string< char16_t >

using	cow_u32string = basic_cow_string< char32_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. More...

using	settings = dictionary< config_value >

using	type_id_t = uint16_t
	Internal representation of a type ID.

using	weak_actor_ptr = weak_intrusive_ptr< actor_control_block >

using	group_module_ptr = intrusive_ptr< group_module >

using	strong_actor_ptr = intrusive_ptr< actor_control_block >

using	mailbox_element_ptr = std::unique_ptr< mailbox_element >

using	tracing_data_ptr = std::unique_ptr< tracing_data >

using	shared_action_ptr = std::shared_ptr< callback< void()> >

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

using	high_message_priority_constant = std::integral_constant< message_priority, message_priority::high >

using	normal_message_priority_constant = std::integral_constant< message_priority, message_priority::normal >

using	string_parser_state = parser_state< std::string_view::iterator >
	Specialization for parsers operating on string views.

using	foo = result< void >(Is...)

template<class Fs , class... In>
using	response_type_t = typename response_type< Fs, In... >::type
	Computes the response message type for input `In...` from the list of message passing interfaces `Fs`. More...

template<class Fs , class... In>
using	delegated_response_type_t = typename response_type< Fs, In... >::delegated_type
	Computes the response message type for input `In...` from the list of message passing interfaces `Fs` and returns the corresponding `delegated<T>`. More...

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

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.

Enumerations
enum	exit_reason : uint8_t { exit_reason::normal = 0, 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 { invoke_message_result::consumed, invoke_message_result::skipped, invoke_message_result::dropped }
	Stores the result of a message invocation. More...

enum	message_priority { high = 0, normal = 1 }

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::invalid_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::invalid_argument = 15, pec::missing_argument, pec::invalid_category, pec::invalid_field_name, pec::repeated_field_name, pec::missing_field = 20, pec::invalid_range_expression, pec::invalid_state, pec::nested_too_deeply }
	PEC stands for "Parser Error Code". More...

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::invalid_stream = 30, sec::cannot_resubscribe_stream, sec::bad_function_call = 40, sec::feature_disabled, sec::cannot_open_file, sec::socket_invalid, sec::socket_disconnected, sec::socket_operation_failed = 45, sec::unavailable_or_would_block, sec::incompatible_versions, sec::incompatible_application_ids, sec::malformed_basp_message, sec::serializing_basp_payload_failed = 50, sec::redundant_connection, sec::remote_lookup_failed, sec::no_tracing_context, sec::all_requests_failed, sec::field_invariant_check_failed = 55, sec::field_value_synchronization_failed, sec::invalid_field_type, sec::unsafe_type, sec::save_callback_failed, sec::load_callback_failed = 60, sec::conversion_failed, sec::connection_closed, sec::type_clash, sec::unsupported_operation, sec::no_such_key = 65, sec::broken_promise, sec::connection_timeout, sec::action_reschedule_failed, sec::invalid_observable, sec::too_many_observers = 70, sec::disposed, sec::cannot_open_resource, sec::protocol_error, sec::logic_error }
	SEC stands for "System Error Code". More...

enum	spawn_options : int { no_flags = 0x00, link_flag = 0x01, monitor_flag = 0x02, detach_flag = 0x04, hide_flag = 0x08, priority_aware_flag = 0x20, lazy_init_flag = 0x40 }
	Stores options passed to the `spawn` function family.

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

enum	thread_owner { thread_owner::scheduler, thread_owner::pool, thread_owner::system, thread_owner::other }
	Denotes the component that launched a CAF thread. More...

Functions
template<class F >
action	make_action (F f)
	Convenience function for creating an action from a function object. More...

template<class F >
action	make_single_shot_action (F f)
	Convenience function for creating an action from a function object. More...

CAF_CORE_EXPORT 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`. More...

CAF_CORE_EXPORT bool	operator== (const strong_actor_ptr &, const abstract_actor *)

CAF_CORE_EXPORT bool	operator== (const abstract_actor *, const strong_actor_ptr &)

bool	operator!= (const strong_actor_ptr &x, const abstract_actor *y)

bool	operator!= (const abstract_actor *x, const strong_actor_ptr &y)

CAF_CORE_EXPORT error_code< sec >	load_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid)

CAF_CORE_EXPORT error_code< sec >	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 *)

CAF_CORE_EXPORT std::string	to_string (const strong_actor_ptr &x)

CAF_CORE_EXPORT void	append_to_string (std::string &x, const strong_actor_ptr &y)

CAF_CORE_EXPORT std::string	to_string (const weak_actor_ptr &x)

CAF_CORE_EXPORT void	append_to_string (std::string &x, const weak_actor_ptr &y)

template<class Inspector >
bool	inspect (Inspector &f, strong_actor_ptr &x)

template<class Inspector >
bool	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 ()

CAF_CORE_EXPORT actor_ostream	aout (local_actor *self)
	Convenience factory function for creating an actor output stream.

CAF_CORE_EXPORT actor_ostream	aout (scoped_actor &self)

template<class... Sigs>
actor_ostream	aout (const typed_actor_pointer< Sigs... > &ptr)
	Convenience factory function for creating an actor output stream.

CAF_CORE_EXPORT const settings &	content (const actor_system_config &cfg)
	Returns all user-provided configuration parameters.

template<class Rep , class Period >
constexpr auto	after (std::chrono::duration< Rep, Period > d)
	Returns a generator for timeouts.

template<class IntegerType , class = std::enable_if_t<std::is_integral<IntegerType>::value>>
constexpr IntegerType	to_integer (std::byte x) noexcept

template<class T >
constexpr bool	statically_typed ()

template<class ForwardIterator , class Sentinel >
std::pair< ForwardIterator, std::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. More...

template<class T >
expected< T >	get_as (const config_value &, inspector_access_type::none)

template<class T >
expected< T >	get_as (const config_value &, inspector_access_type::unsafe)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::specialization token)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::inspect token)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::builtin_inspect token)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::builtin)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::empty)

template<class T , size_t... Is>
expected< T >	get_as_tuple (const config_value::list &x, std::index_sequence< Is... >)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::tuple)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::map)

template<class T >
expected< T >	get_as (const config_value &x, inspector_access_type::list)

template<class... Ts>
config_value	make_config_value_list (Ts &&... xs)

template<size_t Index, class... Ts>
const auto &	get (const_typed_message_view< Ts... > xs)

template<class... Ts, size_t... Is>
auto	to_tuple (const_typed_message_view< Ts... > xs, std::index_sequence< Is... >)

template<class... Ts>
auto	to_tuple (const_typed_message_view< Ts... > xs)

template<class... Ts>
auto	make_const_typed_message_view (const message &msg)

template<class... Ts>
std::optional< std::tuple< Ts... > >	to_tuple (const message &msg)

template<class T >
auto	operator== (const cow_vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs.std()==ys.std())

template<class T >
auto	operator== (const cow_vector< T > &xs, const std::vector< T > &ys) -> decltype(xs.std()==ys)

template<class T >
auto	operator== (const std::vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs==ys.std())

template<class T >
auto	operator!= (const cow_vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs.std() !=ys.std())

template<class T >
auto	operator!= (const cow_vector< T > &xs, const std::vector< T > &ys) -> decltype(xs.std() !=ys)

template<class T >
auto	operator!= (const std::vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs !=ys.std())

template<class T >
std::string	deep_to_string (const T &x)
	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...

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 Inspector , class Enumeration >
bool	default_enum_inspect (Inspector &f, Enumeration &x)
	Convenience function for providing a default inspection scaffold for custom enumeration types. More...

template<class... Ts>
bool	operator== (const delegated< Ts... > &, const delegated< Ts... > &)

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 Enum >
auto	to_string (error_code< Enum > x) -> decltype(to_string(x.value()))
	Converts `x` to a string if `Enum` provides a `to_string` function.

template<class T >
void	exec_main_init_meta_objects_single ()

template<class... Ts>
void	exec_main_init_meta_objects ()

template<class T >
void	exec_main_load_module (actor_system_config &cfg)

template<class... Ts, class F = void (*)(actor_system&)>
int	exec_main (F fun, int argc, char **argv)

template<class Inspector >
bool	inspect (Inspector &f, exit_reason &x)

template<>
class	deprecated ("use expected<void> instead")]] expected< unit_t >

template<class T >
std::string	to_string (const expected< T > &x)

std::string	to_string (const expected< void > &x)

template<class >
class	deprecated ("use std::optional instead")]] optional

class	deprecated ("use std::string_view instead")]] string_view

template<class T >
config_option	make_config_option (std::string_view category, std::string_view name, std::string_view description)
	Creates a config option that synchronizes with `storage`.

template<class T >
config_option	make_config_option (T &storage, std::string_view category, std::string_view name, std::string_view description)
	Creates a config option that synchronizes with `storage`.

template<class ProjectIds , uint16_t... Is>
void	init_global_meta_objects_impl (std::integer_sequence< uint16_t, Is... >)

template<class ProjectIds >
void	init_global_meta_objects ()
	Initializes the global meta object table with all types in `ProjectIds`. More...

template<class T >
std::string	to_string (const intrusive_ptr< T > &x)

CAF_CORE_EXPORT std::string	to_string (invoke_message_result)

CAF_CORE_EXPORT std::string	to_string (const ipv4_endpoint &ep)

CAF_CORE_EXPORT error	parse (std::string_view str, ipv6_address &dest)

CAF_CORE_EXPORT std::string	to_string (const ipv6_endpoint &ep)

bool	operator== (const json_array::const_iterator &lhs, const json_array::const_iterator &rhs) noexcept

bool	operator!= (const json_array::const_iterator &lhs, const json_array::const_iterator &rhs) noexcept

bool	operator== (const json_array &lhs, const json_array &rhs) noexcept

bool	operator!= (const json_array &lhs, const json_array &rhs) noexcept

bool	operator== (const json_object::const_iterator &lhs, const json_object::const_iterator &rhs) noexcept

bool	operator!= (const json_object::const_iterator &lhs, const json_object::const_iterator &rhs) noexcept

bool	operator== (const json_object &lhs, const json_object &rhs) noexcept

bool	operator!= (const json_object &lhs, const json_object &rhs) noexcept

bool	operator== (const json_value &lhs, const json_value &rhs)

bool	operator!= (const json_value &lhs, const json_value &rhs)

CAF_CORE_EXPORT std::string	to_string (logger::field_type x)

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)

CAF_CORE_EXPORT config_option	make_negated_config_option (bool &storage, std::string_view category, std::string_view name, std::string_view description)

template<class Inspector >
bool	inspect (Inspector &f, message_id &x)

CAF_CORE_EXPORT std::string	to_string (message_priority)

template<class Self , class Adapter , class Reader >
auto	make_mtl (Self self, Adapter adapter, Reader reader)
	Creates an MTL (message translation layer) to enable an actor to exchange messages with non-CAF endpoints over a user-defined data exchange format such as JSON. More...

template<class Iterator , class Sentinel , class... Ts>
auto	make_error (const parser_state< Iterator, Sentinel > &ps, Ts &&... xs) -> 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. More...

template<class... Is>
struct	deprecated ("write 'result<foo>(bar)' instead of " "'replies_to<bar>::with<foo>'")]] replies_to

template<class... Ts>
auto	make_result (Ts &&... xs)
	Convenience function for wrapping the parameter pack `xs...` into a `result`. More...

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 >
auto	get_or (const settings &xs, defaults::parameter< T > param)
	Convenience overload for calling `get_or(xs, param.name, param.fallback)`.

template<class T >
config_value &	put (settings &xs, std::string_view key, T &&value)
	Converts `value` to a `config_value` and assigns it to `key`. More...

template<class T >
void	put_missing (settings &xs, std::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). More...

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

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

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 std::byte >	as_bytes (span< T > xs)

template<class T >
span< std::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. More...

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

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

template<class T >
span< T >	make_span (T first, T last)
	Convenience function to make using `caf::span` more convenient without the deduction guides. More...

constexpr spawn_options	operator+ (spawn_options x, spawn_options y)
	Concatenates two spawn_options.

constexpr bool	has_spawn_option (spawn_options haystack, spawn_options needle)
	Checks whether `haystack` contains `needle`.

constexpr bool	has_detach_flag (spawn_options opts)
	Checks whether the detached flag is set in `opts`.

constexpr bool	has_priority_aware_flag (spawn_options)
	Checks whether the priority_aware flag is set in `opts`.

constexpr bool	has_hide_flag (spawn_options opts)
	Checks whether the hidden flag is set in `opts`.

constexpr bool	has_link_flag (spawn_options opts)
	Checks whether the linked flag is set in `opts`.

constexpr bool	has_monitor_flag (spawn_options opts)
	Checks whether the monitored flag is set in `opts`.

constexpr bool	has_lazy_init_flag (spawn_options opts)
	Checks whether the lazy_init flag is set in `opts`.

constexpr std::string_view	is_any_of (std::string_view arg) noexcept

CAF_CORE_EXPORT void	split (std::vector< std::string > &result, std::string_view str, std::string_view delims, bool keep_all=true)

CAF_CORE_EXPORT void	split (std::vector< std::string_view > &result, std::string_view str, std::string_view delims, bool keep_all=true)

CAF_CORE_EXPORT void	split (std::vector< std::string > &result, std::string_view str, char delim, bool keep_all=true)

CAF_CORE_EXPORT void	split (std::vector< std::string_view > &result, std::string_view str, char delim, bool keep_all=true)

constexpr std::string_view	make_string_view (const char first, const char last)

CAF_CORE_EXPORT std::string_view	trim (std::string_view str)
	Drops any leading and trailing whitespaces from `str`.

CAF_CORE_EXPORT bool	icase_equal (std::string_view x, std::string_view y)
	Checks whether two strings are equal when ignoring upper/lower case.

CAF_CORE_EXPORT std::pair< std::string_view, std::string_view >	split_by (std::string_view str, std::string_view sep)
	Splits a string by a separator into a head and a tail. More...

template<class InputIterator >
std::string	join (InputIterator first, InputIterator last, std::string_view glue)

template<class Container >
std::string	join (const Container &c, std::string_view glue)

CAF_CORE_EXPORT void	replace_all (std::string &str, std::string_view what, std::string_view with)
	Replaces all occurrences of `what` by `with` in `str`.

CAF_CORE_EXPORT bool	starts_with (std::string_view str, std::string_view prefix)
	Returns whether `str` begins with `prefix`.

CAF_CORE_EXPORT bool	ends_with (std::string_view str, std::string_view suffix)
	Returns whether `str` ends with `suffix`.

CAF_CORE_EXPORT std::ostream &	operator<< (std::ostream &out, term x)

constexpr bool	is_infinite (timespan value)
	Checks whether `value` represents an infinite amount of time.

CAF_CORE_EXPORT timestamp	make_timestamp ()
	Convenience function for returning a `timestamp` representing the current system time. More...

CAF_CORE_EXPORT std::string	timestamp_to_string (timestamp x)
	Prints `x` in ISO 8601 format, e.g., `2018-11-15T06:25:01.462`.

CAF_CORE_EXPORT expected< timestamp >	timestamp_from_string (std::string_view str)
	Converts an ISO 8601 formatted timestamp into its native representation.

CAF_CORE_EXPORT 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`. More...

template<class T >
std::string_view	type_name_or_anonymous ()
	Returns `type_name_v<T>` if available, "anonymous" otherwise.

template<class T >
type_id_t	type_id_or_invalid ()
	Returns `type_id_v<T>` if available, `invalid_type_id` otherwise.

CAF_CORE_EXPORT std::string_view	query_type_name (type_id_t type)
	Returns the type name for `type` or an empty string if `type` is an invalid ID. More...

CAF_CORE_EXPORT type_id_t	query_type_id (std::string_view name)
	Returns the type for `name` or `invalid_type_id` if `name` is unknown.

template<class... Ts>
type_id_list	types_of (const std::tuple< Ts... > &)

template<class T >
auto	typed_actor_view_flow_access (caf::scheduled_actor *self)
	Utility function to force the type of `self` to depend on `T` and to raise a compiler error if the user did not include 'caf/scheduled_actor/flow.hpp'. More...

template<class... Fs>
typed_behavior< deduce_mpi_t< Fs >... >	make_typed_behavior (Fs... fs)
	Creates a typed behavior from given function objects.

template<size_t Index, class... Ts>
auto &	get (typed_message_view< Ts... > x)

template<class... Ts>
auto	make_typed_message_view (message &msg)

template<class Inspector >
bool	inspect (Inspector &f, uri::authority_type &x)

template<class Inspector >
bool	inspect (Inspector &f, uri::impl_type &x)

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_release_weak (actor_control_block *x)

void	intrusive_ptr_release (actor_control_block *x)

void	swap (config_option &first, config_option &second) noexcept

bool	operator< (double x, const config_value &y)

bool	operator<= (double x, const config_value &y)

bool	operator== (double x, const config_value &y)

bool	operator> (double x, const config_value &y)

bool	operator>= (double x, const config_value &y)

bool	operator< (const config_value &x, double y)

bool	operator<= (const config_value &x, double y)

bool	operator== (const config_value &x, double y)

bool	operator> (const config_value &x, double y)

bool	operator>= (const config_value &x, double 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)

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::string	to_string (const settings &xs)

std::ostream &	operator<< (std::ostream &out, const config_value &x)

std::string	to_string (const error &x)

std::string	to_string (const group &x)

ipv4_address	make_ipv4_address (uint8_t oct1, uint8_t oct2, uint8_t oct3, uint8_t oct4)

std::string	to_string (const ipv4_address &x)

error	parse (std::string_view str, ipv4_address &dest)

std::string	to_string (ipv4_subnet x)

std::string	to_string (ipv6_address x)

std::string	to_string (ipv6_subnet x)

std::string	to_string (const json_array &arr)

std::string	to_string (const json_object &obj)

std::string	to_string (const json_value &val)

std::string_view	as_json_type_name (json_writer::type t)

std::string	to_string (const logger::field &x)

bool	operator== (const logger::field &x, const logger::field &y)

mailbox_element_ptr	make_mailbox_element (strong_actor_ptr sender, message_id id, mailbox_element::forwarding_stack stages, message payload)

std::string	to_string (const message &msg)

void	append_to_string (std::string &str, const node_id &x)

std::string	to_string (const node_id &x)

node_id	make_node_id (uri from)

node_id	make_node_id (uint32_t process_id, const hashed_node_id::host_id_type &host_id)

std::optional< node_id >	make_node_id (uint32_t process_id, std::string_view host_hash)

error	parse (std::string_view str, node_id &dest)

skippable_result	reflect (scheduled_actor *, message &msg)

skippable_result	reflect_and_quit (scheduled_actor *ptr, message &msg)

skippable_result	print_and_drop (scheduled_actor *ptr, message &msg)

skippable_result	drop (scheduled_actor *, message &)

std::string	to_string (const scoped_actor &x)

std::string	to_string (sec x)

bool	from_string (std::string_view in, sec &out)

bool	from_integer (std::underlying_type_t< sec > in, sec &out)

const config_value *	get_if (const settings *xs, std::string_view name)

expected< std::string >	get_or (const settings &xs, std::string_view name, const char *fallback)

config_value &	put_impl (settings &dict, const std::vector< std::string_view > &path, config_value &value)

bool	inspect (serializer &sink, const tracing_data_ptr &x)

bool	inspect (binary_serializer &sink, const tracing_data_ptr &x)

bool	inspect (deserializer &source, tracing_data_ptr &x)

bool	inspect (binary_deserializer &source, tracing_data_ptr &x)

std::string	to_string (type_id_list xs)

type_id_list	types_of (const message &msg)

std::string	to_string (const uri &x)

std::string	to_string (const uri::authority_type &x)

error	parse (std::string_view str, uri &dest)

expected< uri >	make_uri (std::string_view str)

error	parse (std::string_view str, uuid &dest)

std::string	to_string (const uuid &x)

expected< uuid >	make_uuid (std::string_view str)

template<class T >
bool	operator== (const unordered_flat_map< int, T > &xs, const std::vector< std::pair< int, T >> &ys)

template<class T >
bool	operator== (const std::vector< std::pair< int, T >> &xs, const unordered_flat_map< int, T > &ys)

template<class... Ts>
bool	operator== (const message &x, const std::tuple< Ts... > &y)

template<class T >
bool	operator== (const message &x, const T &y)

Variables
constexpr actor_id	invalid_actor_id = 0
	Denotes an ID that is never used by an actor.

template<class T >
constexpr bool	is_allowed_unsafe_message_type_v = allowed_unsafe_message_type<T>::value

template<class >
class nodiscard	error_code

class nodiscard	error

constexpr no_stages_t	no_stages = no_stages_t{}
	Convenience tag for producing empty forwarding stacks.

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

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

constexpr spawn_options	linked = spawn_options::link_flag
	Causes `spawn` to call `self->link_to(...) immediately after the new actor was spawned. More...

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	lazy_init = spawn_options::lazy_init_flag
	Causes the new actor to delay its initialization until a message arrives. More...

constexpr bool	token_compress_on = false

constexpr type_id_t	invalid_type_id = 65535
	Special value equal to the greatest possible value for `type_id_t`. More...

constexpr type_id_t	first_custom_type_id = 200
	The first type ID not reserved by CAF and its modules.

template<class T >
constexpr bool	has_type_id_v = detail::is_complete<type_id<T>>
	Checks whether `type_id` is specialized for `T`.

constexpr partial_behavior_init_t	partial_behavior_init = partial_behavior_init_t{}

constexpr unsafe_behavior_init_t	unsafe_behavior_init = unsafe_behavior_init_t{}
	Convenience constant for constructing a typed behavior from an untyped behavior. More...

Detailed Description

Root namespace of libcaf.

Typedef Documentation

◆ delegated_response_type_t

template<class Fs , class... In>

using caf::delegated_response_type_t = typedef typename response_type<Fs, In...>::delegated_type

Computes the response message type for input In... from the list of message passing interfaces Fs and returns the corresponding delegated<T>.

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

◆ response_type_t

template<class Fs , class... In>

using caf::response_type_t = typedef typename response_type<Fs, In...>::type

Computes the response message type for input In... from the list of message passing interfaces Fs.

◆ response_type_unbox_t

template<class Ts , class Xs >

using caf::response_type_unbox_t = typedef typename response_type_unbox<Ts, Xs>::type

Computes the response message for input Xs from the list of message passing interfaces Ts.

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.
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 finished 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 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 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.
invalid_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.
invalid_argument	Stopped at an unparsable argument.
missing_argument	Stopped because an argument was omitted.
invalid_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.
invalid_range_expression	Parsing a range statement ('n..m' or 'n..m..step') failed.
invalid_state	Stopped after running into an invalid parser state. Should never happen and most likely indicates a bug in the implementation.
nested_too_deeply	Parser stopped after exceeding its maximum supported level of nesting.

◆ 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.
invalid_stream	Subscribing to a stream failed because it was invalid.
cannot_resubscribe_stream	Subscribing to a stream failed because it can only be subscribed to once.
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.
no_tracing_context	Serialization failed because actor_system::tracing_context is null.
all_requests_failed	No request produced a valid result.
field_invariant_check_failed	Deserialization failed because an invariant got violated after reading the content of a field.
field_value_synchronization_failed	Deserialization failed because a setter rejected the input.
invalid_field_type	Deserialization failed because the source announced an invalid type.
unsafe_type	Serialization failed because a type was flagged as unsafe message type.
save_callback_failed	Serialization failed because a save callback returned `false`.
load_callback_failed	Deserialization failed because a load callback returned `false`.
conversion_failed	Converting between two types failed.
connection_closed	A network connection was closed by the remote side.
type_clash	An operation failed because run-time type information diverged from the expected type.
unsupported_operation	An operation failed because the callee does not implement this functionality.
no_such_key	A key lookup failed.
broken_promise	An destroyed a response promise without calling deliver or delegate on it.
connection_timeout	Disconnected from a BASP node after reaching the connection timeout.
action_reschedule_failed	Signals that an actor fell behind a periodic action trigger. After raising this error, an actor_clock stops scheduling the action.
invalid_observable	Attaching to an observable failed because the target is invalid.
too_many_observers	Attaching to an observable failed because the target already reached its maximum observer count.
disposed	Signals that an operation failed because the target has been disposed.
cannot_open_resource	Failed to open a resource.
protocol_error	Received malformed data.
logic_error	Encountered faulty logic in the program.

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

◆ thread_owner

enum caf::thread_owner

strong

Denotes the component that launched a CAF thread.

Enumerator
scheduler	Indicates that the thread belongs to the cooperative scheduler.
pool	Indicates that the thread belongs to the internal thread pool for detached and blocking actors.
system	Indicates that the thread runs background activity such as logging for the actor system.
other	Indicates that the thread has been launched by request of a user without using any of the default mechanisms above.

Function Documentation

◆ actor_cast()

template<class T , class U >

T caf::actor_cast ( U && what )

Converts actor handle what to a different actor handle or raw pointer of type T.

◆ append_timestamp_to_string()

void caf::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.

◆ deep_to_string()

template<class T >

std::string caf::deep_to_string ( const T & x )

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

◆ default_enum_inspect()

template<class Inspector , class Enumeration >

bool caf::default_enum_inspect	(	Inspector &	f,
		Enumeration &	x
	)

Convenience function for providing a default inspection scaffold for custom enumeration types.

The enumeration type must provide the following interface based on free functions:

{(cpp)}
enum class Enumeration : ... { ... };
std::string to_string(Enumeration);
bool from_string(string_view, Enumeration&);
bool from_integer(std::underlying_type_t<Enumeration>, Enumeration&);

◆ find_by_long_name()

template<class ForwardIterator , class Sentinel >

std::pair<ForwardIterator, std::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 string_view of the option value if the entry is found and a ForwardIterator to last with an empty string_view otherwise.

◆ init_global_meta_objects()

template<class ProjectIds >

void caf::init_global_meta_objects ( )

Initializes the global meta object table with all types in ProjectIds.

Warning: calling this after constructing any ::actor_system is unsafe and causes undefined behavior.

◆ init_global_meta_objects_impl()

template<class ProjectIds , uint16_t... Is>

void caf::init_global_meta_objects_impl ( std::integer_sequence< uint16_t, Is... > )

Warning: calling this after constructing any ::actor_system is unsafe and causes undefined behavior.

◆ make_action()

template<class F >

action caf::make_action ( F f )

Convenience function for creating an action from a function object.

Parameters

f	The body for the action.

◆ make_error()

template<class Iterator , class Sentinel , class... Ts>

auto caf::make_error	(	const parser_state< Iterator, Sentinel > &	ps,
		Ts &&...	xs
	)		-> 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.

◆ make_mtl()

template<class Self , class Adapter , class Reader >

auto caf::make_mtl	(	Self *	self,
		Adapter	adapter,
		Reader *	reader
	)

Creates an MTL (message translation layer) to enable an actor to exchange messages with non-CAF endpoints over a user-defined data exchange format such as JSON.

Parameters

self	Points to an event-based or blocking actor.
adapter	Translates between internal and external message types.
reader	Points to an object that either implements the interface deserializer directly or that provides a compatible API.

◆ make_result()

template<class... Ts>

auto caf::make_result ( Ts &&... xs )

Convenience function for wrapping the parameter pack xs... into a result.

◆ make_single_shot_action()

template<class F >

action caf::make_single_shot_action ( F f )

Convenience function for creating an action from a function object.

Parameters

f	The body for the action.

◆ make_span() [1/4]

template<class T >

auto caf::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.

◆ make_span() [2/4]

template<class T , size_t N>

span<T> caf::make_span ( T(&) xs[N] )

Convenience function to make using caf::span more convenient without the deduction guides.

◆ make_span() [3/4]

template<class T >

span<T> caf::make_span	(	T *	first,
		size_t	size
	)

Convenience function to make using caf::span more convenient without the deduction guides.

◆ make_span() [4/4]

template<class T >

span<T> caf::make_span	(	T *	first,
		T *	last
	)

Convenience function to make using caf::span more convenient without the deduction guides.

◆ make_timestamp()

timestamp caf::make_timestamp ( )

Convenience function for returning a timestamp representing the current system time.

◆ put()

template<class T >

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

Converts value to a config_value and assigns it to key.

Parameters

xs	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,
		std::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`.

◆ query_type_name()

std::string_view caf::query_type_name ( type_id_t type )

Returns the type name for type or an empty string if type is an invalid ID.

◆ split_by()

std::pair< std::string_view, std::string_view > caf::split_by	(	std::string_view	str,
		std::string_view	sep
	)

Splits a string by a separator into a head and a tail.

If sep was not found, the tail is empty.

◆ typed_actor_view_flow_access()

template<class T >

auto caf::typed_actor_view_flow_access ( caf::scheduled_actor * self )

Utility function to force the type of self to depend on T and to raise a compiler error if the user did not include 'caf/scheduled_actor/flow.hpp'.

The function itself does nothing and simply returns self.

Variable Documentation

◆ invalid_type_id

constexpr type_id_t caf::invalid_type_id = 65535

Special value equal to the greatest possible value for type_id_t.

Generally indicates that no type ID for a given type exists.

◆ skip

constexpr skip_t caf::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.

◆ unsafe_behavior_init

constexpr unsafe_behavior_init_t caf::unsafe_behavior_init = unsafe_behavior_init_t{}

Convenience constant for constructing a typed behavior from an untyped behavior.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ delegated_response_type_t

◆ interface_mismatch_t

◆ ip_subnet

◆ response_type_t

◆ response_type_unbox_t

Enumeration Type Documentation

◆ exit_reason

◆ invoke_message_result

◆ pec

◆ sec

◆ term

◆ thread_owner

Function Documentation

◆ actor_cast()

◆ append_timestamp_to_string()

◆ deep_to_string()

◆ default_enum_inspect()

◆ find_by_long_name()

◆ init_global_meta_objects()

◆ init_global_meta_objects_impl()

◆ make_action()

◆ make_error()

◆ make_mtl()

◆ make_result()

◆ make_single_shot_action()

◆ make_span() [1/4]

◆ make_span() [2/4]

◆ make_span() [3/4]

◆ make_span() [4/4]

◆ make_timestamp()

◆ put()

◆ put_dictionary()

◆ put_list()

◆ put_missing()

◆ query_type_name()

◆ split_by()

◆ typed_actor_view_flow_access()

Variable Documentation

◆ invalid_type_id

◆ skip

◆ unsafe_behavior_init