caf::io::typed_broker< Sigs > Class Template Reference

A typed broker mediates between actor systems and other components in the network. More...

#include <typed_broker.hpp>

Inheritance diagram for caf::io::typed_broker< Sigs >:

Public Types
using	signatures = type_list<Sigs...>
using	actor_hdl = typed_actor<Sigs...>
using	behavior_type = typed_behavior<Sigs...>
using	super
Public Types inherited from caf::local_actor
using	clock_type = std::chrono::steady_clock
	Defines a monotonic clock suitable for measuring intervals.

Public Member Functions
void	initialize () override
template<class F , class... Ts>
infer_handle_from_fun_t< F >	fork (F fun, connection_handle hdl, Ts &&... xs)
expected< connection_handle >	add_tcp_scribe (const std::string &host, uint16_t port)
connection_handle	add_tcp_scribe (network::native_socket fd)
expected< std::pair< accept_handle, uint16_t > >	add_tcp_doorman (uint16_t port=0, const char *in=nullptr, bool reuse_addr=false)
expected< accept_handle >	add_tcp_doorman (network::native_socket fd)
	typed_broker (actor_config &cfg)
template<class T , class... Ts>
void	become (T &&arg, Ts &&... args)
	Changes the behavior of this actor.
void	unbecome ()
	Removes the last added behavior.
Public Member Functions inherited from caf::local_actor
	local_actor (actor_config &cfg)
void	on_cleanup (const error &) override
	Called from cleanup to perform extra cleanup actions for this actor.
void	setup_metrics ()
virtual void	launch (scheduler *sched, bool lazy, bool hide)=0
clock_type::time_point	now () const noexcept
	Returns the current time.
disposable	request_response_timeout (timespan d, message_id mid)
	Requests a new timeout for mid.
template<class... Args>
void	println (std::string_view fmt, Args &&... args)
	Adds a new line to stdout.
template<class... Args>
void	println (term color, std::string_view fmt, Args &&... args)
	Adds a new line to stdout.
template<class T , spawn_options Os = no_spawn_options, class... Ts>
infer_handle_from_class_t< T >	spawn (Ts &&... xs)
template<spawn_options Options = no_spawn_options, class CustomSpawn , class... Args>
CustomSpawn::handle_type	spawn (CustomSpawn, Args &&... args)
template<spawn_options Os = no_spawn_options, class F , class... Ts>
infer_handle_from_fun_t< F >	spawn (F fun, Ts &&... xs)
void	send_exit (const actor_addr &receiver, error reason)
	Sends an exit message to receiver.
void	send_exit (const strong_actor_ptr &receiver, error reason)
	Sends an exit message to receiver.
template<class Handle >
void	send_exit (const Handle &receiver, error reason)
	Sends an exit message to receiver.
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
void	anon_send (const Handle &receiver, T &&arg, Ts &&... args)
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
disposable	scheduled_anon_send (const Handle &receiver, actor_clock::time_point timeout, T &&arg, Ts &&... args)
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
disposable	delayed_anon_send (const Handle &receiver, actor_clock::duration_type timeout, T &&arg, Ts &&... args)
scheduler *	context () const noexcept
	Returns the execution unit currently used by this actor.
void	context (scheduler *x) noexcept
	Sets the execution unit for this actor.
actor_system &	system () const noexcept
	Returns the hosting actor system.
const actor_system_config &	config () const noexcept
	Returns the config of the hosting actor system.
actor_clock &	clock () const noexcept
	Returns the clock of the actor system.
strong_actor_ptr &	current_sender () noexcept
	Returns a pointer to the sender of the current message.
message_id	current_message_id () noexcept
	Returns the ID of the current message.
message_id	take_current_message_id () noexcept
	Returns the ID of the current message and marks the ID stored in the current mailbox element as answered.
void	drop_current_message_id () noexcept
	Marks the current message ID as answered.
mailbox_element *	current_mailbox_element () noexcept
	Returns a pointer to the currently processed mailbox element.
void	monitor (const node_id &node)
	Adds a unidirectional monitor to node.
void	demonitor (const node_id &node)
	Removes a monitor from node.
virtual void	on_exit ()
	Can be overridden to perform cleanup code after an actor finished execution.
template<class... Ts>
detail::response_promise_t< Ts... >	make_response_promise ()
	Creates a typed_response_promise to respond to a request later on.
response_promise	make_response_promise ()
	Creates a response_promise to respond to a request later on.
const char *	name () const override
	Returns an implementation-dependent name for logging purposes, which is only valid as long as the actor is running.
virtual error	save_state (serializer &sink, unsigned int version)
	Serializes the state of this actor to sink.
virtual error	load_state (deserializer &source, unsigned int version)
	Deserializes the state of this actor from source.
const error &	fail_state () const noexcept
	Returns the currently defined fail state.
Public Member Functions inherited from caf::abstract_actor
	abstract_actor (const abstract_actor &)=delete
abstract_actor &	operator= (const abstract_actor &)=delete
void	attach (attachable_ptr ptr)
	Attaches ptr to this actor.
template<class F >
void	attach_functor (F f)
	Convenience function that attaches the functor f to this actor.
size_t	detach (const attachable::token &what)
	Detaches the first attached object that matches what.
void	link_to (const actor_addr &other)
	Links this actor to other.
template<class ActorHandle >
void	link_to (const ActorHandle &other)
	Links this actor to other.
void	unlink_from (const actor_addr &other)
	Unlinks this actor from addr.
template<class ActorHandle >
void	unlink_from (const ActorHandle &other)
	Links this actor to hdl.
virtual std::set< std::string >	message_types () const
	Returns the set of accepted messages types as strings or an empty set if this actor is untyped.
