Loading...
Searching...
No Matches
caf Namespace Reference

Root namespace of libcaf. More...

## Namespaces

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

## Classes

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

## Typedefs

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

## Enumerations

enum class | atom_value : uint64_t
| The value type of atoms.
enum class | byte : uint8_t
| A C++11/14 drop-in replacement for C++17's std::byte.
enum class | select_config_value_hint { is_integral , is_map , is_list , is_custom , is_missing }
enum class | time_unit : uint32_t
| SI time units to specify timeouts.
enum class | exit_reason : uint8_t { normal = 0 , unhandled_exception , unknown , out_of_workers , user_shutdown , kill , remote_link_unreachable , unreachable }
| This error category represents fail conditions for actors. More...
enum class | spawn_mode { function , function_with_selfptr , clazz }
enum class | invoke_message_result { consumed , skipped , dropped }
| Stores the result of a message invocation. More...
enum class | message_priority { high = 0 , normal = 1 }
| Denotes the urgency of asynchronous messages.

enum class

pec : uint8_t {
success = 0 ,
trailing_character = 1 ,
unexpected_eof ,
unexpected_character ,
timespan_overflow ,
fractional_timespan = 5 ,
too_many_characters ,
illegal_escape_sequence ,
unexpected_newline ,
integer_overflow ,
integer_underflow = 10 ,
exponent_underflow ,
exponent_overflow ,
type_mismatch ,
not_an_option ,
illegal_argument = 15 ,
missing_argument ,
illegal_category ,
invalid_field_name ,
repeated_field_name ,
missing_field
}

| PEC stands for "Parser Error Code". More...
enum | result_runtime_type { rt_value , rt_error , rt_delegated , rt_skip }

enum class

sec : uint8_t {
none = 0 ,
unexpected_message = 1 ,
unexpected_response ,
request_receiver_down ,
request_timeout ,
no_such_group_module = 5 ,
no_actor_published_at_port ,
unexpected_actor_messaging_interface ,
state_not_serializable ,
unsupported_sys_key ,
unsupported_sys_message = 10 ,
disconnect_during_handshake ,
cannot_forward_to_invalid_actor ,
no_route_to_receiving_node ,
failed_to_assign_scribe_from_handle ,
failed_to_assign_doorman_from_handle = 15 ,
cannot_close_invalid_port ,
cannot_connect_to_node ,
cannot_open_port ,
network_syscall_failed ,
invalid_argument = 20 ,
invalid_protocol_family ,
cannot_publish_invalid_actor ,
cannot_spawn_actor_from_arguments ,
end_of_stream ,
no_context = 25 ,
unknown_type ,
no_proxy_registry ,
runtime_error ,
remote_linking_failed ,
cannot_add_upstream = 30 ,
upstream_already_exists ,
invalid_upstream ,
cannot_add_downstream ,
downstream_already_exists ,
invalid_downstream = 35 ,
no_downstream_stages_defined ,
stream_init_failed ,
invalid_stream_state ,
unhandled_stream_error ,
bad_function_call = 40 ,
feature_disabled ,
cannot_open_file ,
socket_invalid ,
socket_disconnected ,
socket_operation_failed = 45 ,
unavailable_or_would_block ,
incompatible_versions ,
incompatible_application_ids ,
malformed_basp_message ,
serializing_basp_payload_failed = 50 ,
redundant_connection ,
remote_lookup_failed ,
connection_timeout
}

| SEC stands for "System Error Code". More...
enum class | stream_priority { very_high , high , normal , low , very_low }
| Categorizes individual streams. More...
enum class | term { reset , reset_endl , black , red , green , yellow , blue , magenta , cyan , white , bold_black , bold_red , bold_green , bold_yellow , bold_blue , bold_magenta , bold_cyan , bold_white }
| Terminal color and font face options. More...

## Functions

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

## Variables

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

## Detailed Description

Root namespace of libcaf.

## Typedef Documentation

## default_downstream_manager_t

template<class F>

using caf::default_downstream_manager_t

Initial value:
typename default_downstream_manager<F>::type
caf::default_downstream_manager::type
broadcast_downstream_manager< output_type > type
The default downstream manager deduced by this trait.
Definition default_downstream_manager.hpp:51

## enable_if_has_make_error_t

template<class T, class U = void>

using caf::enable_if_has_make_error_t

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

Convenience alias to detect enums that provide make_error overloads.

## function_view_flattened_result_t

template<class T>

using caf::function_view_flattened_result_t

Initial value:
typename function_view_flattened_result<T>::type

## interface_mismatch_t

template<class Found, class Expected>

using caf::interface_mismatch_t

Initial value:
detail::imi<0, Found, Expected,
detail::type_list<>>
caf::detail::type_list<>

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

Returns the number of elements on a match.

Precondition
  len(Found) == len(Expected)

## ip_subnet

using caf::ip_subnet = ipv6_subnet

An IP subnetwork.

The address family is IPv6 unless embeds_v4 returns true.

## make_stage_result_t

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

using caf::make_stage_result_t

