|
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 | actor_traits |
| Provides uniform access to properties of actor types. More...
|
|
struct | add_param |
| Converts T to param<T> unless T is arithmetic, an atom constant, or a stream handshake. More...
|
|
struct | allowed_unsafe_message_type |
| Template specializations can whitelist individual types for unsafe message passing operations. More...
|
|
class | arraybuf |
| A streambuffer abstraction over a fixed array of bytes. More...
|
|
struct | atom_constant |
| Lifts an atom_value to a compile-time constant. More...
|
|
class | attachable |
| Callback utility class. More...
|
|
class | behavior |
| Describes the behavior of an actor, i.e., provides a message handler and an optional timeout. More...
|
|
class | 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...
|
|
struct | blocking_actor_base |
| Marker type for blocking actors. More...
|
|
class | buffered_downstream_manager |
| Mixin for streams with any number of downstreams. More...
|
|
class | byte_address |
| Base type for addresses based on a byte representation such as IP or Ethernet addresses. More...
|
|
class | callback |
| Describes a simple callback, usually implemented via lambda expression. More...
|
|
class | callback_impl |
| Utility class for wrapping a function object of type Base . More...
|
|
class | composable_behavior |
| Base type for composable actor states. More...
|
|
class | composable_behavior_base |
| Generates an interface class that provides operator() . More...
|
|
class | composable_behavior_based_actor |
| Implementation class for spawning composable states directly as actors. More...
|
|
struct | composed_type |
| Computes the type for f*g (actor composition). More...
|
|
class | config_option |
| Defines a configuration option for the application. More...
|
|
class | config_option_adder |
| Adds config options of the same category to a config_option_set . More...
|
|
class | config_option_set |
| A set of config_option objects that parses CLI arguments into a settings object. More...
|
|
class | config_value |
| A type for config parameters with similar interface to a variant . 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 | containerbuf |
| A streambuffer abstraction over a contiguous container. More...
|
|
class | cow_tuple |
| A copy-on-write tuple implementation. More...
|
|
class | data_processor |
| A data processor translates an object into a format that can be stored or vice versa. More...
|
|
struct | deep_to_string_t |
| Wrapper to deep_to_string for using the function as an inspector. 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 | 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 | dictionary |
| Maps strings to values of type V , but unlike std::map<std::string, V> accepts string_view for looking up keys efficiently. More...
|
|
struct | down_msg |
| Sent to all actors monitoring an actor when it is terminated. More...
|
|
class | downstream |
| Grants access to an output stream buffer. More...
|
|
class | downstream_manager |
| Manages downstream communication for a stream_manager . More...
|
|
class | downstream_manager_base |
| The default downstream manager base stores outbound paths in an unordered map. More...
|
|
struct | downstream_msg |
| Stream messages that travel downstream, i.e., batches and close messages. More...
|
|
class | duration |
| Time duration consisting of a time_unit and a 64 bit unsigned integer. More...
|
|
struct | dynamically_typed_actor_base |
| Marker type for dynamically typed actors. More...
|
|
class | empty_type_erased_tuple |
| Dummy objects representing empty tuples. 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 | exit_msg |
| Sent to all links when an actor is terminated. More...
|
|
class | expected |
| Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error . More...
|
|
class | expected< void > |
| The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool . More...
|
|
struct | extend |
| Allows convenient definition of types using mixins. More...
|
|
class | forwarding_actor_proxy |
| Implements a simple proxy forwarding all operations to a manager. More...
|
|
class | function_view |
| A function view for an actor hides any messaging from the caller. More...
|
|
class | fused_downstream_manager |
| A downstream manager that delegates to any number of sub-managers. More...
|
|
struct | group_down_msg |
| Sent to all members of a group when it goes offline. More...
|
|
class | group_module |
| Interface for user-defined multicast implementations. More...
|
|
class | handle |
| Base class for IO handles such as accept_handle or connection_handle . More...
|
|
struct | has_make_error |
| Evaluates to true if T is an enum with a free function make_error for converting it to an error . More...
|
|
struct | has_sum_type_access |
| Evaluates to true if T specializes sum_type_access . More...
|
|
struct | has_type_id |
| Evaluates to true if any of these statements holds true: More...
|
|
struct | illegal_message_element |
| Marker class identifying classes in CAF that are not allowed to be used as message element. More...
|
|
class | inbound_path |
| State for a path to an upstream actor (source). More...
|
|
class | inbound_stream_slot |
| Wraps a stream slot ID for inbound paths with the full type information of the path creation. More...
|
|
struct | index_mapping |
| Marker for representing placeholders at runtime. More...
|
|
struct | infer_handle_from_class |
| Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced. More...
|
|
struct | infer_handle_from_fun |
| Deduces an actor handle type from a function or function object. More...
|
|
struct | infinite_t |
| Represents an infinite amount of timeout for specifying "invalid" timeouts. More...
|
|
class | intrusive_cow_ptr |
| An intrusive, reference counting smart pointer implementation with copy-on-write optimization. More...
|
|
class | intrusive_ptr |
| An intrusive, reference counting smart pointer implementation. More...
|
|
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...
|
|
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...
|
|
class | memory_managed |
| This base enables derived classes to enforce a different allocation strategy than new/delete by providing a virtual protected request_deletion() function and non-public destructor. More...
|
|
class | message |
| Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type. More...
|
|
class | message_builder |
| Provides a convenient interface for createing message objects from a series of values using the member function append . More...
|
|
class | message_handler |
| A partial function implementation used to process a message . More...
|
|
class | message_id |
| Bundles various flags along with an optional request ID. More...
|
|
class | message_view |
| Represents an object pointing to a type_erased_tuple that is convertible to a message More...
|
|
class | monitorable_actor |
| Base class for all actor implementations. More...
|
|
struct | named_actor_config |
| Stores a flow-control configuration. More...
|
|
struct | no_error_t |
| Helper class to construct an expected<T> that represents no error. More...
|
|
struct | no_stages_t |
| Convenience tag type for producing empty forwarding stacks. More...
|
|
class | node_id |
| A node ID is an opaque value for representing CAF instances in the network. More...
|
|
struct | non_blocking_actor_base |
| Marker type for non-blocking actors. More...
|
|
struct | none_t |
| Represents "nothing", e.g., for clearing an optional by assigning none . More...
|
|
struct | open_stream_msg |
| Demands the receiver to open a new stream from the sender to the receiver. More...
|
|
class | optional |
| A C++17 compatible optional implementation. More...
|
|
class | optional< T & > |
| Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead. More...
|
|
class | outbound_path |
| State for a single path to a sink of a downstream_manager . More...
|
|
class | outbound_stream_slot |
| Wraps a stream slot ID for outbound paths with the full type information of the path creation. More...
|
|
class | param |
| Represents a message handler parameter of type T and guarantees copy-on-write semantics. More...
|
|
struct | param_decay |
| Convenience struct for remove_param<std::decay<T>> . More...
|
|
struct | parser_state |
| Stores all informations necessary for implementing an FSM-based parser. More...
|
|
class | proxy_registry |
| Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages. More...
|
|
struct | ratio_to_time_unit_helper |
| Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes. More...
|
|
class | raw_event_based_actor |
| A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages. More...
|
|
class | ref_counted |
| Base class for reference counted objects with an atomic reference count. More...
|
|
struct | remove_param |
| Unpacks param<T> to T . More...
|
|
class | response_handle |
| This helper class identifies an expected response message and enables request(...).then(...) . More...
|
|
class | response_promise |
| A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More...
|
|
struct | response_type |
| Defines: More...
|
|
struct | response_type_unbox |
| Unboxes Xs and calls response_type . More...
|
|
class | resumable |
| A cooperatively executed task managed by one or more instances of execution_unit . More...
|
|
class | runtime_settings_map |
| Thread-safe container for mapping atoms to arbitrary settings. More...
|
|
class | scheduled_actor |
| A cooperatively scheduled, event-based actor implementation. More...
|
|
class | scoped_actor |
| A scoped handle to a blocking actor. More...
|
|
class | scoped_execution_unit |
| Identifies an execution unit, e.g., a worker thread of the scheduler. More...
|
|
struct | select_callback |
| Utility class for selecting a callback_impl . More...
|
|
struct | select_config_value_access |
| Delegates to config_value_access for all specialized versions. More...
|
|
struct | select_config_value_access< T, 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...
|
|
class | serializer |
| Technology-independent serialization interface. More...
|
|
class | serializer_impl |
| Implements the serializer interface with a binary serialization protocol. More...
|
|
class | skip_t |
| Default handler function that leaves messages in the mailbox. More...
|
|
class | span |
| A C++11/14 drop-in replacement for C++20's std::span without support for static extents. More...
|
|
class | spawn_options |
| Stores options passed to the spawn function family. More...
|
|
class | stateful_actor |
| An event-based actor with managed state. More...
|
|
struct | statically_typed_actor_base |
| Marker type for statically typed actors. More...
|
|
class | stream |
| Empty marker type for streaming handshakes. More...
|
|
class | stream_buffer |
| The base class for all stream buffer implementations. More...
|
|
class | stream_deserializer |
| Implements the deserializer interface with a binary serialization protocol. More...
|
|
struct | stream_finalize_trait |
| Dispatches a finalize call to a function taking either one or two arguments. More...
|
|
struct | stream_finalize_trait< Fun, State, false > |
| Specializes the trait for callbacks that only take the state. More...
|
|
struct | stream_finalize_trait< Fun, State, true > |
| Specializes the trait for callbacks that take state and error. More...
|
|
class | stream_manager |
| Manages a single stream with any number of in- and outbound paths. More...
|
|
class | stream_serializer |
| Implements the serializer interface with a binary serialization protocol. More...
|
|
class | stream_sink_driver |
| Identifies an unbound sequence of messages. More...
|
|
struct | stream_sink_trait |
| Defines required type aliases for stream sinks. More...
|
|
struct | stream_sink_trait< void(State &, const std::vector< In > &)> |
| Specializes the trait for batch-wise processing with const references. More...
|
|
struct | stream_sink_trait< void(State &, In)> |
| Specializes the trait for element-wise processing. More...
|
|
struct | stream_sink_trait< void(State &, std::vector< In > &)> |
| Specializes the trait for batch-wise processing. More...
|
|
struct | stream_sink_trait_base |
| Base type for all sink traits. More...
|
|
struct | stream_slots |
| Maps two stream_slot values into a pair for storing sender and receiver slot information. More...
|
|
class | stream_source_driver |
| Identifies an unbound sequence of messages. More...
|
|
struct | stream_source_trait |
| Deduces the output type and the state type for a stream source from its pull implementation. More...
|
|
class | stream_stage_driver |
| Encapsulates user-provided functionality for generating a stream stage. More...
|
|
struct | stream_stage_trait< void(State &, downstream< Out > &, In)> |
| Deduces the input type, output type and the state type for a stream stage from its process implementation. More...
|
|
class | string_view |
| Drop-in replacement for C++17 std::string_view. More...
|
|
struct | sum_type_access |
| Specializing this trait allows users to enable holds_alternative , get , get_if , and visit for any user-defined sum type. More...
|
|
struct | sum_type_access< variant< Ts... > > |
| Enable holds_alternative , get , get_if , and visit for variant . More...
|
|
class | thread_hook |
| Interface to define thread hooks. More...
|
|
struct | timeout_msg |
| Signalizes a timeout event. More...
|
|
struct | type_by_id |
| Maps the globally unique ID V to a type (inverse to ::type_id). More...
|
|
class | type_erased_tuple |
| Represents a tuple of type-erased values. More...
|
|
class | type_erased_value |
| Represents a single type-erased value. More...
|
|
struct | type_erased_value_factory |
| Converts values to type-erased values. More...
|
|
struct | type_id |
| Maps the type T to a globally unique 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 | type_nr |
| Computes the type number for T . More...
|
|
class | typed_actor |
| Identifies a statically typed actor. More...
|
|
struct | typed_actor_view_base |
| Tag type for typed_actor_view. More...
|
|
class | typed_event_based_actor |
| A cooperatively scheduled, event-based actor implementation with static type-checking. More...
|
|
class | typed_response_promise |
| A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More...
|
|
struct | unbox_message_element |
| Unboxes atom constants, i.e., converts atom_constant<V> to V . More...
|
|
struct | unit_t |
| Unit is analogous to void , but can be safely returned, stored, etc. More...
|
|
struct | upstream_msg |
| Stream messages that flow upstream, i.e., acks and drop messages. More...
|
|
class | uri |
| A URI according to RFC 3986. More...
|
|
class | variant |
| A variant represents always a valid value of one of the types Ts... . More...
|
|
class | weak_intrusive_ptr |
| An intrusive, reference counting smart pointer implementation. More...
|
|
|
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) |
|
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) |
|
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) |
|