C  | |
| check_init [Ev] | 
check_init f - call a callback when the event loop is about to start
    calling the callbacks after receiving the events
 
 | 
| child_get_pid [Ev] | 
child_get_pid ev - retrieve the pid that is being watched
 
 | 
| child_get_rpid [Ev] | 
child_get_rpid ev - retrieve the pid that issued a status change
 
 | 
| child_get_rstatus [Ev] | 
child_get_status ev - retrieve the status of the child process
 
 | 
| child_init [Ev] | 
child_init f child trace - call a callback when the status of a child
    process changes.
 
 | 
| child_set [Ev] | 
child_set ev child trace - set the child event parameters again
 
 | 
| clear_pending [Ev] | 
clear pending events from an event watcher: return the 
    list if events that were pending
 
 | 
D  | |
| default_exn_handler [Ev] | 
default exception handler; it output diagnostics to stderr and swallows the exception
 
 | 
| default_loop [Ev] | 
access the default loop.
 
 | 
E  | |
| embeddable_backends [Ev] | 
list of backends that may be embedded; embedding not yet supported
 
 | 
F  | |
| fork_init [Ev] | 
fork_init f - call a callback after a fork (and the event loop notices it/is notified about it).
 
 | 
| forked [Ev] | 
forked loop - inform an event loop that we have forked (and we'd like to keep using the libev services)
 
 | 
G  | |
| get_cb [Ev] | 
get_cb ev - retrieves the callback of an event
 
 | 
| get_loop [Ev] | 
raises NoLoop the event is not active
 
 | 
| get_priority [Ev] | 
get_priority ev - retrieve the priority of an event.
 
 | 
I  | |
| idle_init [Ev] | 
idle_init f - call a callback when the event loop has nothing else to do
 
 | 
| invoke [Ev] | 
invoke an event as if it had just been fired.
 
 | 
| io_init [Ev] | 
io_init f fd revents
 
 | 
| is_active [Ev] | 
is_active ev - is this event active? an event is
    active when it has been issued *_start an inactive
    after a *_stop.
 
 | 
| is_default_loop [Ev] | 
is this the default loop?
 
 | 
| is_pending [Ev] | 
is_pending ev - does this even have outstanding events?
 
 | 
L  | |
| loop [Ev] | 
loop l flags - run an event loop
 
 | 
| loop_count [Ev] | 
a monotonic (wrapping) counter that roughly indicates the number of times the
    event loop has iterated
 
 | 
| loop_destroy [Ev] | 
destroy an event loop.
 
 | 
| loop_new [Ev] | 
create a new event loop
 
 | 
| loop_now [Ev] | 
time of day according to the event loop
 
 | 
N  | |
| no_cb [Ev] | 
no_cb ev - a callback that does nothing; could be useful
    as the callback parameter to _init functions.
 
 | 
P  | |
| periodic_get_at [Ev] | 
periodic_get_at ev - retrieve the epoch time when the event
    will be fired the next time
 
 | 
| periodic_init [Ev] | 
periodic_init f periodic_time - call a callback with a certain
    schedule.
 
 | 
| periodic_set [Ev] | 
periodic_set ev periodic_time - set the periodic parameters again
 
 | 
| prepare_init [Ev] | 
prepare_init f - call a callback when the event loop is about to start
    waiting for events
 
 | 
R  | |
| recommended_backends [Ev] | 
list of recommended backends for this host
 
 | 
S  | |
| set_cb [Ev] | 
set_cb ev f - sets the callback of an event
 
 | 
| set_exn_handler [Ev] | 
set_exn_handler loop handler - set the exception handler of an event loop
 
 | 
| set_io_collect_interval [Ev] | 
set_io_collect_interval loop interval - collect io events in
    lumps.
 
 | 
| set_keepalive [Ev] | 
keepalive ev state - set the the significance of this event
    watcher from its loop, when considering whether to exit or not.
 
 | 
| set_priority [Ev] | 
set_priority ev priority - set the priority of an event.
 
 | 
| set_timeout_collect_interval [Ev] | 
set_timeout_collect_interval loop interval - collect timeout events in
    lumps.
 
 | 
| signal_init [Ev] | 
signal_init f signal - call a callback when a certain signal
    is raised.
 
 | 
| start [Ev] | 
start loop ev - attach an event watcher to an event loop (that is, activate it).
 
 | 
| stat_get_attr [Ev] | 
stat_get_attr ev - retrieve the stats of the monitored file
 
 | 
| stat_get_prev [Ev] | 
stat_get_attr ev - retrieve the old stats of the monitored file (befoe the callback)
 
 | 
| stat_init [Ev] | 
stat_init f filename interval - call a callback when the state of a file (as seen by stat) changes
 
 | 
| stat_set [Ev] | 
stat_set filename interval - sets the parameters of the event watcher.
 
 | 
| stop [Ev] | 
stop ev - detach an event watcher from an event loop (thus deactivating it).
 
 | 
| string_of_loop_arg [Ev] | 
convert a loop argument into a human-readable string
 
 | 
| string_of_revent [Ev] | 
convert an revent into a human-readable string
 
 | 
| supported_backends [Ev] | 
list of supported backends
 
 | 
T  | |
| timer_again [Ev] | 
timer_again ev - retrigger the timer to run again after the 
    interval.
 
 | 
| timer_init [Ev] | 
timer_init f offset repeat - call a callback after offset seconds;
    if repeat > 0.0, retrigger the timer to run periodically.
 
 | 
U  | |
| unloop [Ev] | 
unloop l how - run an event loop.
 
 |