caf Namespace Reference

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...

Detailed Description

Root namespace of libcaf.

Typedef Documentation

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.

Function Documentation

void caf::await_all_actors_done

(

)

Blocks execution of this actor until all other actors finished execution.

Warning

This function will cause a deadlock if called from multiple actors.

Do not call this function in cooperatively scheduled actors.

Examples:

announce_1.cpp, announce_2.cpp, announce_3.cpp, announce_4.cpp, announce_5.cpp, dancing_kirby.cpp, dining_philosophers.cpp, and hello_world.cpp.

template<class... Sigs, class... Ts>

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).

template<class T >

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.

template<class T , typename U >

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.

Note

This function must be used before actor is spawned. Dynamically changing the scheduler at runtime is not supported.

Exceptions

std::logic_error

if a scheduler is already defined

template<class Policy = policy::work_stealing>

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).

Note

This function must be used before actor is spawned. Dynamically changing the scheduler at runtime is not supported.

Exceptions

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().

Examples:

announce_1.cpp, announce_2.cpp, announce_3.cpp, announce_4.cpp, announce_5.cpp, dancing_kirby.cpp, dining_philosophers.cpp, and hello_world.cpp.

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.

template<class C , spawn_options Os, typename BeforeLaunch , class... Ts>

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.

template<spawn_options Os, typename BeforeLaunch , typename F , class... Ts>

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.

template<class C , spawn_options Os, class BeforeLaunch , class... Ts>

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.

Parameters

allow_nullptr

if set to true, this function returns nullptr instead of throwing an exception on error

template<class T >

const uniform_type_info* caf::uniform_typeid

(

bool

allow_nullptr = false

)

Returns the uniform type info for type T.

Parameters

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.

Precondition

nr > 0 && nr < detail::type_nrs

Variable Documentation

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.

Note

This implicitly causes the actor to run in its own thread.