Namespace containing public Tamer classes and functions for the Tamer core. More...

Classes
class	event
	A future occurrence. More...
class	rendezvous
	A set of watched events. More...
class	tamed_class

Enumerations
enum	init_flags { init_tamer = 1 , init_libevent = 2 , init_libev = 4 , init_sigpipe = 0x1000 , init_strict = 0x2000 , init_no_epoll = 0x4000 }
enum	time_type_t { time_normal , time_virtual }
enum	websocket_opcode { WEBSOCKET_CONTINUATION = 0 , WEBSOCKET_TEXT = 1 , WEBSOCKET_BINARY = 2 , WEBSOCKET_CLOSE = 8 , WEBSOCKET_PING = 9 , WEBSOCKET_PONG = 10 }
enum	loop_flags { loop_default = 0 , loop_forever = 0 , loop_once = 1 }
enum	signal_flags { signal_default = 0 , signal_background = 1 }
enum	fd_actions { fd_read = 0 , fd_write = 1 , fd_hangup = 2 , nfdactions = 3 }

Functions
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	operator+ (event< T0, T1, T2, T3 > e1, event< T0, T1, T2, T3 > e2)
	Create event that triggers e1 and e2 when triggered.
template<typename R, typename T0>
event< T0 >	operator+ (event< T0 > e1, preevent< R, T0 > &&e2)
template<typename R, typename T0>
event< T0 >	operator+ (preevent< R, T0 > &&e1, event< T0 > e2)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	all (event< T0, T1, T2, T3 > e1, event< T0, T1, T2, T3 > e2)
	Create event that triggers e1 and e2 when triggered.
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	all (event< T0, T1, T2, T3 > e1, event< T0, T1, T2, T3 > e2, event< T0, T1, T2, T3 > e3)
	Create event that triggers e1, e2, and e3 when triggered.
template<typename R, typename T0>
event< T0 >	all (event< T0 > e1, preevent< R, T0 > &&e2)
template<typename R, typename T0>
event< T0 >	all (preevent< R, T0 > &&e1, event< T0 > e2)
template<size_t I = 0, typename VI = void, typename... TS>
event	bind (event< TS... > e, VI vi)
	Create bound event for e with vi.
template<typename R, typename T0, typename V0>
event	bind (preevent< R, T0 > &&pe, V0 v0)
template<typename... TS>
event< TS... >	rebind (event<> e)
	Create bound event for e.
template<typename T0>
event< T0 >	rebind (event<> e, T0 &s0)
template<typename T0, typename R>
event< T0 >	rebind (preevent< R > &&pe)
template<typename T0, typename R>
event< T0 >	rebind (preevent< R > &&pe, T0 &s0)
template<typename S0, typename T0, typename F>
event< S0 >	map (event< T0 > e, F f)
	Create an event that triggers another event with a mapped value.
template<typename S0, typename R, typename T0, typename F>
event< S0 >	map (preevent< R, T0 > &&pe, F f)
template<size_t I = 0, typename V = void, typename... TS>
event< TS... >	add_timeout (const timeval &delay, event< TS... > e, V v)
	Add timeout to an event.
template<size_t I = 0, typename V = void, typename... TS>
event< TS... >	add_timeout (double delay, event< TS... > e, V v)
template<size_t I = 0, typename V = void, typename... TS>
event< TS... >	add_timeout_sec (int delay, event< TS... > e, V v)
template<size_t I = 0, typename V = void, typename... TS>
event< TS... >	add_timeout_msec (int delay, event< TS... > e, V v)
template<typename R, typename T0>
event< T0 >	add_timeout (const timeval &delay, preevent< R, T0 > &&pe, T0 v)
template<typename R, typename T0>
event< T0 >	add_timeout (double delay, preevent< R, T0 > &&pe, T0 v)
template<typename R, typename T0>
event< T0 >	add_timeout_sec (int delay, preevent< R, T0 > &&pe, T0 v)
template<typename R, typename T0>
event< T0 >	add_timeout_msec (int delay, preevent< R, T0 > &&pe, T0 v)
template<typename... TS>
event< TS... >	add_timeout (const timeval &delay, event< TS... > e)
	Add timeout to an event.
template<typename... TS>
event< TS... >	add_timeout (double delay, event< TS... > e)
template<typename... TS>
event< TS... >	add_timeout_sec (int delay, event< TS... > e)
template<typename... TS>
event< TS... >	add_timeout_msec (int delay, event< TS... > e)
template<typename T0, typename R>
event< T0 >	add_timeout (const timeval &delay, preevent< R, T0 > &&pe)
template<typename T0, typename R>
event< T0 >	add_timeout (double delay, preevent< R, T0 > &&pe)
template<typename T0, typename R>
event< T0 >	add_timeout_sec (int delay, preevent< R, T0 > &&pe)
template<typename T0, typename R>
event< T0 >	add_timeout_msec (int delay, preevent< R, T0 > &&pe)
template<typename T0>
event< T0 >	add_signal (int signo, event< T0 > e, T0 v)
	Add signal interruption to an event.
