|
class | abstract_actor |
| Base class for all actor implementations. More...
|
|
class | abstract_channel |
| Interface for all message receivers. More...
|
|
class | abstract_composable_behavior |
| Marker type that allows CAF to spawn actors from composable states. More...
|
|
class | abstract_group |
| A multicast group. More...
|
|
class | actor |
| Identifies an untyped actor. More...
|
|
class | actor_addr |
| Stores the address of typed as well as untyped actors. More...
|
|
class | actor_clock |
| A monotonic clock for scheduling timeouts and delayed messages. More...
|
|
class | actor_companion |
| An co-existing actor forwarding all messages through a user-defined callback to another object, thus serving as gateway to allow any object to interact with other actors. More...
|
|
class | actor_config |
| Stores spawn-time flags and groups. More...
|
|
class | actor_control_block |
| Actors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it. More...
|
|
class | actor_ostream |
| Provides support for thread-safe output operations on character streams. More...
|
|
class | actor_pool |
| An actor poool is a lightweight abstraction for a set of workers. More...
|
|
class | actor_proxy |
| Represents an actor running on a remote machine, or different hardware, or in a separate process. More...
|
|
class | actor_registry |
| A registry is used to associate actors to IDs or atoms (names). More...
|
|
class | actor_system |
| Actor environment including scheduler, registry, and optional components such as a middleman. More...
|
|
class | actor_system_config |
| Configures an actor_system on startup. More...
|
|
struct | allowed_unsafe_message_type |
| Template specializations can whitelist individual types for unsafe message passing operations. More...
|
|
class | annotated_stream |
| Identifies an unbound sequence of messages annotated with the additional handshake arguments emitted to the next stage. More...
|
|
class | arraybuf |
| A streambuffer abstraction over a fixed array of bytes. More...
|
|
struct | atom_constant |
| Lifts an atom_value to a compile-time constant. More...
|
|
class | attachable |
| Callback utility class. More...
|
|
class | behavior |
| Describes the behavior of an actor, i.e., provides a message handler and an optional timeout. More...
|
|
class | blocking_actor |
| A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing. More...
|
|
class | broadcast_topic_scatterer |
| A topic scatterer that delivers data in broadcast fashion to all sinks. More...
|
|
class | buffered_scatterer |
| Mixin for streams with any number of downstreams. 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 |
| Helper class to generate config readers for different input types. More...
|
|
class | containerbuf |
| A streambuffer abstraction over a contiguous container. More...
|
|
class | data_processor |
| A data processor translates an object into a format that can be stored or vice versa. More...
|
|
class | delegated |
| Helper class to indicate that a request has been forwarded. More...
|
|
class | deserializer |
| Technology-independent deserialization interface. 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 | duration |
| Time duration consisting of a time_unit and a 64 bit unsigned integer. More...
|
|
class | empty_type_erased_tuple |
|
class | error |
| A serializable type for storing error codes with category and optional, human-readable context information. More...
|
|
class | event_based_actor |
| A cooperatively scheduled, event-based actor implementation. More...
|
|
class | execution_unit |
| Identifies an execution unit, e.g., a worker thread of the scheduler. More...
|
|
struct | exit_msg |
| Sent to all links when an actor is terminated. More...
|
|
class | expected |
| Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error . More...
|
|
class | expected< void > |
| The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool . More...
|
|
struct | extend |
| Allows convenient definition of types using mixins. More...
|
|
class | forwarding_actor_proxy |
| Implements a simple proxy forwarding all operations to a manager. More...
|
|
class | function_view |
| A function view for an actor hides any messaging from the caller. More...
|
|
class | fused_scatterer |
| A scatterer that delegates to any number of sub-scatterers. 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 | illegal_message_element |
| Marker class identifying classes in CAF that are not allowed to be used as message element. More...
|
|
class | inbound_path |
| State for a path to an upstream actor (source). More...
|
|
struct | index_mapping |
| Marker for representing placeholders at runtime. More...
|
|
struct | infer_handle_from_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_ptr |
| An intrusive, reference counting smart pointer implementation. More...
|
|
class | invalid_stream_gatherer |
| Type-erased policy for receiving data from sources. More...
|
|
class | invalid_stream_scatterer |
| Type-erased policy for dispatching data to sinks. More...
|
|
struct | invalid_stream_t |
| Marker type for constructing invalid stream objects. More...
|
|
struct | is_same_ish |
| Compares T to U und evaluates to true_type if either `T == U or if T and U are both integral types of the same size and signedness. 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...
|
|
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 | 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 |
| Denotes whether a message is asynchronous or synchronous. More...
|
|
class | message_view |
| Represents an object pointing to a type_erased_tuple that is convertible to a message More...
|
|
class | monitorable_actor |
| Base class for all actor implementations. More...
|
|
struct | named_actor_config |
| Stores a flow-control configuration. More...
|
|
struct | no_error_t |
| Helper class to construct an expected<T> that represents no error. More...
|
|
struct | no_stages_t |
| Convenience tag type for producing empty forwarding stacks. More...
|
|
class | node_id |
| A node ID consists of a host ID and process ID. More...
|
|
struct | none_t |
| Represents "nothing", e.g., for clearing an optional by assigning none . More...
|
|
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 on a stream_scatterer . More...
|
|
class | param |
| Represents a message handler parameter of type T and guarantees copy-on-write semantics. More...
|
|
struct | param_decay |
| Convenience struct for remove_param<std::decay<T>> . More...
|
|
class | proxy_registry |
| Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages. More...
|
|
class | random_gatherer |
| Pulls data from sources in arbitrary order. More...
|
|
class | random_topic_scatterer |
| A topic scatterer that delivers data to sinks in random order. 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 | 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...
|
|
class | serializer |
| Technology-independent serialization interface. More...
|
|
class | skip_t |
|
class | spawn_options |
| Stores options passed to the spawn function family. More...
|
|
class | stateful_actor |
| An event-based actor with managed state. More...
|
|
class | stream |
| Identifies an unbound sequence of messages. 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...
|
|
class | stream_edge_impl |
| Provides a common scaffold for implementations of the stream_gatherer and stream_scatterer interfaces. More...
|
|
class | stream_gatherer |
| Type-erased policy for receiving data from sources. More...
|
|
class | stream_gatherer_impl |
| Type-erased policy for receiving data from sources. More...
|
|
class | stream_manager |
| Manages a single stream with any number of down- and upstream actors. More...
|
|
struct | stream_msg |
| Stream communication messages for handshaking, ACKing, data transmission, etc. More...
|
|
class | stream_result |
| Terminates a stream by reducing it to a single value. More...
|
|
class | stream_scatterer |
| Type-erased policy for dispatching data to sinks. More...
|
|
class | stream_scatterer_impl |
| Type-erased policy for dispatching data to sinks. More...
|
|
class | stream_serializer |
| Implements the serializer interface with a binary serialization protocol. More...
|
|
class | terminal_stream_scatterer |
| Special-purpose scatterer for sinks that terminate a stream. More...
|
|
class | thread_hook |
| Interface to define thread hooks. More...
|
|
struct | timeout_msg |
| Signalizes a timeout event. More...
|
|
class | topic_scatterer |
| A topic scatterer allows stream nodes to fork into multiple lanes, where each lane carries only a subset of the data. More...
|
|
class | type_erased_tuple |
| Represents a tuple of type-erased values. More...
|
|
class | type_erased_value |
| Represents a single type-erased value. More...
|
|
struct | type_erased_value_factory |
|
struct | type_nr |
| Computes the type number for T . More...
|
|
class | typed_actor |
| Identifies a statically typed actor. More...
|
|
class | typed_event_based_actor |
| A cooperatively scheduled, event-based actor implementation with static type-checking. More...
|
|
class | typed_response_promise |
| A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More...
|
|
struct | unbox_message_element |
| Unboxes atom constants, i.e., converts atom_constant<V> to V . More...
|
|
struct | unit_t |
| Unit is analogous to void , but can be safely returned, stored, etc. More...
|
|
struct | unsafe_actor_handle_init_t |
| Tag type to select the unsafe constructor of actor handles. More...
|
|
class | variant |
| A variant represents always a valid value of one of the types Ts... . More...
|
|
struct | variant_compare_helper |
|
struct | variant_reader |
|
struct | variant_writer |
|
class | weak_intrusive_ptr |
| An intrusive, reference counting smart pointer implementation. More...
|
|
|
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 | rtti_pair = std::pair< uint16_t, const std::type_info * > |
|
using | rtti_pair_vec = std::vector< rtti_pair > |
|
using | rtti_pair_vec_triple = std::tuple< rtti_pair_vec, rtti_pair_vec, rtti_pair_vec > |
|
using | add_atom = atom_constant< atom("add")> |
| Used for request operations.
|
|
using | get_atom = atom_constant< atom("get")> |
| Used for request operations.
|
|
using | put_atom = atom_constant< atom("put")> |
| Used for request operations.
|
|
using | update_atom = atom_constant< atom("update")> |
| Used for signalizing updates, e.g., in a key-value store.
|
|
using | delete_atom = atom_constant< atom("delete")> |
| Used for request operations.
|
|
using | ok_atom = atom_constant< atom("ok")> |
| Used for response messages.
|
|
using | sys_atom = atom_constant< atom("sys")> |
| Used for triggering system-level message handling.
|
|
using | join_atom = atom_constant< atom("join")> |
| Used for signaling group subscriptions.
|
|
using | leave_atom = atom_constant< atom("leave")> |
| Used for signaling group unsubscriptions.
|
|
using | forward_atom = atom_constant< atom("forward")> |
| Used for signaling forwarding paths.
|
|
using | flush_atom = atom_constant< atom("flush")> |
| Used for buffer management.
|
|
using | redirect_atom = atom_constant< atom("redirect")> |
| Used for I/O redirection.
|
|
using | link_atom = atom_constant< atom("link")> |
| Used for link requests over network.
|
|
using | unlink_atom = atom_constant< atom("unlink")> |
| Used for removing networked links.
|
|
using | publish_atom = atom_constant< atom("publish")> |
| Used for publishing actors at a given port.
|
|
using | publish_udp_atom = atom_constant< atom("pub_udp")> |
| Used for publishing actors at a given port.
|
|
using | unpublish_atom = atom_constant< atom("unpublish")> |
| Used for removing an actor/port mapping.
|
|
using | unpublish_udp_atom = atom_constant< atom("unpub_udp")> |
| Used for removing an actor/port mapping.
|
|
using | subscribe_atom = atom_constant< atom("subscribe")> |
| Used for signalizing group membership.
|
|
using | unsubscribe_atom = atom_constant< atom("unsubscrib")> |
| Used for withdrawing group membership.
|
|
using | connect_atom = atom_constant< atom("connect")> |
| Used for establishing network connections.
|
|
using | contact_atom = atom_constant< atom("contact")> |
| Used for contacting a remote UDP endpoint.
|
|
using | open_atom = atom_constant< atom("open")> |
| Used for opening ports or files.
|
|
using | close_atom = atom_constant< atom("close")> |
| Used for closing ports or files.
|
|
using | spawn_atom = atom_constant< atom("spawn")> |
| Used for spawning remote actors.
|
|
using | migrate_atom = atom_constant< atom("migrate")> |
| Used for migrating actors to other nodes.
|
|
using | tick_atom = atom_constant< atom("tick")> |
| Used for triggering periodic operations.
|
|
using | pending_atom = atom_constant< atom("pending")> |
| Used for pending out of order messages.
|
|
using | binary_deserializer = stream_deserializer< charbuf > |
| A stream serializer that writes into an unbounded contiguous character sequence. More...
|
|
using | binary_serializer = stream_serializer< vectorbuf > |
| A stream serializer that writes into an unbounded contiguous character sequence. More...
|
|
template<class T > |
using | signatures_of_t = typename signatures_of< T >::type |
|
using | config_value = variant< std::string, double, int64_t, bool, atom_value > |
| A variant type for config parameters.
|
|
template<class T > |
using | deduce_mpi_t = typename detail::dmfou< typename param_decay< T >::type >::type |
| Deduces the message passing interface from a function object.
|
|
template<class T , class U = void> |
using | enable_if_has_make_error_t = typename std::enable_if< has_make_error< T >::value, U >::type |
| Convenience alias for std::enable_if<has_make_error<T>::value, U>::type .
|
|
template<class T > |
using | function_view_flattened_result_t = typename function_view_flattened_result< T >::type |
|
using | actor_id = uint64_t uint64_t |
|
using | weak_actor_ptr = weak_intrusive_ptr< actor_control_block > |
|
using | strong_actor_ptr = intrusive_ptr< actor_control_block > |
|
using | stream_manager_ptr = intrusive_ptr< stream_manager > |
|
using | type_erased_value_ptr = std::unique_ptr< type_erased_value > |
|
using | mailbox_element_ptr = std::unique_ptr< mailbox_element, detail::disposer > |
|
template<spawn_mode X> |
using | spawn_mode_token = std::integral_constant< spawn_mode, X > |
|
template<class Found , class Expected > |
using | interface_mismatch_t = detail::imi< 0, Found, Expected, detail::type_list<> > |
| Scans two typed MPI lists for compatibility, returning the index of the first mismatch. More...
|
|
template<class Lockable > |
using | unique_lock = std::unique_lock< Lockable > |
|
template<class SharedLockable > |
using | upgrade_lock = shared_lock< SharedLockable > |
|
template<class T > |
using | param_t = typename std::conditional< std::is_arithmetic< T >::value||is_atom_constant< T >::value, T, param< T > >::type |
| Convenience alias that wraps T into param<T> unless T is arithmetic or an atom constant. More...
|
|
using | primitive_variant = variant< int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, float, double, long double, std::string, std::u16string, std::u32string, atom_value, bool > |
|
template<class... Is> |
using | reacts_to = typed_mpi< detail::type_list< Is... >, output_tuple< void > > |
|
template<class Ts , class... Xs> |
using | response_type_t = typename response_type< Ts, Xs... >::type |
| Computes the response message for input Xs... from the list of message passing interfaces Ts . More...
|
|
template<class Ts , class Xs > |
using | response_type_unbox_t = typename response_type_unbox< Ts, Xs >::type |
| Computes the response message for input Xs from the list of message passing interfaces Ts . More...
|
|
template<class F > |
using | stream_result_trait_t = stream_result_trait< typename detail::get_callable_trait< F >::fun_sig > |
|
template<class Fun , class Fin > |
using | stream_sink_trait_t = stream_sink_trait< typename detail::get_callable_trait< Fun >::fun_sig, typename detail::get_callable_trait< Fin >::fun_sig > |
|
template<class F > |
using | stream_source_trait_t = stream_source_trait< typename detail::get_callable_trait< F >::fun_sig > |
|
template<class F > |
using | stream_stage_trait_t = stream_stage_trait< typename detail::get_callable_trait< F >::fun_sig > |
|
using | charbuf = arraybuf< char > |
|
using | vectorbuf = containerbuf< std::vector< char > > |
|
using | generic_timeout_definition = timeout_definition< std::function< void()> > |
|
using | timestamp = std::chrono::time_point< std::chrono::system_clock, std::chrono::duration< int64_t, std::nano > > |
| A portable timestamp with nanosecond resolution anchored at the UNIX epoch.
|
|
using | sorted_builtin_types = detail::type_list< actor, std::vector< actor >, actor_addr, std::vector< actor_addr >, atom_value, std::vector< char >, down_msg, duration, timestamp, error, exit_msg, group, group_down_msg, int16_t, int32_t, int64_t, int8_t, long double, message, message_id, node_id, std::string, stream_msg, std::map< std::string, std::string >, strong_actor_ptr, std::set< std::string >, std::vector< std::string >, timeout_msg, uint16_t, std::u16string, uint32_t, std::u32string, uint64_t, uint8_t, unit_t, weak_actor_ptr, bool, double, float > |
| Compile-time list of all built-in types. 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 . More...
|
|
error | load_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid) |
|
error | save_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid) |
|
template<class Inspector > |
auto | context_of (Inspector *f) -> decltype(f->context()) |
|
execution_unit * | context_of (void *) |
|
std::string | to_string (const strong_actor_ptr &x) |
|
void | append_to_string (std::string &x, const strong_actor_ptr &y) |
|
std::string | to_string (const weak_actor_ptr &x) |
|
void | append_to_string (std::string &x, const weak_actor_ptr &y) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, strong_actor_ptr &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, weak_actor_ptr &x) |
|
template<class F > |
actor_factory | make_actor_factory (F fun) |
|
template<class T , class... Ts> |
actor_factory_result | dyn_spawn_class (actor_config &cfg, message &msg) |
|
template<class T , class... Ts> |
actor_factory | make_actor_factory () |
|
actor_ostream | aout (local_actor *self) |
| Convenience factory function for creating an actor output stream.
|
|
actor_ostream | aout (scoped_actor &self) |
| Convenience factory function for creating an actor output stream.
|
|
template<class... Sigs> |
actor_ostream | aout (const typed_actor_pointer< Sigs... > &ptr) |
| Convenience factory function for creating an actor output stream.
|
|
template<class T > |
std::string | get_mpi_field (const uniform_type_info_map &types) |
|
template<class T > |
std::string | get_rtti_from_mpi (const uniform_type_info_map &types) |
|
constexpr timeout_definition_builder | after (duration d) |
| Returns a generator for timeouts.
|
|
template<class Rep , class Period > |
constexpr timeout_definition_builder | after (std::chrono::duration< Rep, Period > d) |
| Returns a generator for timeouts.
|
|
atom_value | atom_from_string (const std::string &x) |
|
template<size_t Size> |
constexpr atom_value | atom (char const (&str)[Size]) |
| Creates an atom from given string literal.
|
|
template<size_t Size> |
constexpr uint64_t | atom_uint (char const (&str)[Size]) |
| Creates an atom from given string literal and return an integer representation of the atom. More...
|
|
constexpr uint64_t | atom_uint (atom_value x) |
| Converts an atom to its integer representation.
|
|
template<atom_value V> |
std::string | to_string (const atom_constant< V > &) |
|
template<class T > |
constexpr bool | statically_typed () |
|
template<class T > |
std::unique_ptr< config_option > | make_config_option (T &storage, const char *category, const char *name, const char *explanation) |
|
template<class... Ts> |
std::string | deep_to_string_as_tuple (Ts &&... xs) |
| Convenience function for deep_to_string(std::forward_as_tuple(xs...)) .
|
|
template<class... Ts> |
bool | operator== (const delegated< Ts... > &, const delegated< Ts... > &) |
|
template<class T > |
std::enable_if< std::is_same< error, decltype(std::declval< deserializer & >).apply(std::declval< T & >))) >::value >::type | operator & (deserializer &source, T &x) |
|
template<class T > |
std::enable_if< std::is_same< error, decltype(std::declval< deserializer & >).apply(std::declval< T & >))) >::value, deserializer & >::type | operator>> (deserializer &source, T &x) |
|
std::string | to_string (time_unit x) |
| Relates time_unit.
|
|
constexpr intmax_t | denom_to_unit_index (intmax_t x, intmax_t offset=2) |
|
constexpr time_unit | denom_to_time_unit (intmax_t x) |
|
template<class... Ts, class F = void (*)(actor_system&)> |
int | exec_main (F fun, int argc, char **argv, const char *config_file_name="caf-application.ini") |
|
std::string | to_string (exit_reason x) |
| Returns a string representation of given exit reason.
|
|
template<class T > |
std::string | to_string (const expected< T > &x) |
|
std::string | to_string (const expected< void > &x) |
|
template<class Inspector > |
Inspector::return_type | inspect (Inspector &f, inbound_path &x) |
|
bool | operator== (const index_mapping &x, const index_mapping &y) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, index_mapping &x) |
|
template<class T > |
std::string | to_string (const intrusive_ptr< T > &x) |
|
std::string | to_string (invoke_message_result x) |
|
std::string | to_string (logger::field_type x) |
|
std::string | to_string (const logger::field &x) |
|
bool | operator== (const logger::field &x, const logger::field &y) |
|
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) |
|
template<class... Ts> |
message | make_message_from_tuple (std::tuple< Ts... > xs) |
| Converts the tuple xs to a message.
|
|
bool | operator< (const match_case_info &x, const match_case_info &y) |
|
template<class F > |
std::enable_if< !std::is_base_of< match_case, F >::value, std::tuple< trivial_match_case< F > >>::type | to_match_case_tuple (F fun) |
|
template<class MatchCase > |
std::enable_if< std::is_base_of< match_case, MatchCase >::value, std::tuple< const MatchCase & >>::type | to_match_case_tuple (const MatchCase &x) |
|
template<class... Ts> |
const std::tuple< Ts... > & | to_match_case_tuple (const std::tuple< Ts... > &x) |
|
template<class T , class U > |
std::enable_if< std::is_base_of< match_case, T >::value||std::is_base_of< match_case, U >::value >::type | operator, (T, U) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, named_actor_config &x) |
|
bool | operator== (const node_id &lhs, const node_id &rhs) |
|
bool | operator!= (const node_id &lhs, const node_id &rhs) |
|
bool | operator< (const node_id &lhs, const node_id &rhs) |
|
template<class Inspector , class T > |
std::enable_if< Inspector::reads_state, typename Inspector::result_type >::type | inspect (Inspector &f, optional< T > &x) |
|
template<class Inspector , class T > |
std::enable_if< Inspector::writes_state, typename Inspector::result_type >::type | inspect (Inspector &f, optional< T > &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, outbound_path &x) |
|
template<class T > |
std::enable_if< std::is_same< T *, resumable * >::value >::type | intrusive_ptr_add_ref (T *ptr) |
|
template<class T > |
std::enable_if< std::is_same< T *, resumable * >::value >::type | intrusive_ptr_release (T *ptr) |
|
std::string | to_string (const scoped_actor &x) |
|
template<message_priority P = message_priority::normal, class Source = actor, class Dest = actor, class... Ts> |
void | send_as (const Source &src, const Dest &dest, Ts &&... xs) |
| Sends to a message under the identity of from with priority prio .
|
|
template<class Source , class Dest , class... Ts> |
void | unsafe_send_as (Source *src, const Dest &dest, Ts &&... xs) |
|
template<class... Ts> |
void | unsafe_response (local_actor *self, strong_actor_ptr src, std::vector< strong_actor_ptr > stages, message_id mid, Ts &&... xs) |
|
template<message_priority P = message_priority::normal, class Dest = actor, class... Ts> |
void | anon_send (const Dest &dest, Ts &&... xs) |
| Anonymously sends dest a message.
|
|
template<class Dest > |
void | anon_send_exit (const Dest &dest, exit_reason reason) |
| Anonymously sends dest an exit message.
|
|
void | anon_send_exit (const actor_addr &to, exit_reason reason) |
| Anonymously sends to an exit message.
|
|
void | anon_send_exit (const weak_actor_ptr &to, exit_reason reason) |
| Anonymously sends to an exit message.
|
|
template<class T > |
std::enable_if< std::is_same< error, decltype(std::declval< serializer & >).apply(std::declval< T & >))) >::value >::type | operator & (serializer &sink, const T &x) |
|
template<class T > |
std::enable_if< std::is_same< error, decltype(std::declval< serializer & >).apply(std::declval< T & >))) >::value, serializer & >::type | operator<< (serializer &sink, const T &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_id &x) |
|
template<class T > |
const T & | get (const stream_msg &x) |
| Allows the testing DSL to unbox stream_msg automagically.
|
|
template<class T > |
bool | is (const stream_msg &x) |
| Allows the testing DSL to check whether stream_msg holds a T .
|
|
template<class T , class... Ts> |
std::enable_if< detail::tl_contains< stream_msg::content_alternatives, T >::value, stream_msg >::type | make (const stream_id &sid, actor_addr addr, Ts &&... xs) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::open &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::ack_open &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::batch &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::ack_batch &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::close &) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::drop &) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::forced_close &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg::forced_drop &x) |
|
template<class Inspector > |
Inspector::result_type | inspect (Inspector &f, stream_msg &x) |
|
std::string | is_any_of (std::string arg) |
|
template<class Container , class Delim > |
void | split (Container &result, const std::string &str, const Delim &delims, bool keep_all=true) |
|
template<class Container > |
std::string | join (const Container &c, const std::string &glue) |
|
void | splice (std::string &, const std::string &) |
|
template<class T , class... Ts> |
void | splice (std::string &str, const std::string &glue, T &&arg, Ts &&... xs) |
|
template<ptrdiff_t WhatSize, ptrdiff_t WithSize> |
void | replace_all (std::string &str, const char(&what)[WhatSize], const char(&with)[WithSize]) |
|
template<size_t S> |
bool | starts_with (const std::string &str, const char(&prefix)[S]) |
|
template<size_t S> |
bool | ends_with (const std::string &str, const char(&suffix)[S]) |
|
template<class T > |
std::enable_if< std::is_arithmetic< T >::value, std::string >::type | convert_to_str (T value) |
|
std::string | convert_to_str (std::string value) |
|
std::ostream & | operator<< (std::ostream &out, term x) |
|
timestamp | make_timestamp () |
| Convenience function for returning a timestamp representing the current system time. More...
|
|
std::string | timestamp_to_string (const timestamp &x) |
| Converts the time-since-epoch of x to a string .
|
|
void | append_timestamp_to_string (std::string &x, const timestamp &y) |
| Appends the time-since-epoch of y to x .
|
|
template<class T , class E = typename std::enable_if< detail::is_inspectable< detail::stringification_inspector, T >::value >::type> |
std::string | to_string (const T &x) |
|
template<class... Ts> |
constexpr uint32_t | make_type_token () |
|
constexpr uint32_t | add_to_type_token (uint32_t token, uint16_t tnr) |
|
template<class T > |
constexpr uint32_t | make_type_token_from_list () |
|
template<class... Xs, class... Ts> |
detail::mpi_splice< typed_actor, detail::type_list< Xs... >, typename Ts::signatures... >::type | splice (const typed_actor< Xs... > &x, const Ts &... xs) |
|
template<class T , class... Ts> |
bool | holds_alternative (const variant< Ts... > &data) |
|