|
C++ Actor Framework 0.18
|
Root namespace of libcaf. More...
Namespaces | |
| namespace | exit_reason |
| Contains all predefined exit reasons. | |
| namespace | io |
| Contains all IO-related classes and functions. | |
| namespace | mixin |
| Contains mixin classes implementing several actor traits. | |
| namespace | policy |
| Contains policies encapsulating characteristics or algorithms. | |
Classes | |
| class | abstract_actor |
| Base class for all actor implementations. More... | |
| class | abstract_channel |
| Interface for all message receivers. More... | |
| class | abstract_group |
| A multicast group. More... | |
| class | action |
A functional interface similar to std::function<void()> with dispose semantics. More... | |
| class | actor |
| Identifies an untyped actor. More... | |
| class | actor_addr |
| Stores the address of typed as well as untyped actors. More... | |
| class | actor_clock |
| A monotonic clock for scheduling timeouts and delayed messages. More... | |
| class | actor_companion |
| An co-existing actor forwarding all messages through a user-defined callback to another object, thus serving as gateway to allow any object to interact with other actors. More... | |
| class | actor_config |
| Stores spawn-time flags and groups. More... | |
| class | actor_control_block |
| Actors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it. More... | |
| class | actor_ostream |
| Provides support for thread-safe output operations on character streams. More... | |
| class | actor_pool |
| An actor poool is a lightweight abstraction for a set of workers. More... | |
| class | actor_profiler |
| A profiler which provides a set of callbacks for several actor operations in order to collect fine-grained profiling state about the system. More... | |
| class | actor_proxy |
| Represents an actor running on a remote machine, or different hardware, or in a separate process. More... | |
| class | actor_registry |
| A registry is used to associate actors to IDs or names. More... | |
| class | actor_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 | allowed_unsafe_message_type |
| Template specializations can whitelist individual types for unsafe message passing operations. 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 |
| Deserializes C++ objects from sequence of bytes. More... | |
| class | binary_serializer |
| Serializes C++ objects into a sequence of bytes. More... | |
| class | blocking_actor |
| A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing. More... | |
| struct | blocking_actor_base |
| Marker type for blocking actors. More... | |
| class | 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 F. 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... | |
| class | config_value_reader |
| Extracts objects from a config_value. More... | |
| class | config_value_writer |
| Serializes an objects into a config_value. More... | |
| class | cow_tuple |
| A copy-on-write tuple implementation. More... | |
| class | credit_controller |
| Computes credit for an attached source. More... | |
| struct | deep_to_string_t |
Wraps deep_to_string into a function object. More... | |
| struct | default_actor_traits |
Default implementation of actor_traits for non-actors (SFINAE-friendly). More... | |
| struct | default_actor_traits< T, true > |
Default implementation of actor_traits for regular actors. More... | |
| 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... | |
| class | disposable |
| Represents a disposable resource. 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... | |
| struct | downstream_msg_batch |
| Transmits stream data. More... | |
| struct | downstream_msg_close |
| Orderly shuts down a stream after receiving an ACK for the last batch. More... | |
| struct | downstream_msg_forced_close |
| Propagates a fatal error from sources to sinks. More... | |
| struct | dynamically_typed_actor_base |
| Marker type for dynamically typed actors. More... | |
| class | error |
| A serializable type for storing error codes with category and optional, human-readable context information. More... | |
| class | error_code |
| A lightweight wrapper around an error code enum. More... | |
| class | event_based_actor |
| A cooperatively scheduled, event-based actor implementation. More... | |
| class | event_based_mtl |
| Enables event-based actors to generate messages from a user-defined data exchange format such as JSON and to send the generated messages to another (typed) actor. More... | |
| 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 | get_or_auto_deduce |
| Configures get_or to uses the get_or_deduction_guide. More... | |
| struct | get_or_deduction_guide |
| Customization point for configuring automatic mappings from default value types to deduced types. More... | |
| struct | 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_sum_type_access |
Evaluates to true if T specializes sum_type_access. More... | |
| struct | illegal_message_element |
| Marker class identifying classes in CAF that are not allowed to be used as message element. More... | |
| class | inbound_path |
| State for a path to an upstream actor (source). More... | |
| class | inbound_stream_slot |
| Wraps a stream slot ID for inbound paths with the full type information of the path creation. More... | |
| struct | 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 | inspector_access |
| Customization point for adding support for a custom type. More... | |
| struct | inspector_access_base |
Provides default implementations for save_field and load_field. More... | |
| struct | inspector_access_type |
| Wraps tag types for static dispatching. More... | |
| class | intrusive_cow_ptr |
| An intrusive, reference counting smart pointer implementation with copy-on-write optimization. More... | |
| class | intrusive_ptr |
| An intrusive, reference counting smart pointer implementation. More... | |
| 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 | json_reader |
| Deserializes an inspectable object from a JSON-formatted string. More... | |
| class | json_writer |
| Serializes an inspectable object to a JSON-formatted string. More... | |
| class | load_inspector |
| Base type for inspectors that load objects from some input source. More... | |
| class | local_actor |
| Base class for actors running on this node, either living in an own thread or cooperatively scheduled. More... | |
| class | logger |
| Centrally logs events from all actors in an actor system. More... | |
| class | 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 | message |
| Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type. More... | |
| class | message_builder |
Provides a convenient interface for creating message objects from a series of values using the member function append. More... | |
| class | message_handler |
A partial function implementation used to process a message. More... | |
| class | message_id |
| Bundles various flags along with an optional request ID. More... | |
| class | monitorable_actor |
| Base class for all actor implementations. More... | |
| struct | no_stages_t |
| Convenience tag type for producing empty forwarding stacks. More... | |
| struct | node_down_msg |
| Sent to all actors monitoring a node when CAF loses connection to it. More... | |
| class | node_id |
| A node ID is an opaque value for representing CAF instances in the network. More... | |
| 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... | |
| struct | optional_inspector_access |
| Provides inspector access for types that represent optional values. 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... | |
| struct | parser_state |
| Stores all information necessary for implementing an FSM-based parser. More... | |
| struct | partial_behavior_init_t |
Tag type for constructing a typed_behavior with an incomplete list of message handlers, delegating to the default handler for all unmatched inputs. More... | |
| class | proxy_registry |
| Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages. More... | |
| class | ref_counted |
| Base class for reference counted objects with an atomic reference count. More... | |
| class | response_handle |
This helper class identifies an expected response message and enables request(...).then(...). More... | |
| class | response_promise |
| Enables actors to delay a response message by capturing the context of a request message. More... | |
| struct | response_type |
| Defines: More... | |
| struct | response_type_unbox |
Unboxes Xs and calls response_type. More... | |
| class | result |
Wraps the result of a message handler to represent either a value (wrapped into a message), a delegated<Ts...> (indicates that another actor is going to respond), or an error. More... | |
| class | result_base |
Base type for all specializations of result. More... | |
| class | resumable |
A cooperatively executed task managed by one or more instances of execution_unit. More... | |
| class | save_inspector |
| Base type for inspectors that save objects to some output sink. More... | |
| class | 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 | span |
A C++11/14 drop-in replacement for C++20's std::span without support for static extents. More... | |
| class | stateful_actor |
| An event-based actor with managed state. More... | |
| struct | statically_typed_actor_base |
| Marker type for statically typed actors. More... | |
| class | stream |
| Empty marker type for streaming handshakes. 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_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... | |
| class | tracing_data |
| Marker interface for application-specific tracing data. More... | |
| class | tracing_data_factory |
| Creates instances of tracing_data. More... | |
| struct | type_by_id |
Maps the globally unique ID V to a type (inverse to ::type_id). More... | |
| class | type_erased_value |
| Represents a single type-erased value. More... | |
| struct | type_id |
Maps the type T to a globally unique ID. More... | |
| class | type_id_list |
| A list of type IDs, stored in a size-prefix, contiguous memory block. More... | |
| struct | type_name |
Convenience type that resolves to type_name_by_id<type_id_v<T>>. More... | |
| struct | type_name< void > |
Convenience specialization that enables generic code to not treat void manually. More... | |
| struct | type_name_by_id |
Maps the globally unique ID V to a type name. More... | |
| class | typed_actor |
| Identifies a statically typed actor. More... | |
| class | typed_actor_view |
| Decorates a pointer to a scheduled_actor with a statically typed actor interface. More... | |
| struct | typed_actor_view_base |
| Tag type for typed_actor_view. More... | |
| class | typed_event_based_actor |
| A cooperatively scheduled, event-based actor implementation with static type-checking. More... | |
| class | typed_response_promise |
| Enables statically typed actors to delay a response message by capturing the context of a request message. More... | |
| struct | unit_t |
Unit is analogous to void, but can be safely returned, stored, etc. More... | |
| struct | unsafe_behavior_init_t |
| Empty struct tag for constructing a typed behavior from an untyped behavior. More... | |
| struct | upstream_msg |
| Stream messages that flow upstream, i.e., acks and drop messages. More... | |
| struct | upstream_msg_ack_batch |
| Cumulatively acknowledges received batches and signalizes new demand from a sink to its source. More... | |
| struct | upstream_msg_ack_open |
Acknowledges a previous open message and finalizes a stream handshake. More... | |
| struct | upstream_msg_drop |
| Asks the source to discard any remaining credit and close this path after receiving an ACK for the last batch. More... | |
| struct | upstream_msg_forced_drop |
| Propagates a fatal error from sinks to sources. More... | |
| class | uri |
| A URI according to RFC 3986. More... | |
| class | uuid |
| A universally unique identifier according to RFC 4122. More... | |
| class | variant |
A variant represents always a valid value of one of the types Ts.... More... | |
| class | weak_intrusive_ptr |
| An intrusive, reference counting smart pointer implementation. More... | |
Typedefs | |
| using | actor_factory_result = std::pair< strong_actor_ptr, std::set< std::string > > |
| using | actor_factory = std::function< actor_factory_result(actor_config &, message &)> |
| using | selfptr_mode_token = spawn_mode_token< spawn_mode::function_with_selfptr > |
| using | void_mode_token = spawn_mode_token< spawn_mode::function > |
| using | byte_buffer = std::vector< byte > |
| A buffer for storing binary data. | |
| using | byte_span = span< byte > |
| Convenience alias for referring to a writable sequence of bytes. | |
| using | const_byte_span = span< const byte > |
| Convenience alias for referring to a read-only sequence of bytes. | |
| template<class Signature > | |
| using | unique_callback_ptr = std::unique_ptr< callback< Signature > > |
| Smart pointer type for heap-allocated callbacks with unique ownership. | |
| template<class Signature > | |
| using | shared_callback_ptr = std::shared_ptr< callback< Signature > > |
| Smart pointer type for heap-allocated callbacks with shared ownership. | |
| template<class T > | |
| using | signatures_of_t = typename signatures_of< T >::type |
| template<class T > | |
| using | deduce_mpi_t = typename detail::dmfou< std::decay_t< T > >::type |
| Deduces the message passing interface from a function object. | |
| template<class F > | |
| using | default_downstream_manager_t = typename default_downstream_manager< F >::type |
| template<class T > | |
| using | function_view_flattened_result_t = typename function_view_flattened_result< T >::type |
| 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 | skippable_result = variant< delegated< message >, message, error, skip_t > |
Similar to result<message>, but also allows to skip a message. | |
| using | stream_slot = uint16_t |
| Identifies a single stream path in the same way a TCP port identifies a connection over IP. | |
| using | type_id_t = uint16_t |
| Internal representation of a type ID. | |
| using | weak_actor_ptr = weak_intrusive_ptr< actor_control_block > |
| using | group_module_ptr = intrusive_ptr< group_module > |
| using | stream_manager_ptr = intrusive_ptr< stream_manager > |
| using | strong_actor_ptr = intrusive_ptr< actor_control_block > |
| using | mailbox_element_ptr = std::unique_ptr< mailbox_element > |
| using | tracing_data_ptr = std::unique_ptr< tracing_data > |
| template<spawn_mode X> | |
| using | spawn_mode_token = std::integral_constant< spawn_mode, X > |
| template<class Found , class Expected > | |
| using | interface_mismatch_t = detail::imi< 0, Found, Expected, detail::type_list<> > |
| Scans two typed MPI lists for compatibility, returning the index of the first mismatch. | |
| template<class Lockable > | |
| using | unique_lock = std::unique_lock< Lockable > |
| template<class SharedLockable > | |
| using | upgrade_lock = shared_lock< SharedLockable > |
| template<class In , class DownstreamManager , class... Ts> | |
| using | make_stage_result_t = make_stage_result< In, DownstreamManager, detail::strip_and_convert_t< Ts >... > |
Helper type for defining a make_stage_result from a downstream manager plus additional handshake types. | |
| using | high_message_priority_constant = std::integral_constant< message_priority, message_priority::high > |
| using | normal_message_priority_constant = std::integral_constant< message_priority, message_priority::normal > |
| using | string_parser_state = parser_state< string_view::iterator > |
| Specialization for parsers operating on string views. | |
| template<class... Is> | |
| using | reacts_to = result< void >(Is...) |
| template<class Fs , class... In> | |
| using | response_type_t = typename response_type< Fs, In... >::type |
Computes the response message type for input In... from the list of message passing interfaces Fs. | |
| template<class Fs , class... In> | |
| using | delegated_response_type_t = typename response_type< Fs, In... >::delegated_type |
Computes the response message type for input In... from the list of message passing interfaces Fs and returns the corresponding delegated<T>. | |
| template<class Ts , class Xs > | |
| using | response_type_unbox_t = typename response_type_unbox< Ts, Xs >::type |
Computes the response message for input Xs from the list of message passing interfaces Ts. | |
| template<class In > | |
| using | stream_sink_ptr = intrusive_ptr< stream_sink< In > > |
| template<class Fun > | |
| using | stream_sink_trait_t = stream_sink_trait< typename detail::get_callable_trait< Fun >::fun_sig > |
| Derives a sink trait from the signatures of Fun and Fin. | |
| template<class DownstreamManager > | |
| using | stream_source_ptr = intrusive_ptr< stream_source< DownstreamManager > > |
| template<class Pull > | |
| using | stream_source_trait_t = stream_source_trait< typename detail::get_callable_trait< Pull >::fun_sig > |
Convenience alias for extracting the function signature from Pull and passing it to stream_source_trait. | |
| template<class In , class DownstreamManager > | |
| using | stream_stage_ptr = intrusive_ptr< stream_stage< In, DownstreamManager > > |
| template<class Process > | |
| using | stream_stage_trait_t = stream_stage_trait< typename detail::get_callable_trait< Process >::fun_sig > |
Convenience alias for extracting the function signature from Process and passing it to stream_stage_trait. | |
| template<class F , class... Ts> | |
| using | sum_type_visit_result_t = typename sum_type_visit_result< detail::decay_t< F >, detail::decay_t< Ts >... >::type |
| using | generic_timeout_definition = timeout_definition< std::function< void()> > |
| using | timespan = std::chrono::duration< int64_t, std::nano > |
| A portable timespan type with nanosecond resolution. | |
| using | timestamp = std::chrono::time_point< std::chrono::system_clock, timespan > |
| A portable timestamp with nanosecond resolution anchored at the UNIX epoch. | |
| template<class... Ts> | |
| using | is_variant_t = typename is_variant< Ts... >::type |
| template<class F , class... Ts> | |
| using | variant_visit_result_t = typename variant_visit_result< detail::decay_t< F >, detail::decay_t< Ts >... >::type |
Functions | |
| template<class F > | |
| action | make_action (F f, action::state init_state=action::state::scheduled) |
| Convenience function for creating action objects from a function object. | |
| CAF_CORE_EXPORT actor | operator* (actor f, actor g) |
Combine f and g so that (f*g)(x) = f(g(x)). | |
| bool | operator== (const actor_addr &x, std::nullptr_t) |
| bool | operator== (std::nullptr_t, const actor_addr &x) |
| bool | operator!= (const actor_addr &x, std::nullptr_t) |
| bool | operator!= (std::nullptr_t, const actor_addr &x) |
| template<class T , class U > | |
| T | actor_cast (U &&what) |
Converts actor handle what to a different actor handle or raw pointer of type T. | |
| CAF_CORE_EXPORT bool | operator== (const strong_actor_ptr &, const abstract_actor *) |
| CAF_CORE_EXPORT bool | operator== (const abstract_actor *, const strong_actor_ptr &) |
| bool | operator!= (const strong_actor_ptr &x, const abstract_actor *y) |
| bool | operator!= (const abstract_actor *x, const strong_actor_ptr &y) |
| CAF_CORE_EXPORT error_code< sec > | load_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid) |
| CAF_CORE_EXPORT error_code< sec > | save_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid) |
| template<class Inspector > | |
| auto | context_of (Inspector *f) -> decltype(f->context()) |
| execution_unit * | context_of (void *) |
| CAF_CORE_EXPORT std::string | to_string (const strong_actor_ptr &x) |
| CAF_CORE_EXPORT void | append_to_string (std::string &x, const strong_actor_ptr &y) |
| CAF_CORE_EXPORT std::string | to_string (const weak_actor_ptr &x) |
| CAF_CORE_EXPORT void | append_to_string (std::string &x, const weak_actor_ptr &y) |
| template<class Inspector > | |
| bool | inspect (Inspector &f, strong_actor_ptr &x) |
| template<class Inspector > | |
| bool | inspect (Inspector &f, weak_actor_ptr &x) |
| template<class F > | |
| actor_factory | make_actor_factory (F fun) |
| template<class T , class... Ts> | |
| actor_factory_result | dyn_spawn_class (actor_config &cfg, message &msg) |
| template<class T , class... Ts> | |
| actor_factory | make_actor_factory () |
| CAF_CORE_EXPORT actor_ostream | aout (local_actor *self) |
| Convenience factory function for creating an actor output stream. | |
| CAF_CORE_EXPORT actor_ostream | aout (scoped_actor &self) |
| template<class... Sigs> | |
| actor_ostream | aout (const typed_actor_pointer< Sigs... > &ptr) |
| Convenience factory function for creating an actor output stream. | |
| CAF_CORE_EXPORT const settings & | content (const actor_system_config &cfg) |
| Returns all user-provided configuration parameters. | |
| template<class Rep , class Period > | |
| constexpr auto | after (std::chrono::duration< Rep, Period > d) |
| Returns a generator for timeouts. | |
| template<class 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 fin={}, 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 = std::enable_if_t<std::is_integral<IntegerType>::value>> | |
| constexpr IntegerType | to_integer (byte x) noexcept |
| template<class IntegerType , class E = std::enable_if_t<std::is_integral<IntegerType>::value>> | |
| constexpr byte & | operator<<= (byte &x, IntegerType shift) noexcept |
| template<class IntegerType , class E = std::enable_if_t<std::is_integral<IntegerType>::value>> | |
| constexpr byte | operator<< (byte x, IntegerType shift) noexcept |
| template<class IntegerType , class E = std::enable_if_t<std::is_integral<IntegerType>::value>> | |
| constexpr byte & | operator>>= (byte &x, IntegerType shift) noexcept |
| template<class IntegerType , class E = std::enable_if_t<std::is_integral<IntegerType>::value>> | |
| 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. | |
| template<class T > | |
| expected< T > | get_as (const config_value &, inspector_access_type::none) |
| template<class T > | |
| expected< T > | get_as (const config_value &, inspector_access_type::unsafe) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::specialization token) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::inspect token) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::builtin_inspect token) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::builtin) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::empty) |
| template<class T , size_t... Is> | |
| expected< T > | get_as_tuple (const config_value::list &x, std::index_sequence< Is... >) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::tuple) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::map) |
| template<class T > | |
| expected< T > | get_as (const config_value &x, inspector_access_type::list) |
| template<class T , class = std::enable_if_t<detail::is_config_value_type_v<T>>> | |
| auto | get_if (const config_value *x) |
| template<class T , class = std::enable_if_t<detail::is_config_value_type_v<T>>> | |
| auto | get_if (config_value *x) |
| template<class T , class = std::enable_if_t<detail::is_config_value_type_v<T>>> | |
| decltype(auto) | get (const config_value &x) |
| template<class T , class = std::enable_if_t<detail::is_config_value_type_v<T>>> | |
| decltype(auto) | get (config_value &x) |
| template<class T , class = std::enable_if_t<detail::is_config_value_type_v<T>>> | |
| auto | holds_alternative (const config_value &x) |
| template<class... Ts> | |
| config_value | make_config_value_list (Ts &&... xs) |
| template<size_t Index, class... Ts> | |
| const auto & | get (const_typed_message_view< Ts... > xs) |
| template<class... Ts, size_t... Is> | |
| auto | to_tuple (const_typed_message_view< Ts... > xs, std::index_sequence< Is... >) |
| template<class... Ts> | |
| auto | to_tuple (const_typed_message_view< Ts... > xs) |
| template<class... Ts> | |
| auto | make_const_typed_message_view (const message &msg) |
| template<class... Ts> | |
| optional< std::tuple< Ts... > > | to_tuple (const message &msg) |
| template<class T > | |
| std::string | deep_to_string (const T &x) |
Unrolls collections such as vectors/maps, decomposes tuples/pairs/arrays, auto-escapes strings and calls to_string for user-defined types via argument-dependent loopkup (ADL). | |
| template<class... Ts> | |
| std::string | deep_to_string_as_tuple (const Ts &... xs) |
Convenience function for deep_to_string(std::forward_as_tuple(xs...)). | |
| template<class Inspector , class Enumeration > | |
| bool | default_enum_inspect (Inspector &f, Enumeration &x) |
| Convenience function for providing a default inspection scaffold for custom enumeration types. | |
| template<class... Ts> | |
| bool | operator== (const delegated< Ts... > &, const delegated< Ts... > &) |
| template<class T > | |
| bool | operator== (const dictionary< T > &xs, const dictionary< T > &ys) |
| template<class T > | |
| bool | operator!= (const dictionary< T > &xs, const dictionary< T > &ys) |
| template<class T > | |
| bool | operator< (const dictionary< T > &xs, const dictionary< T > &ys) |
| template<class T > | |
| bool | operator<= (const dictionary< T > &xs, const dictionary< T > &ys) |
| template<class T > | |
| bool | operator> (const dictionary< T > &xs, const dictionary< T > &ys) |
| template<class T > | |
| bool | operator>= (const dictionary< T > &xs, const dictionary< T > &ys) |
| template<class 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. | |
| template<class Enum > | |
| auto | to_string (error_code< Enum > x) -> decltype(to_string(x.value())) |
Converts x to a string if Enum provides a to_string function. | |
| template<class T > | |
| void | exec_main_init_meta_objects_single () |
| template<class... Ts> | |
| void | exec_main_init_meta_objects () |
| template<class T > | |
| void | exec_main_load_module (actor_system_config &cfg) |
| template<class... Ts, class F = void (*)(actor_system&)> | |
| int | exec_main (F fun, int argc, char **argv) |
| template<class Inspector > | |
| bool | inspect (Inspector &f, exit_reason &x) |
| template<class 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. | |
| template<class ProjectIds , uint16_t... Is> | |
| void | init_global_meta_objects_impl (std::integer_sequence< uint16_t, Is... >) |
| template<class ProjectIds > | |
| void | init_global_meta_objects () |
Initializes the global meta object table with all types in ProjectIds. | |
| template<class T > | |
| std::string | to_string (const intrusive_ptr< T > &x) |
| CAF_CORE_EXPORT std::string | to_string (invoke_message_result) |
| CAF_CORE_EXPORT std::string | to_string (const ipv4_endpoint &ep) |
| CAF_CORE_EXPORT error | parse (string_view str, ipv6_address &dest) |
| CAF_CORE_EXPORT std::string | to_string (const ipv6_endpoint &ep) |
| CAF_CORE_EXPORT std::string | to_string (logger::field_type x) |
| template<class T , class R = infer_handle_from_class_t<T>, class... Ts> | |
| R | make_actor (actor_id aid, node_id nid, actor_system *sys, Ts &&... xs) |
| CAF_CORE_EXPORT config_option | make_negated_config_option (bool &storage, string_view category, string_view name, string_view description) |
| template<class Inspector > | |
| bool | inspect (Inspector &f, message_id &x) |
| CAF_CORE_EXPORT std::string | to_string (message_priority) |
| template<class Self , class Adapter , class Reader > | |
| auto | make_mtl (Self *self, Adapter adapter, Reader *reader) |
| Creates an MTL (message translation layer) to enable an actor to exchange messages with non-CAF endpoints over a user-defined data exchange format such as JSON. | |
| template<class Iterator , class Sentinel , class... Ts> | |
| auto | make_error (const parser_state< Iterator, Sentinel > &ps, Ts &&... xs) -> decltype(make_error(ps.code, ps.line, ps.column)) |
Returns an error object from the current code in ps as well as its current position. | |
| template<class... Ts> | |
| auto | 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 > | |
| 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). | |
| CAF_CORE_EXPORT config_value::list & | put_list (settings &xs, std::string name) |
Inserts a new list named name into the dictionary xs and returns a reference to it. | |
| CAF_CORE_EXPORT config_value::dictionary & | put_dictionary (settings &xs, std::string name) |
Inserts a new list named name into the dictionary xs and returns a reference to it. | |
| 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. | |
| constexpr spawn_options | operator+ (spawn_options x, spawn_options y) |
Concatenates two spawn_options. | |
| constexpr bool | has_spawn_option (spawn_options haystack, spawn_options needle) |
Checks whether haystack contains needle. | |
| constexpr bool | has_detach_flag (spawn_options opts) |
Checks whether the detached flag is set in opts. | |
| constexpr bool | has_priority_aware_flag (spawn_options) |
Checks whether the priority_aware flag is set in opts. | |
| constexpr bool | has_hide_flag (spawn_options opts) |
Checks whether the hidden flag is set in opts. | |
| constexpr bool | has_link_flag (spawn_options opts) |
Checks whether the linked flag is set in opts. | |
| constexpr bool | has_monitor_flag (spawn_options opts) |
Checks whether the monitored flag is set in opts. | |
| constexpr bool | has_lazy_init_flag (spawn_options opts) |
Checks whether the lazy_init flag is set in opts. | |
| CAF_CORE_EXPORT attachable_ptr | make_stream_aborter (actor_addr observed, actor_addr observer, stream_slot slot, stream_aborter::mode m) |
| constexpr string_view | is_any_of (string_view arg) noexcept |
| CAF_CORE_EXPORT void | split (std::vector< std::string > &result, string_view str, string_view delims, bool keep_all=true) |
| CAF_CORE_EXPORT void | split (std::vector< string_view > &result, string_view str, string_view delims, bool keep_all=true) |
| CAF_CORE_EXPORT void | split (std::vector< std::string > &result, string_view str, char delim, bool keep_all=true) |
| CAF_CORE_EXPORT 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) |
| CAF_CORE_EXPORT void | replace_all (std::string &str, string_view what, string_view with) |
Replaces all occurrences of what by with in str. | |
| CAF_CORE_EXPORT bool | starts_with (string_view str, string_view prefix) |
Returns whether str begins with prefix. | |
| CAF_CORE_EXPORT 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 , class U , class Trait = sum_type_access<U>> | |
| auto | get (U &x) -> decltype(Trait::get(x, make_sum_type_token< Trait, T >())) |
| Returns a reference to the value of a sum type. | |
| template<class T , class U , class Trait = sum_type_access<U>> | |
| auto | get (const U &x) -> decltype(Trait::get(x, make_sum_type_token< Trait, T >())) |
| Returns a reference to the value of a sum type. | |
| template<class T , class U , class Trait = sum_type_access<U>> | |
| auto | get_if (U *x) -> decltype(Trait::get_if(x, make_sum_type_token< Trait, T >())) |
Returns a pointer to the value of a sum type if it is of type T, nullptr otherwise. | |
| template<class T , class U , class Trait = sum_type_access<U>> | |
| auto | get_if (const U *x) -> decltype(Trait::get_if(x, make_sum_type_token< Trait, T >())) |
Returns a pointer to the value of a sum type if it is of type T, nullptr otherwise. | |
| template<class T , class U > | |
| bool | holds_alternative (const U &x) |
Returns whether a sum type has a value of type T. | |
| template<class Visitor , class T , class... Ts, class Result = sum_type_visit_result_t<Visitor, T, Ts...>> | |
| detail::enable_if_t< SumTypes< T, Ts... >(), Result > | visit (Visitor &&f, T &&x, Ts &&... xs) |
| Applies the values of any number of sum types to the visitor. | |
| template<class T , int Pos> | |
| constexpr std::integral_constant< int, Pos > | pos (sum_type_token< T, Pos >) |
| CAF_CORE_EXPORT std::ostream & | operator<< (std::ostream &out, term x) |
| constexpr bool | is_infinite (timespan value) |
Checks whether value represents an infinite amount of time. | |
| CAF_CORE_EXPORT timestamp | make_timestamp () |
Convenience function for returning a timestamp representing the current system time. | |
| CAF_CORE_EXPORT std::string | timestamp_to_string (timestamp x) |
Prints x in ISO 8601 format, e.g., 2018-11-15T06:25:01.462. | |
| CAF_CORE_EXPORT 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 > | |
| string_view | type_name_or_anonymous () |
Returns type_name_v<T> if available, "anonymous" otherwise. | |
| template<class T > | |
| type_id_t | type_id_or_invalid () |
Returns type_id_v<T> if available, invalid_type_id otherwise. | |
| CAF_CORE_EXPORT string_view | query_type_name (type_id_t type) |
Returns the type name of given type or an empty string if type is an invalid ID. | |
| CAF_CORE_EXPORT type_id_t | query_type_id (string_view name) |
Returns the type of given name or invalid_type_id if no type matches. | |
| template<class... Ts> | |
| type_id_list | types_of (const std::tuple< Ts... > &) |
| template<class... Fs> | |
| typed_behavior< deduce_mpi_t< Fs >... > | make_typed_behavior (Fs... fs) |
| Creates a typed behavior from given function objects. | |
| template<size_t Index, class... Ts> | |
| auto & | get (typed_message_view< Ts... > x) |
| template<class... Ts> | |
| auto | make_typed_message_view (message &msg) |
| template<class 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 > | |
| bool | inspect (Inspector &f, uri::authority_type &x) |
| template<class Inspector > | |
| bool | inspect (Inspector &f, uri::impl_type &x) |
Variables | |
| constexpr actor_id | invalid_actor_id = 0 |
| Denotes an ID that is never used by an actor. | |
| template<class T > | |
| constexpr bool | is_allowed_unsafe_message_type_v = allowed_unsafe_message_type<T>::value |
| constexpr invalid_stream_t | invalid_stream = invalid_stream_t{} |
| constexpr no_stages_t | no_stages = no_stages_t{} |
| Convenience tag for producing empty forwarding stacks. | |
| static constexpr none_t | none = none_t{} |
| constexpr others_t | others = others_t{} |
| constexpr skip_t | skip = skip_t{} |
| Tells the runtime system to skip a message when used as message handler, i.e., causes the runtime to leave the message in the mailbox of an actor. | |
| constexpr spawn_options | no_spawn_options = spawn_options::no_flags |
| Denotes default settings. | |
| constexpr spawn_options | monitored = spawn_options::monitor_flag |
Causes spawn to call `self->monitor(...) immediately after the new actor was spawned. | |
| constexpr spawn_options | linked = spawn_options::link_flag |
Causes spawn to call `self->link_to(...) immediately after the new actor was spawned. | |
| constexpr spawn_options | detached = spawn_options::detach_flag |
| Causes the new actor to opt out of the cooperative scheduling. | |
| constexpr spawn_options | hidden = spawn_options::hide_flag |
Causes the runtime to ignore the new actor in await_all_actors_done(). | |
| constexpr spawn_options | lazy_init = spawn_options::lazy_init_flag |
| Causes the new actor to delay its initialization until a message arrives. | |
| constexpr stream_slot | invalid_stream_slot = 0 |
| Identifies an invalid slot. | |
| constexpr bool | token_compress_on = false |
| static constexpr timespan | infinite = timespan{std::numeric_limits<int64_t>::max()} |
| Constant representing an infinite amount of time. | |
| constexpr type_id_t | invalid_type_id = 65535 |
Special value equal to the greatest possible value for type_id_t. | |
| constexpr type_id_t | first_custom_type_id = 200 |
| The first type ID not reserved by CAF and its modules. | |
| template<class T > | |
| constexpr bool | has_type_id_v = detail::is_complete<type_id<T>> |
Checks whether type_id is specialized for T. | |
| constexpr partial_behavior_init_t | partial_behavior_init = partial_behavior_init_t{} |
| static constexpr unit_t | unit = unit_t{} |
| constexpr unsafe_behavior_init_t | unsafe_behavior_init = unsafe_behavior_init_t{} |
| Convenience constant for constructing a typed behavior from an untyped behavior. | |
| constexpr size_t | variant_npos = static_cast<size_t>(-1) |
Root namespace of libcaf.
| using caf::interface_mismatch_t = typedef detail::imi<0, Found, Expected, detail::type_list<> > |
Scans two typed MPI lists for compatibility, returning the index of the first mismatch.
Returns the number of elements on a match.
| typedef ipv6_subnet caf::ip_subnet |
An IP subnetwork.
The address family is IPv6 unless embeds_v4 returns true.
| using caf::make_stage_result_t = typedef make_stage_result<In, DownstreamManager, detail::strip_and_convert_t<Ts>...> |
Helper type for defining a make_stage_result from a downstream manager plus additional handshake types.
Hardwires message as result type.
|
strong |
This error category represents fail conditions for actors.
|
strong |
Stores the result of a message invocation.
|
strong |
PEC stands for "Parser Error Code".
This enum contains error codes used by various CAF parsers.
|
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. |
| unavailable_or_would_block | A resource is temporarily unavailable or would block. |
| incompatible_versions | Connection refused because of incompatible CAF versions. |
| incompatible_application_ids | Connection refused because of incompatible application IDs. |
| malformed_basp_message | The middleman received a malformed BASP message from another node. |
| serializing_basp_payload_failed | The middleman closed a connection because it failed to serialize or deserialize a payload. |
| redundant_connection | The middleman closed a connection to itself or an already connected node. |
| remote_lookup_failed | Resolving a path on a remote node failed. |
| no_tracing_context | Serialization failed because actor_system::tracing_context is null. |
| all_requests_failed | No request produced a valid result. |
| field_invariant_check_failed | Deserialization failed because an invariant got violated after reading the content of a field. |
| field_value_synchronization_failed | Deserialization failed because a setter rejected the input. |
| invalid_field_type | Deserialization failed because the source announced an invalid type. |
| unsafe_type | Serialization failed because a type was flagged as unsafe message type. |
| save_callback_failed | Serialization failed because a save callback returned |
| load_callback_failed | Deserialization failed because a load callback returned |
| conversion_failed | Converting between two types failed. |
| connection_closed | A network connection was closed by the remote side. |
| type_clash | An operation failed because run-time type information diverged from the expected type. |
| unsupported_operation | An operation failed because the callee does not implement this functionality. |
| no_such_key | A key lookup failed. |
| broken_promise | An destroyed a response promise without calling deliver or delegate on it. |
| connection_timeout | Disconnected from a BASP node after reaching the connection timeout. |
| action_reschedule_failed | Signals that an actor fell behind a periodic action trigger. After raising this error, an actor_clock stops scheduling the action. |
|
strong |
|
strong |
Terminal color and font face options.
| 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.
| 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. |
stream_manager. | 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.
| self | Points to the hosting actor. |
| xs | Parameter pack for constructing the driver. |
stream_manager. | 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 = {} |
||
| ) |
| 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. |
| 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.
| self | Points to the hosting actor. |
| xs | User-defined arguments for the downstream handshake. |
stream_manager. | 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.
| 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. |
stream_manager and the inbound slot. | 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.
| self | Points to the hosting actor. |
| xs | Additional constructor arguments for Driver. |
stream_manager, an inbound slot, and an outbound slot. | 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.
| 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. |
stream_manager and the output slot. | 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.
| 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. |
stream_manager and the output slot. | 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 | fin = {}, |
||
| policy::arg< DownstreamManager > | token = {} |
||
| ) |
Attaches a new stream source to self by creating a default stream source manager with the default driver.
| 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. |
stream_manager and the output slot. | 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.
| self | Points to the hosting actor. |
| xs | User-defined arguments for the stream handshake. |
| ctor_args | Parameter pack for constructing the driver. |
stream_manager and the output slot. | 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.
| 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. |
stream_manager and the output slot. | 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.
| 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. |
stream_manager, an inbound slot, and an outbound slot. | 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.
| 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. |
stream_manager, an inbound slot, and an outbound slot. | 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.
| 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. |
stream_manager, an inbound slot, and an outbound slot. | std::string caf::deep_to_string | ( | const T & | x | ) |
Unrolls collections such as vectors/maps, decomposes tuples/pairs/arrays, auto-escapes strings and calls to_string for user-defined types via argument-dependent loopkup (ADL).
Any user-defined type that does not provide a to_string is mapped to <unprintable>.
| bool caf::default_enum_inspect | ( | Inspector & | f, |
| Enumeration & | x | ||
| ) |
Convenience function for providing a default inspection scaffold for custom enumeration types.
The enumeration type must provide the following interface based on free functions:
| 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.
| void caf::init_global_meta_objects | ( | ) |
Initializes the global meta object table with all types in ProjectIds.
| void caf::init_global_meta_objects_impl | ( | std::integer_sequence< uint16_t, Is... > | ) |
| action caf::make_action | ( | F | f, |
| action::state | init_state = action::state::scheduled |
||
| ) |
Convenience function for creating action objects from a function object.
| f | The body for the action. |
| init_state | either action::state::scheduled or action::state::waiting. |
| auto caf::make_mtl | ( | Self * | self, |
| Adapter | adapter, | ||
| Reader * | reader | ||
| ) |
Creates an MTL (message translation layer) to enable an actor to exchange messages with non-CAF endpoints over a user-defined data exchange format such as JSON.
| self | Points to an event-based or blocking actor. |
| adapter | Translates between internal and external message types. |
| reader | Points to an object that either implements the interface deserializer directly or that provides a compatible API. |
| config_value & caf::put | ( | settings & | dict, |
| string_view | key, | ||
| T && | value | ||
| ) |
Converts value to a config_value and assigns it to key.
| dict | Dictionary of key-value pairs. |
| key | Human-readable nested keys in the form category.key. |
| value | New value for given key. |
| CAF_CORE_EXPORT 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.
| CAF_CORE_EXPORT 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.
| 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).
| xs | Dictionary of key-value pairs. |
| key | Human-readable nested keys in the form category.key. |
| value | New value for given key. |
|
constexpr |
Special value equal to the greatest possible value for type_id_t.
Generally indicates that no type ID for a given type exists.
1.9.6