template<typename R, typename T0>
event< T0 >	add_signal (int signo, preevent< R, T0 > &&pe, T0 v)
template<typename T0, typename SigInputIterator>
event< T0 >	add_signal (SigInputIterator first, SigInputIterator last, event< T0 > e, T0 v)
	Add signal interruption to an event.
template<typename R, typename T0, typename SigInputIterator>
event< T0 >	add_signal (SigInputIterator first, SigInputIterator last, preevent< R, T0 > &&pe, T0 v)
template<typename T0>
event< T0 >	add_signal (int signo, event< T0 > e)
	Add signal interruption to an event.
template<typename T0, typename R>
event< T0 >	add_signal (int signo, preevent< R, T0 > &&pe)
template<typename T0, typename SigInputIterator>
event< T0 >	add_signal (SigInputIterator first, SigInputIterator last, event< T0 > e)
	Add signal interruption to an event.
template<typename T0, typename R, typename SigInputIterator>
event< T0 >	add_signal (SigInputIterator first, SigInputIterator last, preevent< R, T0 > &&pe)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout (const timeval &delay, event< T0, T1, T2, T3 > e)
	Add silent timeout to an event.
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout (double delay, event< T0, T1, T2, T3 > e)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout_sec (int delay, event< T0, T1, T2, T3 > e)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout_msec (int delay, event< T0, T1, T2, T3 > e)
template<typename R, typename T0>
event< T0 >	with_timeout (const timeval &delay, preevent< R, T0 > &&pe)
template<typename R, typename T0>
event< T0 >	with_timeout (double delay, preevent< R, T0 > &&pe)
template<typename R, typename T0>
event< T0 >	with_timeout_sec (int delay, preevent< R, T0 > &&pe)
template<typename R, typename T0>
event< T0 >	with_timeout_msec (int delay, preevent< R, T0 > &&pe)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_signal (int signo, event< T0, T1, T2, T3 > e)
	Add silent signal interruption to an event.
template<typename R, typename T0>
event< T0 >	with_signal (int signo, preevent< R, T0 > &&pe)
template<typename T0, typename T1, typename T2, typename T3, typename SigInputIterator>
event< T0, T1, T2, T3 >	with_signal (SigInputIterator first, SigInputIterator last, event< T0, T1, T2, T3 > e)
	Add silent signal interruption to an event.
template<typename R, typename T0, typename SigInputIterator>
event< T0 >	with_signal (SigInputIterator first, SigInputIterator last, preevent< R, T0 > &&pe)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout (const timeval &delay, event< T0, T1, T2, T3 > e, int &result)
	Add timeout to an event.
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout (double delay, event< T0, T1, T2, T3 > e, int &result)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout_sec (int delay, event< T0, T1, T2, T3 > e, int &result)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_timeout_msec (int delay, event< T0, T1, T2, T3 > e, int &result)
template<typename R, typename T0>
event< T0 >	with_timeout (const timeval &delay, preevent< R, T0 > &&pe, int &result)
template<typename R, typename T0>
event< T0 >	with_timeout (double delay, preevent< R, T0 > &&pe, int &result)
template<typename R, typename T0>
event< T0 >	with_timeout_sec (int delay, preevent< R, T0 > &&pe, int &result)
template<typename R, typename T0>
event< T0 >	with_timeout_msec (int delay, preevent< R, T0 > &&pe, int &result)
template<typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	with_signal (int signo, event< T0, T1, T2, T3 > e, int &result)
	Add signal interruption to an event.
template<typename R, typename T0>
event< T0 >	with_signal (int signo, preevent< R, T0 > &&pe, int &result)
template<typename T0, typename T1, typename T2, typename T3, typename SigInputIterator>
event< T0, T1, T2, T3 >	with_signal (SigInputIterator first, SigInputIterator last, event< T0, T1, T2, T3 > e, int &result)
	Add signal interruption to an event.
template<typename R, typename T0, typename SigInputIterator>
event< T0 >	with_signal (SigInputIterator first, SigInputIterator last, preevent< R, T0 > &&pe, int &result)
template<typename F>
event	fun_event (F f)
	Create event that calls a function when triggered.
template<typename F, typename A>
event	fun_event (F f, A arg)
	Create event that calls a function when triggered.
template<typename F, typename A1, typename A2>
event	fun_event (F f, A1 arg1, A2 arg2)
	Create event that calls a function when triggered.