Initial value:
make_stage_result<In, DownstreamManager, detail::strip_and_convert_t<Ts>...>
caf::make_stage_result
Returns a stream stage with the slot IDs of its first in- and outbound paths.
Definition make_stage_result.hpp:36

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

Hardwires message as result type.

## primitive_variant

using caf::primitive_variant

Initial value:
variant<int8_t, int16_t, int32_t, int64_t,
uint8_t, uint16_t, uint32_t, uint64_t,
float, double, long double,
std::string, std::u16string, std::u32string,
atom_value, bool>
caf::variant
A variant represents always a valid value of one of the types Ts....
Definition variant.hpp:119
caf::atom_value
atom_value
The value type of atoms.
Definition atom.hpp:32

## rtti_pair

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

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

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

## select_config_value_access_t

template<class T>

using caf::select_config_value_access_t

Initial value:
typename select_config_value_access<
T>::type
caf::select_config_value_access
Delegates to config_value_access for all specialized versions.
Definition config_value.hpp:344

## sorted_builtin_types

using caf::sorted_builtin_types

Compile-time list of all built-in types.

Warning
  Types are sorted by uniform name.

## stream_sink_trait_t

template<class Fun>

using caf::stream_sink_trait_t

Initial value:
stream_sink_trait<typename detail::get_callable_trait<Fun>::fun_sig>
caf::stream_sink_trait
Defines required type aliases for stream sinks.
Definition stream_sink_trait.hpp:67

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

## stream_source_trait_t

template<class Pull>

using caf::stream_source_trait_t

Initial value:
stream_source_trait<typename detail::get_callable_trait<Pull>::fun_sig>
caf::stream_source_trait
Deduces the output type and the state type for a stream source from its pull implementation.
Definition stream_source_trait.hpp:30

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

## stream_stage_trait_t

template<class Process>

using caf::stream_stage_trait_t

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

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

## sum_type_visit_result_t

template<class F, class... Ts>

using caf::sum_type_visit_result_t

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

## variant_visit_result_t

template<class F, class... Ts>

using caf::variant_visit_result_t

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

## Enumeration Type Documentation

## exit_reason

enum class caf::exit_reason : uint8_t

strong

This error category represents fail conditions for actors.

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

## invoke_message_result

enum class caf::invoke_message_result

strong

Stores the result of a message invocation.

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

## pec

enum class caf::pec : uint8_t

strong

PEC stands for "Parser Error Code".

This enum contains error codes used by various CAF parsers.

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

## sec

enum class caf::sec : uint8_t

strong

SEC stands for "System Error Code".

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

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

## stream_priority

enum class caf::stream_priority

strong

Categorizes individual streams.

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

## term

enum class caf::term

strong

Terminal color and font face options.

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

## Function Documentation

## atom_uint()

template<size_t Size>

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

constexpr

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

## attach_continuous_stream_source() [1/2]

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

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

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

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

Parameters

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

Returns
  The new stream_manager.

## attach_continuous_stream_source() [2/2]

template<class Driver, class... Ts>

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

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

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

Parameters

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

Returns
  The new stream_manager.

## attach_continuous_stream_stage() [1/2]

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

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

Parameters

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

## attach_continuous_stream_stage() [2/2]

template<class Driver, class... Ts>

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

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

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

Parameters

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

Returns
  The new stream_manager.

## attach_stream_sink() [1/2]

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

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

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

Parameters

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

Returns
  The new stream_manager and the inbound slot.

## attach_stream_sink() [2/2]

template<class Driver, class... Ts>

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

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

Parameters

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

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

## attach_stream_source() [1/5]

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

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

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

Parameters

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

Returns
  The allocated stream_manager and the output slot.

## attach_stream_source() [2/5]

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

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

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

Parameters

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

Returns
  The allocated stream_manager and the output slot.

## attach_stream_source() [3/5]

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

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

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

Parameters

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

Returns
  The allocated stream_manager and the output slot.

## attach_stream_source() [4/5]

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

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

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

Parameters

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

Returns
  The allocated stream_manager and the output slot.

## attach_stream_source() [5/5]

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

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

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

Parameters

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

Returns
  The allocated stream_manager and the output slot.

## attach_stream_stage() [1/3]

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

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

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

Parameters

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

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

## attach_stream_stage() [2/3]

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

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

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

Parameters

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

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

## attach_stream_stage() [3/3]

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

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

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

Parameters

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

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

## deep_to_string()

template<class... Ts>

std::string caf::deep_to_string | ( | const Ts &... | xs | ) |

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

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

## find_by_long_name()

template<class ForwardIterator, class Sentinel>

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

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

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

## put()

template<class T>

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

Converts value to a config_value and assigns it to key.

Parameters

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

## put_dictionary()

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

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

Overrides existing entries with the same name.

## put_list()

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

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

Overrides existing entries with the same name.

## put_missing()

template<class T>

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

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

Parameters

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

## Variable Documentation

## type_nrs

size_t caf::type_nrs

static constexpr

Initial value:
= detail::tl_size<sorted_builtin_types>::value
+ 1
caf::detail::tl_size
Gets the number of template parameters of List.
Definition type_list.hpp:101

The number of built-in types.