Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Net::SIP::Dispatcher::UsertContributed Perl Net::SIP::Dispatcher::Eventloop(3)

NAME
       Net::SIP::Dispatcher::Eventloop - simple	event loop for
       Net::SIP::Dispatcher

SYNOPSIS
	 my $loop = Net::SIP::Dispatcher::Eventloop->new;
	 $loop->addFD( $fd, $callback );
	 $loop->add_timer( 10,$callback	);
	 $loop->loop;

DESCRIPTION
       The package implements a	simple event loop. It's	not optimized for
       speed but it is provided	as a simple implementation in case the users
       application does	not has	an event loop yet.

       Because the eventloop object can	be given in the	constructor of
       Net::SIP::Dispatcher you	might provide an alternative implementation,
       which implemented the described methods.

CONSTRUCTOR
       new Creates new event loop, returns created object

METHODS
       addFD (HANDLE, RW, CALLBACK, [NAME])
	   Adds	file handle HANDLE to the event	loop, so that CALLBACK gets
	   triggered if	HANDLE is readable (RW 0) or writeable (RW 1). Instead
	   of 0	and 1 one can also use the exported constants "EV_READ"	and
	   "EV_WRITE".	CALLBACK is a callback accepted	by invoke_callback in
	   Net::SIP::Util.  The	callback will be invoked with HANDLE as	an
	   additional argument.

	   NAME	can be used to aid debugging, it will be shown in the debug
	   messages once the FD	gets ready.

	   If there was	already	a callback for HANDLE it gets replaced by the
	   new one.

	   IMPORTANT NOTE: CALLBACK gets triggered if HANDLE *is* readable
	   inside the loop, not	if HANDLE *gets* readable. Unlike with
	   Event::Lib or similar the CALLBACK is not triggered by the edge,
	   but by the level (like poll(2) or select(2)). So if 2 bytes come in
	   at the handle and one reads only 1 byte in the callback the
	   callback gets triggered again for more data.	 You have to watch
	   this, if you	want to	integrate Net::SIP with	your existing event
	   loop.

       delFD (HANDLE, [RW])
	   If RW is 0 (EV_READ)	no more	checking for readability of HANDLE
	   will	be done. If RW is 1 (EV_WRITE) no more checking	for
	   writeability	of HANDLE will be done.	 If RW is not given it will
	   remove HANDLE from the loop completely, i.e.	 for both read and
	   write.

       add_timer( WHEN,	CALLBACK, [ REPEAT ] )
	   Adds	timer which gets triggered at WHEN or "now + WHEN". Depending
	   on the value	of WHEN	it gets	interpreted as the number of seconds
	   since 1970-01-01 (when it's really big) or as a relative time (when
	   it's	not that big).	WHEN can be floating point for subseconds
	   resolution.

	   CALLBACK is a callback accepted by invoke_callback in
	   Net::SIP::Util.  It gets invoked with the timer object (see later)
	   as an additional argument, which has	a method cancel	for canceling
	   the (repeating) timer.

	   REPEAT is the number	of seconds between each	invocation of the
	   timer. If greater then 0 (subsection	resolution possible) the
	   callback will be called each	REPEAT seconds,	after it was called
	   the first time at WHEN.

	   The method will return an object which has a	method cancel which
	   can be used to cancel the timer before it gets triggered (or	gets
	   triggered the next time in case of repeating	timers).

       looptime
	   Returns the current loop time in subseconds resolution (using
	   gettimeofday	from Time::HiRes). This	is not the current time, but
	   the time, when the last event in the	loop occurred (e.g. when the
	   select(2) call returned)

       loop ( [	TIMEOUT, @STOPVAR ] )
	   The main loop, e.g. continuiosly checks timers and file handles for
	   the events and calls	callbacks.

	   If TIMEOUT is given it will run the loop for	at most	TIMEOUT
	   seconds, then the method will return. Undefined TIMEOUT means that
	   it will never return	because	of timeout and TIMEOUT of 0 means that
	   it will check all timers and	handles	only once and then return.

	   @STOPVAR is a list of scalar	references. These scalars are expected
	   to be changed from the callbacks, so	it will	check after each loop
	   cycle, e.g.	after all callbacks are	called (timers and handles) if
	   any of these	scalars	is TRUE, in which case it will end the loop.

	   The behavior	with STOPVAR cannot be found in	most existing event
	   loops.  If you want to integrate Net::SIP with your own event loop
	   you might simply wrap all callbacks given in	addFD and add_timer in
	   another callback which at the end checks the	stopvars and
	   terminates the 3rd-party loop in a loop-specific way.

perl v5.32.1			  2021-08-16Net::SIP::Dispatcher::Eventloop(3)

NAME | SYNOPSIS | DESCRIPTION | CONSTRUCTOR | METHODS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Net::SIP::Dispatcher::Eventloop&sektion=3&manpath=FreeBSD+13.1-RELEASE+and+Ports>

home | help