template<typename C>
event< typename C::value_type >	push_back_event (C &container)
template<typename It>
event< typename std::iterator_traits< It >::value_type >	output_event (It &iterator)
void	gethostbyname (std::string name, bool search, event< dns::reply > result)
void	gethostbyaddr (struct in_addr *in, event< dns::reply > result)
bool	initialize (int flags=0)
	Initialize the Tamer event loop.
void	cleanup ()
	Clean up the Tamer event loop.
void	set_time_type (time_type_t tt)
const timeval &	recent ()
	Return a recent snapshot of the current time.
void	set_recent ()
	Sets Tamer's current time to the current timestamp.
double	dtime (const timeval tv)
	Translate a time to a double.
double	dnow ()
	Return the current time as a double.
double	drecent ()
	Return a recent snapshot of the current time as a double.
void	loop (loop_flags flags)
	Run driver loop according to flags.
void	loop ()
	Run driver loop indefinitely.
void	once ()
	Run driver loop once.
void	break_loop ()
	Exit the current driver loop.
void	at_fd_read (int fd, event<> e)
	Register event for file descriptor readability.
void	at_fd_read (int fd, event< int > e)
void	at_fd_write (int fd, event<> e)
	Register event for file descriptor writability.
void	at_fd_write (int fd, event< int > e)
void	at_fd_shutdown (int fd, event<> e)
	Register event for file descriptor shutdown.
void	at_time (const timeval &expiry, event<> e, bool bg=false)
	Register event for a given time.
void	at_time (double expiry, event<> e, bool bg=false)
void	at_delay (const timeval &delay, event<> e, bool bg=false)
	Register event for a given delay.
void	at_delay (double delay, event<> e, bool bg=false)
	Register event for a given delay.
void	at_delay_sec (int delay, event<> e, bool bg=false)
	Register event for a given delay.
void	at_delay_msec (int delay, event<> e, bool bg=false)
	Register event for a given delay.
void	at_delay_usec (int delay, event<> e, bool bg=false)
	Register event for a given delay.
void	at_signal (int signo, event<> e)
	Register event for signal occurrence.
void	at_asap (event<> e)
	Register event to trigger soon.
void	at_preblock (event<> e)
	Register event to trigger before Tamer blocks.
template<typename R, typename I, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_event (one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0, T1 &x1, T2 &x2, T3 &x3)
	Construct a four-result event on rendezvous r with ID eid.
