… | |
… | |
9 | |
9 | |
10 | my $w = EV::timer 2, 0, sub { |
10 | my $w = EV::timer 2, 0, sub { |
11 | warn "is called after 2s"; |
11 | warn "is called after 2s"; |
12 | }; |
12 | }; |
13 | |
13 | |
14 | my $w = EV::timer 2, 1, sub { |
14 | my $w = EV::timer 2, 2, sub { |
15 | warn "is called roughly every 2s (repeat = 1)"; |
15 | warn "is called roughly every 2s (repeat = 2)"; |
16 | }; |
16 | }; |
17 | |
17 | |
18 | undef $w; # destroy event watcher again |
18 | undef $w; # destroy event watcher again |
19 | |
19 | |
20 | my $w = EV::periodic 0, 60, 0, sub { |
20 | my $w = EV::periodic 0, 60, 0, sub { |
… | |
… | |
22 | }; |
22 | }; |
23 | |
23 | |
24 | # IO |
24 | # IO |
25 | |
25 | |
26 | my $w = EV::io *STDIN, EV::READ, sub { |
26 | my $w = EV::io *STDIN, EV::READ, sub { |
27 | my ($w, $revents) = @_; # all callbacks get the watcher object and event mask |
27 | my ($w, $revents) = @_; # all callbacks receive the watcher and event mask |
28 | warn "stdin is readable, you entered: ", <STDIN>; |
28 | warn "stdin is readable, you entered: ", <STDIN>; |
29 | }; |
29 | }; |
30 | |
30 | |
31 | # SIGNALS |
31 | # SIGNALS |
32 | |
32 | |
33 | my $w = EV::signal 'QUIT', sub { |
33 | my $w = EV::signal 'QUIT', sub { |
34 | warn "sigquit received\n"; |
34 | warn "sigquit received\n"; |
35 | }; |
35 | }; |
36 | |
36 | |
37 | my $w = EV::signal 3, sub { |
|
|
38 | warn "sigquit received (this is GNU/Linux, right?)\n"; |
|
|
39 | }; |
|
|
40 | |
|
|
41 | # CHILD/PID STATUS CHANGES |
37 | # CHILD/PID STATUS CHANGES |
42 | |
38 | |
43 | my $w = EV::child 666, sub { |
39 | my $w = EV::child 666, sub { |
44 | my ($w, $revents) = @_; |
40 | my ($w, $revents) = @_; |
45 | # my $pid = $w->rpid; |
|
|
46 | my $status = $w->rstatus; |
41 | my $status = $w->rstatus; |
47 | }; |
42 | }; |
48 | |
43 | |
49 | # MAINLOOP |
44 | # MAINLOOP |
50 | EV::loop; # loop until EV::loop_done is called |
45 | EV::loop; # loop until EV::unloop is called or all watchers stop |
51 | EV::loop EV::LOOP_ONESHOT; # block until at least one event could be handled |
46 | EV::loop EV::LOOP_ONESHOT; # block until at least one event could be handled |
52 | EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block |
47 | EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block |
53 | |
48 | |
54 | DESCRIPTION |
49 | DESCRIPTION |
55 | This module provides an interface to libev |
50 | This module provides an interface to libev |
… | |
… | |
75 | Returns an integer describing the backend used by libev |
70 | Returns an integer describing the backend used by libev |
76 | (EV::METHOD_SELECT or EV::METHOD_EPOLL). |
71 | (EV::METHOD_SELECT or EV::METHOD_EPOLL). |
77 | |
72 | |
78 | EV::loop [$flags] |
73 | EV::loop [$flags] |
79 | Begin checking for events and calling callbacks. It returns when a |
74 | Begin checking for events and calling callbacks. It returns when a |
80 | callback calls EV::loop_done. |
75 | callback calls EV::unloop. |
81 | |
76 | |
82 | The $flags argument can be one of the following: |
77 | The $flags argument can be one of the following: |
83 | |
78 | |
84 | 0 as above |
79 | 0 as above |
85 | EV::LOOP_ONESHOT block at most once (wait, but do not loop) |
80 | EV::LOOP_ONESHOT block at most once (wait, but do not loop) |
86 | EV::LOOP_NONBLOCK do not block at all (fetch/handle events but do not wait) |
81 | EV::LOOP_NONBLOCK do not block at all (fetch/handle events but do not wait) |
87 | |
82 | |
88 | EV::loop_done [$how] |
83 | EV::unloop [$how] |
89 | When called with no arguments or an argument of 1, makes the |
84 | When called with no arguments or an argument of EV::UNLOOP_ONE, |
90 | innermost call to EV::loop return. |
85 | makes the innermost call to EV::loop return. |
91 | |
86 | |
92 | When called with an agrument of 2, all calls to EV::loop will return |
87 | When called with an argument of EV::UNLOOP_ALL, all calls to |
93 | as fast as possible. |
88 | EV::loop will return as fast as possible. |
94 | |
89 | |
95 | WATCHER |
90 | WATCHER |
96 | A watcher is an object that gets created to record your interest in some |
91 | A watcher is an object that gets created to record your interest in some |
97 | event. For instance, if you want to wait for STDIN to become readable, |
92 | event. For instance, if you want to wait for STDIN to become readable, |
98 | you would create an EV::io watcher for that: |
93 | you would create an EV::io watcher for that: |
… | |
… | |
207 | Calls the callback after $after seconds. If $repeat is non-zero, the |
202 | Calls the callback after $after seconds. If $repeat is non-zero, the |
208 | timer will be restarted (with the $repeat value as $after) after the |
203 | timer will be restarted (with the $repeat value as $after) after the |
209 | callback returns. |
204 | callback returns. |
210 | |
205 | |
211 | This means that the callback would be called roughly after $after |
206 | This means that the callback would be called roughly after $after |
212 | seconds, and then every $repeat seconds. "Roughly" because the time |
207 | seconds, and then every $repeat seconds. The timer does his best not |
213 | of callback processing is not taken into account, so the timer will |
208 | to drift, but it will not invoke the timer more often then once per |
214 | slowly drift. If that isn't acceptable, look at EV::periodic. |
209 | event loop iteration, and might drift in other cases. If that isn't |
|
|
210 | acceptable, look at EV::periodic, which can provide long-term stable |
|
|
211 | timers. |
215 | |
212 | |
216 | The timer is based on a monotonic clock, that is if somebody is |
213 | The timer is based on a monotonic clock, that is, if somebody is |
217 | sitting in front of the machine while the timer is running and |
214 | sitting in front of the machine while the timer is running and |
218 | changes the system clock, the timer will nevertheless run (roughly) |
215 | changes the system clock, the timer will nevertheless run (roughly) |
219 | the same time. |
216 | the same time. |
220 | |
217 | |
221 | The "timer_ns" variant doesn't start (activate) the newly created |
218 | The "timer_ns" variant doesn't start (activate) the newly created |
… | |
… | |
227 | |
224 | |
228 | $w->again |
225 | $w->again |
229 | Similar to the "start" method, but has special semantics for |
226 | Similar to the "start" method, but has special semantics for |
230 | repeating timers: |
227 | repeating timers: |
231 | |
228 | |
|
|
229 | If the timer is active and non-repeating, it will be stopped. |
|
|
230 | |
232 | If the timer is active and repeating, reset the timeout to occur |
231 | If the timer is active and repeating, reset the timeout to occur |
233 | $repeat seconds after now. |
232 | $repeat seconds after now. |
234 | |
233 | |
235 | If the timer is active and non-repeating, it will be stopped. |
|
|
236 | |
|
|
237 | If the timer is in active and repeating, start it. |
234 | If the timer is inactive and repeating, start it using the repeat |
|
|
235 | value. |
238 | |
236 | |
239 | Otherwise do nothing. |
237 | Otherwise do nothing. |
240 | |
238 | |
241 | This behaviour is useful when you have a timeout for some IO |
239 | This behaviour is useful when you have a timeout for some IO |
242 | operation. You create a timer object with the same value for $after |
240 | operation. You create a timer object with the same value for $after |
… | |
… | |
280 | at the next possible time where "$time = $at (mod $interval)", |
278 | at the next possible time where "$time = $at (mod $interval)", |
281 | regardless of any time jumps. |
279 | regardless of any time jumps. |
282 | |
280 | |
283 | * manual reschedule mode ($reschedule_cb = coderef) |
281 | * manual reschedule mode ($reschedule_cb = coderef) |
284 | In this mode $interval and $at are both being ignored. Instead, |
282 | In this mode $interval and $at are both being ignored. Instead, |
285 | each time the periodic watcher gets scheduled, the first |
283 | each time the periodic watcher gets scheduled, the reschedule |
286 | callback ($reschedule_cb) will be called with the watcher as |
284 | callback ($reschedule_cb) will be called with the watcher as |
287 | first, and the current time as second argument. |
285 | first, and the current time as second argument. |
288 | |
286 | |
289 | *This callback MUST NOT stop or destroy this or any other |
287 | *This callback MUST NOT stop or destroy this or any other |
290 | periodic watcher, ever*. If you need to stop it, return 1e30 and |
288 | periodic watcher, ever*. If you need to stop it, return 1e30 and |