libcaf
0.13.2
|
Root namespace of libcaf. More...
Namespaces | |
exit_reason | |
Contains all predefined exit reasons. | |
io | |
Contains all network-related classes and functions. | |
mixin | |
Contains mixin classes implementing several actor traits. | |
policy | |
Contains policies encapsulating characteristics or algorithms. | |
Classes | |
class | abstract_actor |
Base class for all actor implementations. More... | |
class | abstract_channel |
Interface for all message receivers. More... | |
class | abstract_group |
A multicast group. More... | |
class | abstract_uniform_type_info |
Implements all pure virtual functions of uniform_type_info except serialize() and deserialize(). More... | |
class | actor |
Identifies an untyped actor. More... | |
class | actor_addr |
Stores the address of typed as well as untyped actors. More... | |
class | actor_companion |
An co-existing 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_exited |
Thrown if an actor finished execution. More... | |
class | actor_namespace |
Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages. 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 | advanced_match_case_impl |
struct | anything |
Acts as wildcard expression in patterns. More... | |
struct | atom_constant |
Lifts an atom_value to a compile-time constant. More... | |
class | attachable |
Callback utility class. More... | |
class | behavior |
Describes the behavior of an actor, i.e., provides a message handler and an optional timeout. More... | |
class | binary_deserializer |
Implements the deserializer interface with a binary serialization protocol. More... | |
class | binary_serializer |
Implements the serializer interface with a binary serialization protocol. More... | |
class | bind_failure |
Thrown to indicate that an actor publishing failed because the requested port could not be used. 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_response_handle_tag |
This tag identifies response handles featuring a blocking API by providing an await member function. More... | |
class | caf_exception |
Base class for exceptions. More... | |
class | channel |
A handle to instances of abstract_channel . More... | |
class | continue_helper |
Helper class to enable users to add continuations when dealing with synchronous sends. More... | |
class | deserializer |
Technology-independent deserialization interface. More... | |
struct | down_msg |
Sent to all actors monitoring an actor when it is terminated. More... | |
class | duration |
Time duration consisting of a time_unit and a 64 bit unsigned integer. 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... | |
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... | |
struct | group_down_msg |
Sent to all members of a group when it goes offline. More... | |
class | handle |
Base class for IO handles such as accept_handle or connection_handle . More... | |
struct | illegal_message_element |
Marker class identifying classes in CAF that are not allowed to be used as message element. More... | |
struct | infer_typed_actor_base |
Infers the appropriate base class for a functor-based typed actor from the result and the first argument of the functor. More... | |
class | intrusive_ptr |
An intrusive, reference counting smart pointer impelementation. More... | |
struct | is_anything |
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... | |
class | local_actor |
Base class for actors running on this node, either living in an own thread or cooperatively scheduled. 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 | network_error |
Thrown to indicate that either an actor publishing failed or the middleman was unable to connect to a remote host. More... | |
class | node_id |
A node ID consists of a host ID and process ID. More... | |
struct | nonblocking_response_handle_tag |
This tag identifies response handles featuring a nonblocking API by providing a then member function. More... | |
class | optional |
Represents an optional value of T . More... | |
class | optional< T & > |
Template specialization to allow optional to hold a reference rather than an actual value. 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 | 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 sync_send(...).then(...) . More... | |
class | response_promise |
A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More... | |
class | resumable |
A cooperatively executed task managed by one or more instances of execution_unit . More... | |
class | scoped_actor |
A scoped handle to a blocking actor. More... | |
class | serializer |
Technology-independent serialization interface. More... | |
struct | skip_message_t |
Optional return type for functors used in pattern matching expressions. More... | |
class | spawn_options |
struct | sync_exited_msg |
Sent whenever a terminated actor receives a synchronous request. More... | |
struct | sync_timeout_msg |
Sent whenever a timeout occurs during a synchronous send. More... | |
struct | timeout_msg |
Signalizes a timeout event. More... | |
class | typed_actor |
Identifies a strongly typed actor. More... | |
class | typed_event_based_actor |
A cooperatively scheduled, event-based actor implementation with strong type checking. More... | |
struct | unbox_message_element |
Unboxes atom constants, i.e., converts atom_constant<V> to V . More... | |
class | uniform_type_info |
Provides a platform independent type name and a (very primitive) kind of reflection in combination with object. More... | |
class | variant |
A variant represents always a valid value of one of the types Ts... . More... | |
Typedefs | |
using | abstract_actor_ptr = intrusive_ptr< abstract_actor > |
using | add_atom = atom_constant< atom("ADD")> |
Generic 'ADD' atom for request operations. | |
using | get_atom = atom_constant< atom("GET")> |
Generic 'GET' atom for request operations. | |
using | put_atom = atom_constant< atom("PUT")> |
Generic 'PUT' atom for request operations. | |
using | delete_atom = atom_constant< atom("DELETE")> |
Generic 'DELETE' atom for request operations. | |
using | ok_atom = atom_constant< atom("OK")> |
Generic 'OK' atom for response messages. | |
using | error_atom = atom_constant< atom("ERROR")> |
Generic 'ERROR' atom for response messages. | |
using | sys_atom = atom_constant< atom("SYS")> |
Marker 'SYS' atom for prefixing messages to a forwarding chain to address an otherwise transparent actor. More... | |
using | join_atom = atom_constant< atom("JOIN")> |
Generic 'JOIN' atom, e.g., for signaling group subscriptions. | |
using | leave_atom = atom_constant< atom("LEAVE")> |
Generic 'LEAVE' atom, e.g., for signaling group unsubscriptions. | |
using | forward_atom = atom_constant< atom("FORWARD")> |
Generic 'FORWARD' atom, e.g., for signaling an actor that it should drop the first element and forward the remainder to a list of predefined receivers. More... | |
using | flush_atom = atom_constant< atom("FLUSH")> |
Generic 'FLUSH' atom, e.g., used by aout . | |
using | link_atom = atom_constant< atom("LINK")> |
Generic 'LINK' atom for link requests over network. | |
using | unlink_atom = atom_constant< atom("UNLINK")> |
Generic 'UNLINK' atom for removing networked links. | |
using | actor_id = uint64_t uint32_t |
using | abstract_group_ptr = intrusive_ptr< abstract_group > |
using | actor_proxy_ptr = intrusive_ptr< actor_proxy > |
using | mailbox_element_ptr = std::unique_ptr< mailbox_element, detail::disposer > |
template<class Lockable > | |
using | unique_lock = std::unique_lock< Lockable > |
template<class SharedLockable > | |
using | upgrade_lock = shared_lock< SharedLockable > |
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...>, detail::type_list< void >, detail::empty_type_list > |
using | generic_timeout_definition = timeout_definition< std::function< void()>> |
using | uniform_value = std::unique_ptr< uniform_value_t > |
Enumerations | |
enum | atom_value : uint64_t |
The value type of atoms. | |
enum | time_unit : uint32_t |
SI time units to specify timeouts. | |
enum | invoke_message_result { im_success, im_skipped, im_dropped } |
enum | message_priority : uint32_t { normal, high } |
Functions | |
template<class T , typename U > | |
T | actor_cast (const U &what) |
Converts actor handle what to a different actor handle of type T . | |
actor_ostream | aout (actor self) |
const uniform_type_info * | announce (const std::type_info &tinfo, uniform_type_info_ptr utype) |
Adds a new mapping to the type system. More... | |
template<class Member , class Parent , class... Ts> | |
std::pair< Member Parent::*, abstract_uniform_type_info< Member > * > | compound_member (Member Parent::*memptr, const Ts &...xs) |
Creates meta information for a non-trivial Member , whereas xs are the "sub-members" of Member . More... | |
template<class Member , class Parent , class... Ts> | |
std::pair< Member &(Parent::*)(), abstract_uniform_type_info< Member > * > | compound_member (Member &(Parent::*getter)(), const Ts &...xs) |
Creates meta information for a non-trivial Member accessed via the getter member function getter returning a mutable reference, whereas xs are the "sub-members" of Member . More... | |
template<class Parent , class GRes , class SRes , class SArg , class... Ts> | |
std::pair< std::pair< GRes(Parent::*)() const, SRes(Parent::*)(SArg)>, abstract_uniform_type_info< typename std::decay< GRes >::type > * > | compound_member (const std::pair< GRes(Parent::*)() const, SRes(Parent::*)(SArg)> &gspair, const Ts &...xs) |
Creates meta information for a non-trivial Member accessed via the pair of getter and setter member function pointers gspair , whereas xs are the "sub-members" of Member . More... | |
template<class T , class... Ts> | |
const uniform_type_info * | announce (std::string tname, const Ts &...xs) |
Adds a new type mapping for T to the type system using tname as its uniform name and the list of member pointers xs . More... | |
template<size_t Size> | |
constexpr atom_value | atom (char const (&str)[Size]) |
Creates an atom from given string literal. | |
void | await_all_actors_done () |
Blocks execution of this actor until all other actors finished execution. More... | |
template<class T > | |
binary_deserializer & | operator>> (binary_deserializer &lhs, T &rhs) |
template<class T , class = typename std::enable_if<detail::is_primitive<T>::value>::type> | |
binary_serializer & | operator<< (binary_serializer &bs, const T &value) |
template<class... Sigs, class... Ts> | |
void | check_typed_input (const typed_actor< Sigs...> &, const detail::type_list< Ts...> &) |
Checks whether R does support an input of type {Ts...} via a static assertion (always returns 0). More... | |
template<class T > | |
T & | unopt (T &v) |
template<class T > | |
T & | unopt (optional< T > &v) |
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< MatchCase & >>::type | to_match_case_tuple (MatchCase &x) |
template<class... Ts> | |
std::tuple< Ts...> & | to_match_case_tuple (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 T > | |
constexpr detail::boxed< T >::type | val () |
A wildcard that matches any value of type T . | |
template<class T , typename BinaryPredicate > | |
std::function< optional< T >const T &)> | guarded (BinaryPredicate p, T value) |
Generates function objects from a binary predicate and a value. | |
template<class T , typename Predicate > | |
unit_t | guarded (Predicate, const detail::wrapped< T > &) |
unit_t | to_guard (const anything &) |
template<class T > | |
unit_t | to_guard (detail::wrapped< T >(*)()) |
template<class T > | |
unit_t | to_guard (const detail::wrapped< T > &) |
template<class T > | |
std::function< optional< typename detail::strip_and_convert< T >::type > const typename detail::strip_and_convert< T >::type &)> | to_guard (const T &value, typename std::enable_if<!detail::is_callable< T >::value >::type *=0) |
template<class F > | |
F | to_guard (F fun, typename std::enable_if< detail::is_callable< F >::value >::type *=0) |
template<atom_value V> | |
auto | to_guard (const atom_constant< V > &) -> decltype(to_guard(V)) |
template<class... Ts> | |
auto | on (const Ts &...xs) -> detail::advanced_match_case_builder< detail::type_list< decltype(to_guard(xs))... >, detail::type_list< typename detail::pattern_type< typename std::decay< Ts >::type >::type...> > |
Returns a generator for match_case objects. | |
template<class T , class... Ts> | |
decltype(on(val< T >(), val< Ts >()...)) | on () |
Returns a generator for match_case objects. | |
template<atom_value A0, class... Ts> | |
decltype(on(A0, val< Ts >()...)) | on () |
Returns a generator for match_case objects. | |
template<atom_value A0, atom_value A1, class... Ts> | |
decltype(on(A0, A1, val< Ts >()...)) | on () |
Returns a generator for match_case objects. | |
template<atom_value A0, atom_value A1, atom_value A2, class... Ts> | |
decltype(on(A0, A1, A2, val< Ts >()...)) | on () |
Returns a generator for match_case objects. | |
template<atom_value A0, atom_value A1, atom_value A2, atom_value A3, class... Ts> | |
decltype(on(A0, A1, A2, A3, val< Ts >()...)) | on () |
Returns a generator for match_case objects. | |
template<class Rep , class Period > | |
constexpr detail::timeout_definition_builder | after (const std::chrono::duration< Rep, Period > &d) |
Returns a generator for timeouts. | |
template<class... Ts> | |
void | send_as (const actor &from, message_priority prio, const channel &to, Ts &&...xs) |
Sends to a message under the identity of from with priority prio . | |
template<class... Ts> | |
void | send_as (const actor &from, const channel &to, Ts &&...xs) |
Sends to a message under the identity of from . | |
template<class... Sigs, class... Ts> | |
void | send_as (const actor &from, message_priority prio, const typed_actor< Sigs...> &to, Ts &&...xs) |
Sends to a message under the identity of from with priority prio . | |
template<class... Sigs, class... Ts> | |
void | send_as (const actor &from, const typed_actor< Sigs...> &to, Ts &&...xs) |
Sends to a message under the identity of from . | |
template<class... Ts> | |
void | anon_send (message_priority prio, const channel &to, Ts &&...xs) |
Anonymously sends to a message with priority prio . | |
template<class... Ts> | |
void | anon_send (const channel &to, Ts &&...xs) |
Anonymously sends to a message. | |
template<class... Sigs, class... Ts> | |
void | anon_send (message_priority prio, const typed_actor< Sigs...> &to, Ts &&...xs) |
Anonymously sends to a message with priority prio . | |
template<class... Sigs, class... Ts> | |
void | anon_send (const typed_actor< Sigs...> &to, Ts &&...xs) |
Anonymously sends to a message. | |
void | anon_send_exit (const actor_addr &to, uint32_t reason) |
Anonymously sends to an exit message. | |
template<class ActorHandle > | |
void | anon_send_exit (const ActorHandle &to, uint32_t reason) |
Anonymously sends to an exit message. | |
void | send_tuple_as (const actor &from, const channel &to, message msg) CAF_DEPRECATED |
void | send_tuple_as (const actor &from, const channel &to, message_priority prio, message msg) CAF_DEPRECATED |
void | anon_send_tuple (const channel &to, message msg) CAF_DEPRECATED |
void | anon_send_tuple (const channel &to, message_priority prio, message msg) CAF_DEPRECATED |
void | set_scheduler (scheduler::abstract_coordinator *ptr) |
Sets a user-defined scheduler. More... | |
template<class Policy = policy::work_stealing> | |
void | set_scheduler (size_t nw=std::thread::hardware_concurrency(), size_t max_throughput=std::numeric_limits< size_t >::max()) |
Sets a user-defined scheduler using given policies. More... | |
void | shutdown () |
Destroys all singletons and stops the scheduler. More... | |
constexpr skip_message_t | skip_message () |
Tells the runtime system to skip a message when used as message handler, i.e., causes the runtime to leave the message in the mailbox of an actor. More... | |
std::ostream & | operator<< (std::ostream &, skip_message_t) |
template<class C , spawn_options Os, class BeforeLaunch , class... Ts> | |
intrusive_ptr< C > | spawn_impl (execution_unit *host, BeforeLaunch before_launch_fun, Ts &&...xs) |
Returns a newly spawned instance of type C using xs... as constructor arguments. More... | |
template<class C , spawn_options Os, typename BeforeLaunch , class... Ts> | |
intrusive_ptr< C > | spawn_class (execution_unit *host, BeforeLaunch before_launch_fun, Ts &&...xs) |
Called by spawn when used to create a class-based actor (usually should not be called by users of the library). More... | |
template<spawn_options Os, class C , class BeforeLaunch , class F , class... Ts> | |
intrusive_ptr< C > | spawn_functor_impl (execution_unit *eu, BeforeLaunch cb, F fun, Ts &&...xs) |
template<spawn_options Os, typename BeforeLaunch , typename F , class... Ts> | |
actor | spawn_functor (execution_unit *eu, BeforeLaunch cb, F fun, Ts &&...xs) |
Called by spawn when used to create a functor-based actor (usually should not be called by users of the library). More... | |
std::string | is_any_of (std::string arg) |
void | split (std::vector< std::string > &result, const std::string &str, const std::string &delimiters=" ", bool keep_empties=true) |
template<class Iterator > | |
std::string | join (Iterator begin, Iterator end, const std::string &glue) |
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<class T , typename U > | |
std::enable_if< !std::is_floating_point< T >::value &&!std::is_floating_point< U >::value, bool >::type | safe_equal (const T &lhs, const U &rhs) |
Compares two values by using operator== unless two floating point numbers are compared. More... | |
template<class T , typename U > | |
std::enable_if< std::is_floating_point< T >::value||std::is_floating_point< U >::value, bool >::type | safe_equal (const T &lhs, const U &rhs) |
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) |
template<class T > | |
caf::optional< T > | spro (const std::string &str) |
std::string | to_verbose_string (const std::exception &e) |
Converts e to a string including e.what() . | |
uniform_value | from_string_impl (const std::string &what) |
Converts a string created by to_string to its original value. | |
template<class T > | |
optional< T > | from_string (const std::string &what) |
Convenience function that tries to deserializes a value from what and converts the result to T . More... | |
template<class T > | |
std::enable_if< detail::tl_exists< detail::type_list< exit_msg, down_msg, sync_exited_msg >, detail::tbind< std::is_same, T >::template type >::value, bool >::type | operator== (const T &lhs, const T &rhs) |
template<class T > | |
std::enable_if< detail::tl_exists< detail::type_list< exit_msg, down_msg, sync_exited_msg >, detail::tbind< std::is_same, T >::template type >::value, bool >::type | operator!= (const T &lhs, const T &rhs) |
bool | operator== (const group_down_msg &lhs, const group_down_msg &rhs) |
bool | operator!= (const group_down_msg &lhs, const group_down_msg &rhs) |
bool | operator== (const timeout_msg &lhs, const timeout_msg &rhs) |
bool | operator!= (const timeout_msg &lhs, const timeout_msg &rhs) |
template<class T > | |
std::string | type_name_access_impl (std::true_type) |
template<class T > | |
std::string | type_name_access_impl (std::false_type) |
template<class T > | |
std::string | type_name_access () |
template<class T , class... Ts> | |
uniform_value | make_uniform_value (const uniform_type_info *uti, Ts &&...xs) |
const uniform_type_info * | uniform_typeid_by_nr (uint16_t nr) |
Returns the uniform type info for the builtin type identified by nr . More... | |
const uniform_type_info * | uniform_typeid (const std::type_info &tinf, bool allow_nullptr=false) |
Returns the uniform type info for type tinf . More... | |
template<class T > | |
const uniform_type_info * | uniform_typeid (bool allow_nullptr=false) |
Returns the uniform type info for type T . More... | |
template<class C , spawn_options Os = no_spawn_options, class... Ts> | |
actor | spawn (Ts &&...xs) |
Returns a new actor of type C using xs... as constructor arguments. More... | |
template<spawn_options Os = no_spawn_options, class... Ts> | |
actor | spawn (Ts &&...xs) |
Returns a new functor-based actor. More... | |
template<class C , spawn_options Os = no_spawn_options, class Groups , class... Ts> | |
actor | spawn_in_groups (const Groups &grps, Ts &&...xs) |
Returns a new actor that immediately, i.e., before this function returns, joins grps of type C using xs as constructor arguments. | |
template<class C , spawn_options Os = no_spawn_options, class... Ts> | |
actor | spawn_in_groups (std::initializer_list< group > grps, Ts &&...xs) |
template<class C , spawn_options Os = no_spawn_options, class... Ts> | |
actor | spawn_in_group (const group &grp, Ts &&...xs) |
Returns a new actor that immediately, i.e., before this function returns, joins grp of type C using xs as constructor arguments. | |
template<spawn_options Os = no_spawn_options, class Groups , class... Ts> | |
actor | spawn_in_groups (const Groups &grps, Ts &&...xs) |
Returns a new actor that immediately, i.e., before this function returns, joins grps . More... | |
template<spawn_options Os = no_spawn_options, class... Ts> | |
actor | spawn_in_groups (std::initializer_list< group > grps, Ts &&...xs) |
template<spawn_options Os = no_spawn_options, class... Ts> | |
actor | spawn_in_group (const group &grp, Ts &&...xs) |
Returns a new actor that immediately, i.e., before this function returns, joins grp . More... | |
template<class C , spawn_options Os = no_spawn_options, class... Ts> | |
actor_handle_from_signature_list< typename C::signatures >::type | spawn_typed (Ts &&...xs) |
Returns a new typed actor of type C using xs... as constructor arguments. More... | |
template<spawn_options Os, typename BeforeLaunch , typename F , class... Ts> | |
infer_typed_actor_handle< typename detail::get_callable_trait< F >::result_type, typename detail::tl_head< typename detail::get_callable_trait< F >::arg_types >::type >::type | spawn_typed_functor (execution_unit *eu, BeforeLaunch cb, F fun, Ts &&...xs) |
Spawns a typed actor from a functor . | |
template<spawn_options Os = no_spawn_options, typename F , class... Ts> | |
infer_typed_actor_handle< typename detail::get_callable_trait< F >::result_type, typename detail::tl_head< typename detail::get_callable_trait< F >::arg_types >::type >::type | spawn_typed (F fun, Ts &&...xs) |
Returns a new typed actor from a functor. More... | |
Variables | |
constexpr actor_id | invalid_actor_id = 0 |
Denotes an ID that is never used by an actor. | |
constexpr invalid_message_id_t | invalid_message_id = invalid_message_id_t{} |
static constexpr none_t | none = none_t{} |
constexpr auto | any_vals = anything() |
A wildcard that matches any number of any values. | |
constexpr auto | arg_match = detail::boxed<detail::arg_match_t>::type() |
A wildcard that matches the argument types of a given callback, must be the last argument to on() . More... | |
constexpr auto | others = detail::catch_all_match_case_builder() |
Generates catch-all match_case objects. | |
constexpr auto | on_arg_match = detail::trivial_match_case_builder() |
Semantically equal to on(arg_match) , but uses a (faster) special-purpose match_case implementation. More... | |
caf::sb_actor | CAF_DEPRECATED |
constexpr bool | token_compress_on = false |
static constexpr unit_t | unit = unit_t{} |
constexpr spawn_options | no_spawn_options = spawn_options::no_flags |
Denotes default settings. | |
constexpr spawn_options | monitored = spawn_options::monitor_flag |
Causes spawn to call `self->monitor(...) immediately after the new actor was spawned. More... | |
constexpr spawn_options | linked = spawn_options::link_flag |
Causes spawn to call `self->link_to(...) immediately after the new actor was spawned. More... | |
constexpr spawn_options | detached = spawn_options::detach_flag |
Causes the new actor to opt out of the cooperative scheduling. | |
constexpr spawn_options | hidden = spawn_options::hide_flag |
Causes the runtime to ignore the new actor in await_all_actors_done() . | |
constexpr spawn_options | blocking_api = spawn_options::blocking_api_flag |
Causes the new actor to opt in to the blocking API, i.e., the actor uses a context-switching or thread-based backend instead of the default event-based implementation. More... | |
constexpr spawn_options | priority_aware = spawn_options::priority_aware_flag |
Causes the new actor to evaluate message priorities. More... | |
constexpr spawn_options | lazy_init = spawn_options::lazy_init_flag |
Causes the new actor to delay its initialization until a message arrives. More... | |
Root namespace of libcaf.
using caf::forward_atom = typedef atom_constant<atom("FORWARD")> |
Generic 'FORWARD' atom, e.g., for signaling an actor that it should drop the first element and forward the remainder to a list of predefined receivers.
using caf::sys_atom = typedef atom_constant<atom("SYS")> |
Marker 'SYS' atom for prefixing messages to a forwarding chain to address an otherwise transparent actor.
void caf::await_all_actors_done | ( | ) |
Blocks execution of this actor until all other actors finished execution.
void caf::check_typed_input | ( | const typed_actor< Sigs...> & | , |
const detail::type_list< Ts...> & | |||
) |
Checks whether R
does support an input of type {Ts...}
via a static assertion (always returns 0).
optional<T> caf::from_string | ( | const std::string & | what | ) |
Convenience function that tries to deserializes a value from what
and converts the result to T
.
std::enable_if< ! std::is_floating_point<T>::value && ! std::is_floating_point<U>::value, bool>::type caf::safe_equal | ( | const T & | lhs, |
const U & | rhs | ||
) |
Compares two values by using operator==
unless two floating point numbers are compared.
In the latter case, the function performs an epsilon comparison.
void caf::set_scheduler | ( | scheduler::abstract_coordinator * | ptr | ) |
Sets a user-defined scheduler.
std::logic_error | if a scheduler is already defined |
void caf::set_scheduler | ( | size_t | nw = std::thread::hardware_concurrency() , |
size_t | max_throughput = std::numeric_limits<size_t>::max() |
||
) |
Sets a user-defined scheduler using given policies.
The scheduler is instantiated with nw
number of workers and allows each actor to consume up to max_throughput
per resume (must be > 0).
std::logic_error | if a scheduler is already defined |
std::invalid_argument | if max_throughput == 0 |
void caf::shutdown | ( | ) |
Destroys all singletons and stops the scheduler.
It is recommended to use this function as very last function call before leaving main().
constexpr skip_message_t caf::skip_message | ( | ) |
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.
intrusive_ptr< C > caf::spawn_class | ( | execution_unit * | host, |
BeforeLaunch | before_launch_fun, | ||
Ts &&... | xs | ||
) |
Called by spawn
when used to create a class-based actor (usually should not be called by users of the library).
This function simply forwards its arguments to spawn_impl
using detail::spawn_fwd
.
actor caf::spawn_functor | ( | execution_unit * | eu, |
BeforeLaunch | cb, | ||
F | fun, | ||
Ts &&... | xs | ||
) |
Called by spawn
when used to create a functor-based actor (usually should not be called by users of the library).
This function selects a proper implementation class and then delegates to spawn_class
.
intrusive_ptr<C> caf::spawn_impl | ( | execution_unit * | host, |
BeforeLaunch | before_launch_fun, | ||
Ts &&... | xs | ||
) |
Returns a newly spawned instance of type C
using xs...
as constructor arguments.
The instance will be added to the job list of host
. However, before the instance is launched, before_launch_fun
will be called, e.g., to join a group before the actor is running.
const uniform_type_info* caf::uniform_typeid | ( | const std::type_info & | tinf, |
bool | allow_nullptr = false |
||
) |
Returns the uniform type info for type tinf
.
allow_nullptr | if set to true, this function returns nullptr instead of throwing an exception on error |
const uniform_type_info* caf::uniform_typeid | ( | bool | allow_nullptr = false | ) |
Returns the uniform type info for type T
.
allow_nullptr | if set to true, this function returns nullptr instead of throwing an exception on error |
const uniform_type_info* caf::uniform_typeid_by_nr | ( | uint16_t | nr | ) |
Returns the uniform type info for the builtin type identified by nr
.
nr > 0 && nr < detail::type_nrs
constexpr auto caf::arg_match = detail::boxed<detail::arg_match_t>::type() |
A wildcard that matches the argument types of a given callback, must be the last argument to on()
.
constexpr spawn_options caf::blocking_api = spawn_options::blocking_api_flag |
Causes the new actor to opt in to the blocking API, i.e., the actor uses a context-switching or thread-based backend instead of the default event-based implementation.
constexpr spawn_options caf::lazy_init = spawn_options::lazy_init_flag |
Causes the new actor to delay its initialization until a message arrives.
constexpr spawn_options caf::linked = spawn_options::link_flag |
Causes spawn
to call `self->link_to(...) immediately after the new actor was spawned.
constexpr spawn_options caf::monitored = spawn_options::monitor_flag |
Causes spawn
to call `self->monitor(...) immediately after the new actor was spawned.
constexpr auto caf::on_arg_match = detail::trivial_match_case_builder() |
Semantically equal to on(arg_match)
, but uses a (faster) special-purpose match_case
implementation.
constexpr spawn_options caf::priority_aware = spawn_options::priority_aware_flag |
Causes the new actor to evaluate message priorities.