template<typename R, typename I, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_event (one_argument_rendezvous_tag< R > &r, const I &eid, typename event< T0, T1, T2, T3 >::results_tuple_type &xs)
template<typename R, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_event (zero_argument_rendezvous_tag< R > &r, T0 &x0, T1 &x1, T2 &x2, T3 &x3)
template<typename R, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_event (zero_argument_rendezvous_tag< R > &r, typename event< T0, T1, T2, T3 >::results_tuple_type &xs)
template<typename R, typename I, typename T0, typename T1, typename T2>
event< T0, T1, T2 >	make_event (one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0, T1 &x1, T2 &x2)
template<typename R, typename T0, typename T1, typename T2>
event< T0, T1, T2 >	make_event (zero_argument_rendezvous_tag< R > &r, T0 &x0, T1 &x1, T2 &x2)
template<typename R, typename I, typename T0, typename T1>
event< T0, T1 >	make_event (one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0, T1 &x1)
template<typename R, typename T0, typename T1>
event< T0, T1 >	make_event (zero_argument_rendezvous_tag< R > &r, T0 &x0, T1 &x1)
template<typename R, typename I, typename T0>
event< T0 >	make_event (one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0)
template<typename R, typename T0>
event< T0 >	make_event (zero_argument_rendezvous_tag< R > &r, T0 &x0)
template<typename R, typename T0>
preevent< R, T0 >	make_event (zero_argument_rendezvous_tag< R > &r, T0 &x0)
template<typename R, typename T0>
preevent< R, T0 >	make_preevent (zero_argument_rendezvous_tag< R > &r, T0 &x0)
template<typename R, typename I>
event	make_event (one_argument_rendezvous_tag< R > &r, const I &eid)
template<typename R>
event	make_event (zero_argument_rendezvous_tag< R > &r)
template<typename R>
preevent< R >	make_event (zero_argument_rendezvous_tag< R > &r)
template<typename R>
preevent< R >	make_preevent (zero_argument_rendezvous_tag< R > &r)
template<typename R, typename I, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0, T1 &x1, T2 &x2, T3 &x3)
template<typename R, typename I, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, typename event< T0, T1, T2, T3 >::results_tuple_type &xs)
template<typename R, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, T0 &x0, T1 &x1, T2 &x2, T3 &x3)
template<typename R, typename T0, typename T1, typename T2, typename T3>
event< T0, T1, T2, T3 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, typename event< T0, T1, T2, T3 >::results_tuple_type &xs)
template<typename R, typename I, typename T0, typename T1, typename T2>
event< T0, T1, T2 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0, T1 &x1, T2 &x2)
template<typename R, typename I, typename T0, typename T1, typename T2>
event< T0, T1, T2 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, typename event< T0, T1, T2 >::results_tuple_type &xs)
template<typename R, typename T0, typename T1, typename T2>
event< T0, T1, T2 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, T0 &x0, T1 &x1, T2 &x2)
template<typename R, typename T0, typename T1, typename T2>
event< T0, T1, T2 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, typename event< T0, T1, T2 >::results_tuple_type &xs)
template<typename R, typename I, typename T0, typename T1>
event< T0, T1 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0, T1 &x1)
template<typename R, typename I, typename T0, typename T1>
event< T0, T1 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, typename event< T0, T1 >::results_tuple_type &xs)
template<typename R, typename T0, typename T1>
event< T0, T1 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, T0 &x0, T1 &x1)
template<typename R, typename T0, typename T1>
event< T0, T1 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, typename event< T0, T1 >::results_tuple_type &xs)
template<typename R, typename I, typename T0>
event< T0 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, T0 &x0)
template<typename R, typename I, typename T0>
event< T0 >	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, std::tuple< T0 > &xs)
template<typename R, typename T0>
event< T0 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, T0 &x0)
template<typename R, typename T0>
event< T0 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, std::tuple< T0 > &xs)
template<typename R, typename T0>
preevent< R, T0 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, T0 &x0)
template<typename R, typename T0>
preevent< T0 >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, std::tuple< T0 > &xs)
template<typename R, typename T0>
preevent< R, T0 >	make_annotated_preevent (const char *file, int line, zero_argument_rendezvous_tag< R > &r, T0 &x0)
template<typename R, typename T0>
preevent< R, T0 >	make_annotated_preevent (const char *file, int line, zero_argument_rendezvous_tag< R > &r, std::tuple< T0 > &xs)
template<typename R, typename I>
event	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid)
template<typename R, typename I>
event	make_annotated_event (const char *file, int line, one_argument_rendezvous_tag< R > &r, const I &eid, typename event<>::results_tuple_type &xs)
template<typename R>
event	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r)
template<typename R>
event	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, typename event<>::results_tuple_type &xs)
template<typename R>
preevent< R >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r)
template<typename R>
preevent< R >	make_annotated_event (const char *file, int line, zero_argument_rendezvous_tag< R > &r, typename event<>::results_tuple_type &xs)
template<typename R>
preevent< R >	make_annotated_preevent (const char *file, int line, zero_argument_rendezvous_tag< R > &r)
template<typename R>
event	make_annotated_preevent (const char *file, int line, zero_argument_rendezvous_tag< R > &r, typename event<>::results_tuple_type &xs)
template<typename T0, typename T1>
event< T0, T1 >	operator+ (event< T0, T1 > a, event< T0, T1 > b)
fd	tcp_listen (int port)
	Open a nonblocking TCP connection on port port.
fd	tcp_listen (int port, int backlog)
void	tcp_listen (int port, event< fd > result)
	Open a nonblocking TCP connection on port port.
void	tcp_listen (int port, int backlog, event< fd > result)
	Open a nonblocking TCP connection on port port.
void	tcp_connect (struct in_addr addr, int port, event< fd > result)
void	tcp_connect (int port, event< fd > result)
void	udp_connect (struct in_addr addr, int port, event< fd > result)
fd	unix_stream_listen (std::string path, int backlog)
fd	unix_stream_listen (std::string path)
void	unix_stream_connect (std::string path, event< fd > result)
pid_t	exec (std::vector< exec_fd > &exec_fds, const char program, bool path, const std::vector< const char > &argv, char *const envp[])
pid_t	execv (fd &in, fd &out, const char program, const std::vector< const char > &argv)
pid_t	execv (fd &in, fd &out, fd &err, const char program, const std::vector< const char > &argv)
pid_t	execvp (fd &in, fd &out, const char program, const std::vector< const char > &argv)
pid_t	execvp (fd &in, fd &out, fd &err, const char program, const std::vector< const char > &argv)
bool	operator== (const fd &a, const fd &b)
	Test whether two file descriptors refer to the same object.
bool	operator!= (const fd &a, const fd &b)
	Test whether two file descriptors refer to the same object.
template<typename T, typename U>
bool	operator== (const ref_ptr< T > &a, const ref_ptr< T > &b)
template<typename T, typename U>
bool	operator!= (const ref_ptr< T > &a, const ref_ptr< T > &b)
template<typename T, typename U>
bool	operator== (const passive_ref_ptr< T > &a, const passive_ref_ptr< T > &b)
template<typename T, typename U>
bool	operator!= (const passive_ref_ptr< T > &a, const passive_ref_ptr< T > &b)
timeval	now ()