actor_id	id () const noexcept
	Returns the ID of this actor.
node_id	node () const noexcept
	Returns the node this actor is living on.
actor_system &	home_system () const noexcept
	Returns the system that created this actor (or proxy).
actor_control_block *	ctrl () const
	Returns the control block for this actor.
actor_addr	address () const noexcept
	Returns the logical actor address.
virtual bool	enqueue (mailbox_element_ptr what, scheduler *sched)=0
	Enqueues a new message wrapped in a mailbox_element to the actor.
virtual mailbox_element *	peek_at_next_mailbox_element ()
	Called by the testing DSL to peek at the next element in the mailbox.
bool	cleanup (error &&reason, scheduler *sched)
	Called by the runtime system to perform cleanup actions for this actor.

Protected Member Functions
virtual behavior_type	make_behavior ()
Protected Member Functions inherited from caf::local_actor
void	do_send (abstract_actor *receiver, message_priority priority, message &&msg)
	Sends msg as an asynchronous message to receiver.
disposable	do_scheduled_send (strong_actor_ptr receiver, message_priority priority, actor_clock::time_point timeout, message &&msg)
	Sends msg as an asynchronous message to receiver after the timeout.
void	do_anon_send (abstract_actor *receiver, message_priority priority, message &&msg)
	Sends msg as an asynchronous message to receiver without sender information.
disposable	do_scheduled_anon_send (strong_actor_ptr receiver, message_priority priority, actor_clock::time_point timeout, message &&msg)
	Sends msg as an asynchronous message to receiver after the timeout without sender information.
void	do_monitor (abstract_actor *ptr, message_priority prio)
void	do_demonitor (const strong_actor_ptr &whom)
Protected Member Functions inherited from caf::abstract_actor
virtual void	on_unreachable ()
	Called on actor if the last strong reference to it expired without a prior call to quit(exit_reason::not_exited).
int	flags () const
void	flags (int new_value)
bool	is_terminated () const noexcept
	Checks whether this actor has terminated.
	abstract_actor (actor_config &cfg)
void	attach_impl (attachable_ptr &ptr)
size_t	detach_impl (const attachable::token &what, bool stop_on_hit=false, bool dry_run=false)
void	add_link (abstract_actor *other)
	Causes the actor to establish a link to other.
void	remove_link (abstract_actor *other)
	Causes the actor to remove any established link to other.
virtual bool	add_backlink (abstract_actor *other)
	Adds an entry to other to the link table of this actor.
virtual bool	remove_backlink (abstract_actor *other)
	Removes an entry to other from the link table of this actor.

Related Symbols
(Note that these are not member symbols.)
using	connection_handler
	Denotes a minimal "client" broker managing one or more connection handles by reacting to new_data_msg and connection_closed_msg.
using	accept_handler
	Denotes a minimal "server" broker managing one or more accept handles by reacting to new_connection_msg and acceptor_closed_msg.
Related Symbols inherited from caf::local_actor
constexpr keep_behavior_t	keep_behavior = keep_behavior_t{}
	Policy tag that causes event_based_actor::become to keep the current behavior available.
Related Symbols inherited from caf::abstract_actor
using	actor_id = uint64_t
	A unique actor ID.

Additional Inherited Members
Protected Attributes inherited from caf::local_actor
scheduler *	context_
mailbox_element *	current_element_
message_id	last_request_id_
detail::unique_function< behavior(local_actor *)>	initial_behavior_fac_
	Factory function for returning initial behavior in function-based actors.
metrics_t	metrics_
Protected Attributes inherited from caf::abstract_actor
std::atomic< int >	flags_
	Holds several state and type flags.
std::mutex	mtx_
	Guards members that may be subject to concurrent access .
std::condition_variable	cv_
	Allows blocking actors to actively wait for incoming messages.
error	fail_state_
	Stores the user-defined exit reason if this actor has finished execution.
attachable_ptr	attachables_head_
	Points to the first attachable in the linked list of attachables (if any).

Detailed Description

template<class... Sigs>
class caf::io::typed_broker< Sigs >

A typed broker mediates between actor systems and other components in the network.

Member Typedef Documentation

super

template<class... Sigs>

using caf::io::typed_broker< Sigs >::super

Initial value:

 
    typename extend<abstract_broker, typed_broker<Sigs...>>::template with<
      mixin::sender, mixin::requester>

Member Function Documentation

become()

template<class... Sigs>

template<class T , class... Ts>

void caf::io::typed_broker< Sigs >::become	(	T &&	arg,
		Ts &&...	args )

Changes the behavior of this actor.

unbecome()

template<class... Sigs>

void caf::io::typed_broker< Sigs >::unbecome

(

)

Removes the last added behavior.

Terminates the actor if there are no behaviors left.

Friends And Related Symbol Documentation

accept_handler

template<class... Sigs>

using accept_handler

related

Initial value:

 typed_actor<result<void>(new_connection_msg),
                                   result<void>(acceptor_closed_msg)>

Denotes a minimal "server" broker managing one or more accept handles by reacting to new_connection_msg and acceptor_closed_msg.

The accept handler usually calls self->fork(...) when receiving a new_connection_msg.

connection_handler

template<class... Sigs>

using connection_handler

related

Initial value:

 typed_actor<result<void>(new_data_msg),
                                       result<void>(connection_closed_msg)>

Denotes a minimal "client" broker managing one or more connection handles by reacting to new_data_msg and connection_closed_msg.

---

The documentation for this class was generated from the following files:

• libcaf_core/caf/fwd.hpp
• libcaf_core/caf/infer_handle.hpp
• libcaf_io/caf/io/fwd.hpp
• libcaf_io/caf/io/typed_broker.hpp