| … | |
… | |
| 2 | |
2 | |
| 3 | AE - simpler/faster/newer/cooler AnyEvent API |
3 | AE - simpler/faster/newer/cooler AnyEvent API |
| 4 | |
4 | |
| 5 | =head1 SYNOPSIS |
5 | =head1 SYNOPSIS |
| 6 | |
6 | |
| 7 | See the L<AnyEvent> manpage for everything there is to say about AE. |
7 | use AnyEvent; # not AE |
|
|
8 | |
|
|
9 | # file handle or descriptor readable |
|
|
10 | my $w = AE::io $fh, 0, sub { ... }; |
|
|
11 | |
|
|
12 | # one-shot or repeating timers |
|
|
13 | my $w = AE::timer $seconds, 0, sub { ... }; # once |
|
|
14 | my $w = AE::timer $seconds, $interval, sub { ... }; # repeated |
|
|
15 | |
|
|
16 | print AE::now; # prints current event loop time |
|
|
17 | print AE::time; # think Time::HiRes::time or simply CORE::time. |
|
|
18 | |
|
|
19 | # POSIX signal |
|
|
20 | my $w = AE::signal TERM => sub { ... }; |
|
|
21 | |
|
|
22 | # child process exit |
|
|
23 | my $w = AE::child $pid, sub { |
|
|
24 | my ($pid, $status) = @_; |
|
|
25 | ... |
|
|
26 | }; |
|
|
27 | |
|
|
28 | # called when event loop idle (if applicable) |
|
|
29 | my $w = AE::idle sub { ... }; |
|
|
30 | |
|
|
31 | my $w = AE::cv; # stores whether a condition was flagged |
|
|
32 | $w->send; # wake up current and all future recv's |
|
|
33 | $w->recv; # enters "main loop" till $condvar gets ->send |
|
|
34 | # use a condvar in callback mode: |
|
|
35 | $w->cb (sub { $_[0]->recv }); |
|
|
36 | |
| 8 | |
37 | |
| 9 | =head1 DESCRIPTION |
38 | =head1 DESCRIPTION |
| 10 | |
39 | |
| 11 | This module implements the new simpler AnyEvent API. There is no |
40 | This module documents the new simpler AnyEvent API. |
| 12 | description of this API here, refer to the L<AnyEvent> module for this. |
|
|
| 13 | |
41 | |
| 14 | The rationale for the new API is that experience with L<EV> shows that |
42 | The rationale for the new API is that experience with L<EV> shows that |
| 15 | this API actually "works", despite it's simplicity. This API is (will be) |
43 | this API actually "works", despite its lack of extensibility, leading to |
| 16 | much faster and also requires less typing. |
44 | a shorter, easier and faster API. |
| 17 | |
45 | |
| 18 | The "old" API is still supported, and there are no plans to "switch". |
46 | The main differences from AnyEvent is that function calls are used |
|
|
47 | instead of method calls, and that no named arguments are used. |
|
|
48 | |
|
|
49 | This makes calls to watcher creation functions really short, which can |
|
|
50 | make a program more readable despite the lack of named parameters. |
|
|
51 | Function calls also allow more static type checking than method calls, so |
|
|
52 | many mistakes are caught at compile-time with this API. |
|
|
53 | |
|
|
54 | Also, some backends (Perl and EV) are so fast that the method call |
|
|
55 | overhead is very noticeable (with EV it increases the execution time five- |
|
|
56 | to six-fold, with Perl the method call overhead is about a factor of two). |
|
|
57 | |
|
|
58 | Note that the C<AE> API is an alternative to, not the future version of, |
|
|
59 | the AnyEvent API. Both APIs can be used interchangeably and there are |
|
|
60 | no plans to "switch", so if in doubt, feel free to use the L<AnyEvent> |
|
|
61 | API in new code. |
|
|
62 | |
|
|
63 | As the AE API is complementary, not everything in the AnyEvent API is |
|
|
64 | available, and you still need to use AnyEvent for the finer stuff. Also, |
|
|
65 | you should not C<use AE> directly, C<use AnyEvent> will provide the AE |
|
|
66 | namespace. |
|
|
67 | |
|
|
68 | At the moment, these functions will become slower then their method-call |
|
|
69 | counterparts when using L<AnyEvent::Strict> or L<AnyEvent::Debug>::wrap. |
|
|
70 | |
|
|
71 | =head2 FUNCTIONS |
|
|
72 | |
|
|
73 | This section briefly describes the alternative watcher |
|
|
74 | constructors. Semantics are not described here; please |
|
|
75 | refer to the L<AnyEvent> manpage for the details. |
|
|
76 | |
|
|
77 | =over 4 |
| 19 | |
78 | |
| 20 | =cut |
79 | =cut |
| 21 | |
80 | |
| 22 | package AE; |
81 | package AE; |
| 23 | |
82 | |
| 24 | use AnyEvent (); # BEGIN { AnyEvent::common_sense } |
83 | use AnyEvent (); # BEGIN { AnyEvent::common_sense } |
| 25 | |
84 | |
| 26 | 1; |
85 | our $VERSION = $AnyEvent::VERSION; |
|
|
86 | |
|
|
87 | =item $w = AE::io $fh_or_fd, $watch_write, $cb |
|
|
88 | |
|
|
89 | Creates an I/O watcher that listens for read events (C<$watch_write> |
|
|
90 | false) or write events (C<$watch_write> is true) on the file handle or |
|
|
91 | file descriptor C<$fh_or_fd>. |
|
|
92 | |
|
|
93 | The callback C<$cb> is invoked as soon and as long as I/O of the type |
|
|
94 | specified by C<$watch_write>) can be done on the file handle/descriptor. |
|
|
95 | |
|
|
96 | Example: wait until STDIN becomes readable. |
|
|
97 | |
|
|
98 | $stdin_ready = AE::io *STDIN, 0, sub { scalar <STDIN> }; |
|
|
99 | |
|
|
100 | Example: wait until STDOUT becomes writable and print something. |
|
|
101 | |
|
|
102 | $stdout_ready = AE::io *STDOUT, 1, sub { print STDOUT "woaw\n" }; |
|
|
103 | |
|
|
104 | =item $w = AE::timer $after, $interval, $cb |
|
|
105 | |
|
|
106 | Creates a timer watcher that invokes the callback C<$cb> after at least |
|
|
107 | C<$after> second have passed (C<$after> can be negative or C<0>). |
|
|
108 | |
|
|
109 | If C<$interval> is C<0>, then the callback will only be invoked once, |
|
|
110 | otherwise it must be a positive number of seconds that specifies the |
|
|
111 | interval between successive invocations of the callback. |
|
|
112 | |
|
|
113 | Example: print "too late" after at least one second has passed. |
|
|
114 | |
|
|
115 | $timer_once = AE::timer 1, 0, sub { print "too late\n" }; |
|
|
116 | |
|
|
117 | Example: print "blubb" once a second, starting as soon as possible. |
|
|
118 | |
|
|
119 | $timer_repeated = AE::timer 0, 1, sub { print "blubb\n" }; |
|
|
120 | |
|
|
121 | =item $w = AE::signal $signame, $cb |
|
|
122 | |
|
|
123 | Invoke the callback C<$cb> each time one or more occurrences of the |
|
|
124 | named signal C<$signame> are detected. |
|
|
125 | |
|
|
126 | =item $w = AE::child $pid, $cb |
|
|
127 | |
|
|
128 | Invokes the callback C<$cb> when the child with the given C<$pid> exits |
|
|
129 | (or all children, when C<$pid> is zero). |
|
|
130 | |
|
|
131 | The callback will get the actual pid and exit status as arguments. |
|
|
132 | |
|
|
133 | =item $w = AE::idle $cb |
|
|
134 | |
|
|
135 | Invoke the callback C<$cb> each time the event loop is "idle" (has no |
|
|
136 | events outstanding), but do not prevent the event loop from polling for |
|
|
137 | more events. |
|
|
138 | |
|
|
139 | =item $cv = AE::cv |
|
|
140 | |
|
|
141 | =item $cv = AE::cv { BLOCK } |
|
|
142 | |
|
|
143 | Create a new condition variable. The first form is identical to C<< |
|
|
144 | AnyEvent->condvar >>, the second form additionally sets the callback (as |
|
|
145 | if the C<cb> method is called on the condition variable). |
|
|
146 | |
|
|
147 | =item AE::now |
|
|
148 | |
|
|
149 | Returns the current event loop time (may be cached by the event loop). |
|
|
150 | |
|
|
151 | =item AE::now_update |
|
|
152 | |
|
|
153 | Ensures that the current event loop time is up to date. |
|
|
154 | |
|
|
155 | =item AE::time |
|
|
156 | |
|
|
157 | Return the current time (not cached, always consults a hardware clock). |
|
|
158 | |
|
|
159 | =item AE::postpone { BLOCK } |
|
|
160 | |
|
|
161 | Exactly the same as C<AnyEvent:::postpone>. |
|
|
162 | |
|
|
163 | =item AE::log $level, $msg[, @args] |
|
|
164 | |
|
|
165 | Exactly the same as C<AnyEvent::log> (or C<AnyEvent::Log::log>). |
|
|
166 | |
|
|
167 | =back |
| 27 | |
168 | |
| 28 | =head1 AUTHOR |
169 | =head1 AUTHOR |
| 29 | |
170 | |
| 30 | Marc Lehmann <schmorp@schmorp.de> |
171 | Marc Lehmann <schmorp@schmorp.de> |
| 31 | http://home.schmorp.de/ |
172 | http://home.schmorp.de/ |
| 32 | |
173 | |
| 33 | =cut |
174 | =cut |
| 34 | |
175 | |
|
|
176 | 1 |
|
|
177 | |