Detailed Description

Namespace containing public Tamer classes and functions for the Tamer core.

Function Documentation

◆ operator+()

template<typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::operator+	(	event< T0, T1, T2, T3 >	e1,
		event< T0, T1, T2, T3 >	e2 )

inline

Create event that triggers e1 and e2 when triggered.

Parameters

e1	First event.
e2	Second event.

Returns: Combination event.

Triggering the returned event instantly triggers e1 and e2 with the same values. The returned event is automatically triggered if e1 and e2 are both triggered separately.

◆ all() [1/2]

template<typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::all	(	event< T0, T1, T2, T3 >	e1,
		event< T0, T1, T2, T3 >	e2 )

inline

Create event that triggers e1 and e2 when triggered.

Parameters

e1	First event.
e2	Second event.

Returns: Combination event.

Triggering the returned event instantly triggers e1 and e2 with the same values. The returned event is automatically triggered if e1 and e2 are both triggered separately.

◆ all() [2/2]

template<typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::all	(	event< T0, T1, T2, T3 >	e1,
		event< T0, T1, T2, T3 >	e2,
		event< T0, T1, T2, T3 >	e3 )

inline

Create event that triggers e1, e2, and e3 when triggered.

Parameters

e1	First event.
e2	Second event.
e3	Third event.

Returns: Combination event.

Equivalent to all(all(e1, e2), e3).

◆ bind()

template<size_t I = 0, typename VI = void, typename... TS>

event tamer::bind	(	event< TS... >	e,
		VI	vi )

Create bound event for e with vi.

Parameters

e	Event.
vi	Trigger value.

Returns: Adapter event.

The result is bound to e: triggering either event automatically triggers the other. Triggering the result instantly triggers e with value vi in its Ith slot; triggering e instantly triggers the result's unblocker.

Referenced by add_signal(), add_signal(), and add_timeout().

◆ rebind()

template<typename... TS>

event< TS... > tamer::rebind ( event<> e )

inline

Create bound event for e.

Parameters

e Event.

Returns: Adapter event.

The result is bound to e: triggering either event automatically triggers the other. Triggering the result instantly triggers e. (The result's T0 trigger value is ignored.) Triggering e instantly triggers the result's unblocker.

◆ map()

template<typename S0, typename T0, typename F>

event< S0 > tamer::map	(	event< T0 >	e,
		F	f )

Create an event that triggers another event with a mapped value.

Parameters

e	Destination event taking T0 values.
f	Map function taking S0 values to T0 values.

Returns: Adapter event taking S0 values.

Triggering the returned event with some value v0 of type S0 instantly triggers e with value f(v0). (This value should have type T0.) Triggering the returned event's unblocker instantly triggers e's unblocker (the map function is not called since no value was provided). If e is triggered directly, then the returned event's unblocker is triggered.

References tamer::event< T0, T1, T2, T3 >::at_trigger(), and tamer::event< T0, T1, T2, T3 >::unblocker().

◆ add_timeout() [1/2]

template<size_t I = 0, typename V = void, typename... TS>

event< TS... > tamer::add_timeout	(	const timeval &	delay,
		event< TS... >	e,
		V	v )

inline

Add timeout to an event.

Parameters

delay	Timeout duration.
e	Event.
v	Timeout trigger value.

Returns: e.

Adds a timeout to e. If delay time passes before e triggers naturally, then e is triggered with value v.

Note: Versions of this function exist for delay values of types timeval, double, and under the names add_timeout_sec() and add_timeout_msec(), int numbers of seconds and milliseconds, respectively.

References at_delay(), and bind().

◆ add_timeout() [2/2]

template<typename... TS>

event< TS... > tamer::add_timeout	(	const timeval &	delay,
		event< TS... >	e )

inline

Add timeout to an event.

Parameters

delay	Timeout duration.
e	Event.

Returns: e.

Adds a timeout to e. If delay time passes before e triggers naturally, then e is unblocked (triggered without a value).

Note: Versions of this function exist for delay values of types timeval, double, and under the names add_timeout_sec() and add_timeout_msec(), int numbers of seconds and milliseconds, respectively.

References at_delay(), and tamer::event< T0, T1, T2, T3 >::unblocker().

◆ add_signal() [1/4]

template<typename T0>

event< T0 > tamer::add_signal	(	int	signo,
		event< T0 >	e,
		T0	v )

inline

Add signal interruption to an event.

Parameters

signo	Signal number.
e	Event.
v	Signal trigger value.

Returns: e.

Adds signal interruption to e. If signal signo occurs before e triggers naturally, then e is triggered with value v.

References at_signal(), and bind().

◆ add_signal() [2/4]

template<typename T0, typename SigInputIterator>

event< T0 > tamer::add_signal	(	SigInputIterator	first,
		SigInputIterator	last,
		event< T0 >	e,
		T0	v )

inline

Add signal interruption to an event.

Parameters

first	Input iterator for start of signal collection.
last	Input iterator for end of signal collection.
e	Event.
v	Signal trigger value.

Returns: e.

Adds signal interruption to e. If any of the signals in [first, last) occur before e triggers naturally, then e is triggered with value v.

References at_signal(), and bind().

◆ add_signal() [3/4]

template<typename T0>

event< T0 > tamer::add_signal	(	int	signo,
		event< T0 >	e )

inline

Add signal interruption to an event.

Parameters

signo	Signal number.
e	Event.

Returns: e.

Adds signal interruption to e. If signal signo occurs before e triggers naturally, then e is unblocked (triggered without a value).

References at_signal(), and tamer::event< T0, T1, T2, T3 >::unblocker().

◆ add_signal() [4/4]

template<typename T0, typename SigInputIterator>

event< T0 > tamer::add_signal	(	SigInputIterator	first,
		SigInputIterator	last,
		event< T0 >	e )

inline

Add signal interruption to an event.

Parameters

first	Input iterator for start of signal collection.
last	Input iterator for end of signal collection.
e	Event.

Returns: e.

Adds signal interruption to e. If any of the signals in [first, last) occur before e triggers naturally, then e is unblocked (triggered without a value).

References at_signal().

◆ with_timeout() [1/2]

template<typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::with_timeout	(	const timeval &	delay,
		event< T0, T1, T2, T3 >	e )

inline

Add silent timeout to an event.

Parameters

delay	Timeout duration.
e	Event.

Returns: e.

Adds a timeout to e. If delay passes before e triggers naturally, then e is unblocked (triggered without a value).

Note: Versions of this function exist for delay values of types timeval, double, and under the names with_timeout_sec() and with_timeout_msec(), int numbers of seconds and milliseconds, respectively.

References at_delay(), and tamer::event< T0, T1, T2, T3 >::unblocker().

◆ with_signal() [1/4]

template<typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::with_signal	(	int	signo,
		event< T0, T1, T2, T3 >	e )

inline

Add silent signal interruption to an event.

Parameters

signo	Signal number.
e	Event.

Returns: e.

Adds signal interruption to e. If signal signo occurs before e triggers naturally, then e is unblocked (triggered without a value).

References at_signal(), and tamer::event< T0, T1, T2, T3 >::unblocker().

◆ with_signal() [2/4]

template<typename T0, typename T1, typename T2, typename T3, typename SigInputIterator>

event< T0, T1, T2, T3 > tamer::with_signal	(	SigInputIterator	first,
		SigInputIterator	last,
		event< T0, T1, T2, T3 >	e )

inline

Add silent signal interruption to an event.

Parameters

first	Input iterator for start of signal collection.
last	Input iterator for end of signal collection.
e	Event.

Returns: e.

Adds signal interruption to e. If a signal in [first, last) occurs before e triggers naturally, then e is unblocked (triggered without a value).

References at_signal(), and tamer::event< T0, T1, T2, T3 >::unblocker().

◆ with_timeout() [2/2]

template<typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::with_timeout	(	const timeval &	delay,
		event< T0, T1, T2, T3 >	e,
		int &	result )

inline

Add timeout to an event.

Parameters

	delay	Timeout duration.
	e	Event.
[out]	result	Result tracker.

Returns: e.

Adds a timeout to e. If e triggers naturally before delay time passes, then result is set to 0. Otherwise, e is unblocked (triggered without a value), and result is set to -ETIMEDOUT.

Note: Versions of this function exist for delay values of types timeval, double, and under the names with_timeout_sec() and with_timeout_msec(), int numbers of seconds and milliseconds, respectively.

References at_delay().

◆ with_signal() [3/4]

template<typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::with_signal	(	int	signo,
		event< T0, T1, T2, T3 >	e,
		int &	result )

inline

Add signal interruption to an event.

Parameters

	signo	Signal number.
	e	Event.
[out]	result	Result tracker.

Returns: e.

Adds signal interruption to e. If e triggers naturally before signal signo occurs, then result is set to 0. Otherwise, e is unblocked (triggered without a value), and result is set to -EINTR.

References at_signal().

◆ with_signal() [4/4]

template<typename T0, typename T1, typename T2, typename T3, typename SigInputIterator>

event< T0, T1, T2, T3 > tamer::with_signal	(	SigInputIterator	first,
		SigInputIterator	last,
		event< T0, T1, T2, T3 >	e,
		int &	result )

inline

Add signal interruption to an event.

Parameters

	first	Input iterator for start of signal collection.
	last	Input iterator for end of signal collection.
	e	Event.
[out]	result	Result tracker.

Returns: Adapter event.

Adds signal interruption to e. If e triggers naturally before a signal in [first, last) occurs, then result is set to 0. Otherwise, e is unblocked (triggered without a value), and result is set to -EINTR.

References at_signal().

◆ fun_event() [1/3]

template<typename F>

event tamer::fun_event ( F f )

inline

Create event that calls a function when triggered.

Parameters

f	Function object.

Returns an event that calls (a copy of) f() when triggered. The call happens immediately, at trigger time.

Note: f must have a public move constructor and a public destructor.

References make_event().

◆ fun_event() [2/3]

template<typename F, typename A>

event tamer::fun_event	(	F	f,
		A	arg )

inline

Create event that calls a function when triggered.

Parameters

f	Function object.
arg	Argument.

Returns an event that calls f(arg) when triggered. The call happens immediately, at trigger time.

Note: f must have a public copy constructor and a public destructor.

◆ fun_event() [3/3]

template<typename F, typename A1, typename A2>

event tamer::fun_event	(	F	f,
		A1	arg1,
		A2	arg2 )

inline

Create event that calls a function when triggered.

Parameters

f	Function object.
arg1	First argument.
arg2	Second argument.

Returns an event that calls f(arg1, arg2) when triggered. The call happens immediately, at trigger time.

Note: f must have a public copy constructor and a public destructor.

◆ initialize()

bool tamer::initialize ( int flags = 0 )

Initialize the Tamer event loop.

Parameters

flags Initialization flags, taken from init_flags.

Call tamer::initialize at least once before registering any primitive Tamer events. The flags argument may contain one or more constants to request a specific driver (init_tamer, init_libevent, or init_libev).

By default Tamer ignores the SIGPIPE signal, which is generally what event-driven programs want. Add init_sigpipe to flags if you want to turn off this behavior.

◆ cleanup()

void tamer::cleanup ( )

Clean up the Tamer event loop.

Delete the driver. Should not be called unless all Tamer objects are deleted.

◆ at_fd_read()

void tamer::at_fd_read	(	int	fd,
		event<>	e )

inline

Register event for file descriptor readability.

Parameters

fd	File descriptor.
e	Event.

Triggers e when fd becomes readable. Cancels e when fd is closed.

◆ at_fd_write()

void tamer::at_fd_write	(	int	fd,
		event<>	e )

inline

Register event for file descriptor writability.

Parameters

fd	File descriptor.
e	Event.

Triggers e when fd becomes writable. Cancels e when fd is closed.

◆ at_fd_shutdown()

void tamer::at_fd_shutdown	(	int	fd,
		event<>	e )

inline

Register event for file descriptor shutdown.

Parameters

fd	File descriptor.
e	Event.

Triggers e when fd is shut down or closed.

◆ at_time() [1/2]

void tamer::at_time	(	const timeval &	expiry,
		event<>	e,
		bool	bg = false )

inline

Register event for a given time.

Parameters

expiry	Time.
e	Event.
bg	Background status.

Triggers e at timestamp expiry, or soon afterwards.

Most timers use foreground events: a call to driver::loop() remains alive as long as the timer is outstanding. Background events, requested by bg true, correspond to background tasks that should be foregone once all foreground events are done.

◆ at_time() [2/2]

void tamer::at_time	(	double	expiry,
		event<>	e,
		bool	bg = false )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ at_delay() [1/2]

void tamer::at_delay	(	const timeval &	delay,
		event<>	e,
		bool	bg = false )

inline

Register event for a given delay.

Parameters

delay	Delay time.
e	Event.
bg	Background status.

Triggers e when delay seconds have elapsed since recent(), or soon afterwards.

Referenced by add_timeout(), add_timeout(), with_timeout(), and with_timeout().

◆ at_delay() [2/2]

void tamer::at_delay	(	double	delay,
		event<>	e,
		bool	bg = false )

inline

Register event for a given delay.

Parameters

delay	Delay time.
e	Event.
bg	Background status.

Triggers e when delay seconds have elapsed since recent(), or soon afterwards.

◆ at_delay_sec()

void tamer::at_delay_sec	(	int	delay,
		event<>	e,
		bool	bg = false )

inline

Register event for a given delay.

Parameters

delay	Delay time.
e	Event.
bg	Background status.

Triggers e when delay seconds have elapsed since recent(), or soon afterwards.

◆ at_delay_msec()

void tamer::at_delay_msec	(	int	delay,
		event<>	e,
		bool	bg = false )

inline

Register event for a given delay.

Parameters

delay	Delay time in milliseconds.
e	Event.
bg	Background status.

Triggers e when delay milliseconds have elapsed since recent(), or soon afterwards.

◆ at_delay_usec()

void tamer::at_delay_usec	(	int	delay,
		event<>	e,
		bool	bg = false )

inline

Register event for a given delay.

Parameters

delay	Delay time in microseconds.
e	Event.
bg	Background status.

Triggers e when delay microseconds have elapsed since recent(), or soon afterwards.

◆ at_signal()

void tamer::at_signal	(	int	signo,
		event<>	e )

inline

Register event for signal occurrence.

Parameters

signo	Signal number.
e	Event.

Triggers e soon after signo is received. The signal signo is blocked while e is triggered and unblocked afterwards.

Referenced by add_signal(), add_signal(), add_signal(), add_signal(), with_signal(), with_signal(), with_signal(), and with_signal().

◆ at_asap()

void tamer::at_asap ( event<> e )

inline

Register event to trigger soon.

Parameters

e Event.

Triggers e the next time through the driver loop.

◆ at_preblock()

void tamer::at_preblock ( event<> e )

inline

Register event to trigger before Tamer blocks.

Parameters

e Event.

Triggers e (and runs its closure) before the next blocking point.

◆ make_annotated_event()

template<typename R, typename I, typename T0, typename T1, typename T2, typename T3>

event< T0, T1, T2, T3 > tamer::make_annotated_event	(	const char *	file,
		int	line,
		one_argument_rendezvous_tag< R > &	r,
		const I &	eid,
		T0 &	x0,
		T1 &	x1,
		T2 &	x2,
		T3 &	x3 )

inline

never

References tamer::event< T0, T1, T2, T3 >::event().

◆ tcp_listen() [1/3]

fd tamer::tcp_listen ( int port )

inline

Open a nonblocking TCP connection on port port.

Parameters

port	Listening port (in host byte order).

Returns: File descriptor.

Equivalent to tcp_listen(port, fd::default_backlog).

References tcp_listen().

Referenced by tcp_listen(), tcp_listen(), and tcp_listen().

◆ tcp_listen() [2/3]

void tamer::tcp_listen	(	int	port,
		event< fd >	result )

inline

Open a nonblocking TCP connection on port port.

Parameters

port	Listening port (in host byte order).
result	Event triggered on completion.

Equivalent to tcp_listen(port, fd::default_backlog, result).

References tcp_listen().

◆ tcp_listen() [3/3]

void tamer::tcp_listen	(	int	port,
		int	backlog,
		event< fd >	result )

inline

Open a nonblocking TCP connection on port port.

Parameters

port	Listening port (in host byte order).
backlog	Maximum connection backlog.
result	Event triggered on completion.

Returns the new listening file descriptor via the result event. The returned file descriptor is made nonblocking, and is opened with the SO_REUSEADDR option. To check whether the function succeeded, use valid() or error() on the resulting file descriptor.

References tcp_listen(), and tamer::event< T0, T1, T2, T3 >::trigger().

◆ operator==()

bool tamer::operator==	(	const fd &	a,
		const fd &	b )

inline

Test whether two file descriptors refer to the same object.

Parameters

a	First file descriptor.
b	Second file descriptor.

Returns: True iff a and b refer to the same file descriptor.

References operator==().

Referenced by operator==().

◆ operator!=()

bool tamer::operator!=	(	const fd &	a,
		const fd &	b )

inline

Test whether two file descriptors refer to the same object.

Parameters

a	First file descriptor.
b	Second file descriptor.

Returns: True iff a and b do not refer to the same file descriptor.

References operator!=().

Referenced by operator!=().

Classes

Enumerations

Functions

Detailed Description

Function Documentation

◆ operator+()

◆ all() [1/2]

◆ all() [2/2]

◆ bind()

◆ rebind()

◆ map()

◆ add_timeout() [1/2]

◆ add_timeout() [2/2]

◆ add_signal() [1/4]

◆ add_signal() [2/4]

◆ add_signal() [3/4]

◆ add_signal() [4/4]

◆ with_timeout() [1/2]

◆ with_signal() [1/4]

◆ with_signal() [2/4]

◆ with_timeout() [2/2]

◆ with_signal() [3/4]

◆ with_signal() [4/4]

◆ fun_event() [1/3]

◆ fun_event() [2/3]

◆ fun_event() [3/3]

◆ initialize()

◆ cleanup()

◆ at_fd_read()

◆ at_fd_write()

◆ at_fd_shutdown()

◆ at_time() [1/2]

◆ at_time() [2/2]

◆ at_delay() [1/2]

◆ at_delay() [2/2]

◆ at_delay_sec()

◆ at_delay_msec()

◆ at_delay_usec()

◆ at_signal()

◆ at_asap()

◆ at_preblock()

◆ make_annotated_event()

◆ tcp_listen() [1/3]

◆ tcp_listen() [2/3]

◆ tcp_listen() [3/3]

◆ operator==()

◆ operator!=()