ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.pm
(Generate patch)

Comparing EV/EV.pm (file contents):
Revision 1.17 by root, Wed Oct 31 21:34:45 2007 UTC vs.
Revision 1.25 by root, Fri Nov 2 22:18:49 2007 UTC

1=head1 NAME 1=head1 NAME
2 2
3EV - perl interface to libevent, monkey.org/~provos/libevent/ 3EV - perl interface to libev, a high performance full-featured event loop
4 4
5=head1 SYNOPSIS 5=head1 SYNOPSIS
6 6
7 use EV; 7 use EV;
8 8
9 # TIMER 9 # TIMERS
10 10
11 my $w = EV::timer 2, 0, sub { 11 my $w = EV::timer 2, 0, sub {
12 warn "is called after 2s"; 12 warn "is called after 2s";
13 }; 13 };
14 14
… …
16 warn "is called roughly every 2s (repeat = 1)"; 16 warn "is called roughly every 2s (repeat = 1)";
17 }; 17 };
18 18
19 undef $w; # destroy event watcher again 19 undef $w; # destroy event watcher again
20 20
21 my $w = EV::timer_abs 0, 60, sub { 21 my $w = EV::periodic 0, 60, sub {
22 warn "is called every minute, on the minute, exactly"; 22 warn "is called every minute, on the minute, exactly";
23 }; 23 };
24 24
25 # IO 25 # IO
26 26
27 my $w = EV::io \*STDIN, EV::READ | EV::PERSIST, sub { 27 my $w = EV::io *STDIN, EV::READ, sub {
28 my ($w, $revents) = @_; # all callbacks get the watcher object and event mask 28 my ($w, $revents) = @_; # all callbacks get the watcher object and event mask
29 if ($revents & EV::TIMEOUT) {
30 warn "nothing received on stdin for 10 seconds, retrying";
31 } else {
32 warn "stdin is readable, you entered: ", <STDIN>; 29 warn "stdin is readable, you entered: ", <STDIN>;
33 }
34 };
35 $w->timeout (10);
36
37 my $w = EV::timed_io \*STDIN, EV::READ, 30, sub {
38 my ($w, $revents) = @_;
39 if ($revents & EV::TIMEOUT) {
40 warn "nothing entered within 30 seconds, bye bye.\n";
41 $w->stop;
42 } else {
43 my $line = <STDIN>;
44 warn "you entered something, you again have 30 seconds.\n";
45 }
46 }; 30 };
47 31
48 # SIGNALS 32 # SIGNALS
49 33
50 my $w = EV::signal 'QUIT', sub { 34 my $w = EV::signal 'QUIT', sub {
… …
60 my $w = EV::child 666, sub { 44 my $w = EV::child 666, sub {
61 my ($w, $revents, $status) = @_; 45 my ($w, $revents, $status) = @_;
62 }; 46 };
63 47
64 # MAINLOOP 48 # MAINLOOP
65 EV::dispatch; # loop as long as watchers are active 49 EV::loop; # loop until EV::loop_done is called
66 EV::loop; # the same thing
67 EV::loop EV::LOOP_ONESHOT; # block until some events could be handles 50 EV::loop EV::LOOP_ONESHOT; # block until at least one event could be handled
68 EV::loop EV::LOOP_NONBLOCK; # check and handle some events, but do not wait 51 EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block
69 52
70=head1 DESCRIPTION 53=head1 DESCRIPTION
71 54
72This module provides an interface to libev 55This module provides an interface to libev
73(L<http://software.schmorp.de/pkg/libev.html>). You probably should 56(L<http://software.schmorp.de/pkg/libev.html>).
74acquaint yourself with its documentation and source code to be able to use
75this module fully.
76 57
77=cut 58=cut
78 59
79package EV; 60package EV;
80 61
81use strict; 62use strict;
82 63
83BEGIN { 64BEGIN {
84 our $VERSION = '0.03'; 65 our $VERSION = '0.5';
85 use XSLoader; 66 use XSLoader;
86 XSLoader::load "EV", $VERSION; 67 XSLoader::load "EV", $VERSION;
87} 68}
88 69
89@EV::Io::ISA = "EV::Watcher"; 70@EV::Io::ISA =
90@EV::Time::ISA = "EV::Watcher";
91@EV::Timer::ISA = "EV::Time"; 71@EV::Timer::ISA =
92@EV::Periodic::ISA = "EV::Time"; 72@EV::Periodic::ISA =
93@EV::Signal::ISA = "EV::Watcher"; 73@EV::Signal::ISA =
94@EV::Idle::ISA = "EV::Watcher"; 74@EV::Idle::ISA =
95@EV::Prepare::ISA = "EV::Watcher"; 75@EV::Prepare::ISA =
96@EV::Check::ISA = "EV::Watcher"; 76@EV::Check::ISA =
97@EV::Child::ISA = "EV::Watcher"; 77@EV::Child::ISA = "EV::Watcher";
98 78
99=head1 BASIC INTERFACE 79=head1 BASIC INTERFACE
100 80
101=over 4 81=over 4
102
103=item $EV::NPRI
104
105How many priority levels are available.
106 82
107=item $EV::DIED 83=item $EV::DIED
108 84
109Must contain a reference to a function that is called when a callback 85Must contain a reference to a function that is called when a callback
110throws an exception (with $@ containing thr error). The default prints an 86throws an exception (with $@ containing thr error). The default prints an
111informative message and continues. 87informative message and continues.
112 88
113If this callback throws an exception it will be silently ignored. 89If this callback throws an exception it will be silently ignored.
114 90
91=item $time = EV::time
92
93Returns the current time in (fractional) seconds since the epoch.
94
115=item $time = EV::now 95=item $time = EV::now
116 96
117Returns the time in (fractional) seconds since the epoch. 97Returns the time the last event loop iteration has been started. This
98is the time that (relative) timers are based on, and refering to it is
99usually faster then calling EV::time.
118 100
119=item $version = EV::version
120
121=item $method = EV::method 101=item $method = EV::ev_method
122 102
123Return version string and event polling method used. 103Returns an integer describing the backend used by libev (EV::METHOD_SELECT
104or EV::METHOD_EPOLL).
124 105
125=item EV::loop $flags # EV::LOOP_ONCE, EV::LOOP_ONESHOT 106=item EV::loop [$flags]
126 107
127=item EV::loopexit $after 108Begin checking for events and calling callbacks. It returns when a
109callback calls EV::loop_done.
128 110
129Exit any active loop or dispatch after C<$after> seconds or immediately if 111The $flags argument can be one of the following:
130C<$after> is missing or zero.
131 112
132=item EV::dispatch 113 0 as above
114 EV::LOOP_ONESHOT block at most once (wait, but do not loop)
115 EV::LOOP_NONBLOCK do not block at all (fetch/handle events but do not wait)
133 116
134Same as C<EV::loop 0>. 117=item EV::loop_done [$how]
135 118
136=item EV::event $callback 119When called with no arguments or an argument of 1, makes the innermost
120call to EV::loop return.
137 121
138Creates a new event watcher waiting for nothing, calling the given callback. 122When called with an agrument of 2, all calls to EV::loop will return as
123fast as possible.
139 124
125=back
126
127=head2 WATCHER
128
129A watcher is an object that gets created to record your interest in some
130event. For instance, if you want to wait for STDIN to become readable, you
131would create an EV::io watcher for that:
132
133 my $watcher = EV::io *STDIN, EV::READ, sub {
134 my ($watcher, $revents) = @_;
135 warn "yeah, STDIN should not be readable without blocking!\n"
136 };
137
138All watchers can be active (waiting for events) or inactive (paused). Only
139active watchers will have their callbacks invoked. All callbacks will be
140called with at least two arguments: the watcher and a bitmask of received
141events.
142
143Each watcher type has its associated bit in revents, so you can use the
144same callback for multiple watchers. The event mask is named after the
145type, i..e. EV::child sets EV::CHILD, EV::prepare sets EV::PREPARE,
146EV::periodic sets EV::PERIODIC and so on, with the exception of IO events
147(which can set both EV::READ and EV::WRITE bits), and EV::timer (which
148uses EV::TIMEOUT).
149
150In the rare case where one wants to create a watcher but not start it at
151the same time, each constructor has a variant with a trailing C<_ns> in
152its name, e.g. EV::io has a non-starting variant EV::io_ns and so on.
153
154Please note that a watcher will automatically be stopped when the watcher
155object is destroyed, so you I<need> to keep the watcher objects returned by
156the constructors.
157
158Also, all methods changing some aspect of a watcher (->set, ->priority,
159->fh and so on) automatically stop and start it again if it is active,
160which means pending events get lost.
161
162=head2 WATCHER TYPES
163
164Now lets move to the existing watcher types and asociated methods.
165
166The following methods are available for all watchers. Then followes a
167description of each watcher constructor (EV::io, EV::timer, EV::periodic,
168EV::signal, EV::child, EV::idle, EV::prepare and EV::check), followed by
169any type-specific methods (if any).
170
171=over 4
172
173=item $w->start
174
175Starts a watcher if it isn't active already. Does nothing to an already
176active watcher. By default, all watchers start out in the active state
177(see the description of the C<_ns> variants if you need stopped watchers).
178
179=item $w->stop
180
181Stop a watcher if it is active. Also clear any pending events (events that
182have been received but that didn't yet result in a callback invocation),
183regardless of wether the watcher was active or not.
184
185=item $bool = $w->is_active
186
187Returns true if the watcher is active, false otherwise.
188
189=item $current_cb = $w->cb
190
191=item $old_cb = $w->cb ($new_cb)
192
193Queries the callback on the watcher and optionally changes it. You can do
194this at any time without the watcher restarting.
195
196=item $current_priority = $w->priority
197
198=item $old_priority = $w->priority ($new_priority)
199
200Queries the priority on the watcher and optionally changes it. Pending
201watchers with higher priority will be invoked first. The valid range of
202priorities lies between EV::MAXPRI (default 2) and EV::MINPRI (default
203-2). If the priority is outside this range it will automatically be
204normalised to the nearest valid priority.
205
206The default priority of any newly-created weatcher is 0.
207
208=item $w->trigger ($revents)
209
210Call the callback *now* with the given event mask.
211
212
140=item my $w = EV::io $fileno_or_fh, $eventmask, $callback 213=item $w = EV::io $fileno_or_fh, $eventmask, $callback
141 214
142=item my $w = EV::io_ns $fileno_or_fh, $eventmask, $callback 215=item $w = EV::io_ns $fileno_or_fh, $eventmask, $callback
143 216
144As long as the returned watcher object is alive, call the C<$callback> 217As long as the returned watcher object is alive, call the C<$callback>
145when the events specified in C<$eventmask> happen. Initially, the timeout 218when the events specified in C<$eventmask>.
146is disabled.
147 219
148You can additionall set a timeout to occur on the watcher, but note that
149this timeout will not be reset when you get an I/O event in the EV::PERSIST
150case, and reaching a timeout will always stop the watcher even in the
151EV::PERSIST case.
152
153If you want a timeout to occur only after a specific time of inactivity, set
154a repeating timeout and do NOT use EV::PERSIST.
155
156Eventmask can be one or more of these constants ORed together: 220The $eventmask can be one or more of these constants ORed together:
157 221
158 EV::READ wait until read() wouldn't block anymore 222 EV::READ wait until read() wouldn't block anymore
159 EV::WRITE wait until write() wouldn't block anymore 223 EV::WRITE wait until write() wouldn't block anymore
160 EV::PERSIST stay active after a (non-timeout) event occured
161 224
162The C<io_ns> variant doesn't add/start the newly created watcher. 225The C<io_ns> variant doesn't start (activate) the newly created watcher.
163 226
164=item my $w = EV::timed_io $fileno_or_fh, $eventmask, $timeout, $callback 227=item $w->set ($fileno_or_fh, $eventmask)
165 228
166=item my $w = EV::timed_io_ns $fileno_or_fh, $eventmask, $timeout, $callback 229Reconfigures the watcher, see the constructor above for details. Can be
230called at any time.
167 231
168Same as C<io> and C<io_ns>, but also specifies a timeout (as if there was 232=item $current_fh = $w->fh
169a call to C<< $w->timeout ($timout, 1) >>. The persist flag is not allowed
170and will automatically be cleared. The watcher will be restarted after each event.
171 233
172If the timeout is zero or undef, no timeout will be set, and a normal 234=item $old_fh = $w->fh ($new_fh)
173watcher (with the persist flag set!) will be created.
174 235
175This has the effect of timing out after the specified period of inactivity 236Returns the previously set filehandle and optionally set a new one.
176has happened.
177 237
178Due to the design of libevent, this is also relatively inefficient, having 238=item $current_eventmask = $w->events
179one or two io watchers and a separate timeout watcher that you reset on
180activity (by calling its C<start> method) is usually more efficient.
181 239
240=item $old_eventmask = $w->events ($new_eventmask)
241
242Returns the previously set event mask and optionally set a new one.
243
244
182=item my $w = EV::timer $after, $repeat, $callback 245=item $w = EV::timer $after, $repeat, $callback
183 246
184=item my $w = EV::timer_ns $after, $repeat, $callback 247=item $w = EV::timer_ns $after, $repeat, $callback
185 248
186Calls the callback after C<$after> seconds. If C<$repeat> is true, the 249Calls the callback after C<$after> seconds. If C<$repeat> is non-zero,
187timer will be restarted after the callback returns. This means that the 250the timer will be restarted (with the $repeat value as $after) after the
188callback would be called roughly every C<$after> seconds, prolonged by the 251callback returns.
189time the callback takes.
190 252
253This means that the callback would be called roughly after C<$after>
254seconds, and then every C<$repeat> seconds. "Roughly" because the time of
255callback processing is not taken into account, so the timer will slowly
256drift. If that isn't acceptable, look at EV::periodic.
257
258The timer is based on a monotonic clock, that is if somebody is sitting
259in front of the machine while the timer is running and changes the system
260clock, the timer will nevertheless run (roughly) the same time.
261
191The C<timer_ns> variant doesn't add/start the newly created watcher. 262The C<timer_ns> variant doesn't start (activate) the newly created watcher.
192 263
264=item $w->set ($after, $repeat)
265
266Reconfigures the watcher, see the constructor above for details. Can be at
267any time.
268
269=item $w->again
270
271Similar to the C<start> method, but has special semantics for repeating timers:
272
273If the timer is active and repeating, reset the timeout to occur
274C<$repeat> seconds after now.
275
276If the timer is active and non-repeating, it will be stopped.
277
278If the timer is in active and repeating, start it.
279
280Otherwise do nothing.
281
282This behaviour is useful when you have a timeout for some IO
283operation. You create a timer object with the same value for C<$after> and
284C<$repeat>, and then, in the read/write watcher, run the C<again> method
285on the timeout.
286
287
288=item $w = EV::periodic $at, $interval, $callback
289
193=item my $w = EV::timer_abs $at, $interval, $callback 290=item $w = EV::periodic_ns $at, $interval, $callback
194
195=item my $w = EV::timer_abs_ns $at, $interval, $callback
196 291
197Similar to EV::timer, but the time is given as an absolute point in time 292Similar to EV::timer, but the time is given as an absolute point in time
198(C<$at>), plus an optional C<$interval>. 293(C<$at>), plus an optional C<$interval>.
199 294
200If the C<$interval> is zero, then the callback will be called at the time 295If the C<$interval> is zero, then the callback will be called at the time
201C<$at> if that is in the future, or as soon as possible if its in the 296C<$at> if that is in the future, or as soon as possible if it is in the
202past. It will not automatically repeat. 297past. It will not automatically repeat.
203 298
204If the C<$interval> is nonzero, then the watcher will always be scheduled 299If the C<$interval> is nonzero, then the watcher will always be scheduled
205to time out at the next C<$at + integer * $interval> time. 300to time out at the next C<$at + N * $interval> time.
206 301
207This can be used to schedule a callback to run at very regular intervals, 302This can be used to schedule a callback to run at very regular intervals,
208as long as the processing time is less then the interval (otherwise 303as long as the processing time is less then the interval (otherwise
209obviously events will be skipped). 304obviously events will be skipped).
210 305
211Another way to think about it (for the mathematically inclined) is that 306Another way to think about it (for the mathematically inclined) is that
212C<timer_abs> will try to tun the callback at the next possible time where 307EV::periodic will try to run the callback at the next possible time where
213C<$time = $at (mod $interval)>, regardless of any time jumps. 308C<$time = $at (mod $interval)>, regardless of any time jumps.
214 309
310This periodic timer is based on "wallclock time", that is, if the clock
311changes (C<ntp>, C<date -s> etc.), then the timer will nevertheless run at
312the specified time. This means it will never drift (it might jitter, but
313it will not drift).
314
215The C<timer_abs_ns> variant doesn't add/start the newly created watcher. 315The C<periodic_ns> variant doesn't start (activate) the newly created watcher.
216 316
317=item $w->set ($at, $interval)
318
319Reconfigures the watcher, see the constructor above for details. Can be at
320any time.
321
322
217=item my $w = EV::signal $signal, $callback 323=item $w = EV::signal $signal, $callback
218 324
219=item my $w = EV::signal_ns $signal, $callback 325=item $w = EV::signal_ns $signal, $callback
220 326
221Call the callback when $signal is received (the signal can be specified 327Call the callback when $signal is received (the signal can be specified
222by number or by name, just as with kill or %SIG). Signal watchers are 328by number or by name, just as with kill or %SIG).
223persistent no natter what.
224 329
225EV will grab the signal for the process (the kernel only allows one 330EV will grab the signal for the process (the kernel only allows one
226component to receive signals) when you start a signal watcher, and 331component to receive a signal at a time) when you start a signal watcher,
227removes it again when you stop it. Pelr does the same when you add/remove 332and removes it again when you stop it. Perl does the same when you
228callbacks to %SIG, so watch out. 333add/remove callbacks to %SIG, so watch out.
229 334
230Unfortunately, only one handler can be registered per signal. Screw 335You can have as many signal watchers per signal as you want.
231libevent.
232 336
233The C<signal_ns> variant doesn't add/start the newly created watcher. 337The C<signal_ns> variant doesn't start (activate) the newly created watcher.
338
339=item $w->set ($signal)
340
341Reconfigures the watcher, see the constructor above for details. Can be at
342any time.
343
344=item $current_signum = $w->signal
345
346=item $old_signum = $w->signal ($new_signal)
347
348Returns the previously set signal (always as a number not name) and
349optionally set a new one.
350
351
352=item $w = EV::child $pid, $callback
353
354=item $w = EV::child_ns $pid, $callback
355
356Call the callback when a status change for pid C<$pid> (or any pid
357if C<$pid> is 0) has been received. More precisely: when the process
358receives a SIGCHLD, EV will fetch the outstanding exit/wait status for all
359changed/zombie children and call the callback.
360
361Unlike all other callbacks, this callback will be called with an
362additional third argument which is the exit status. See the C<waitpid>
363function for details.
364
365You can have as many pid watchers per pid as you want.
366
367The C<child_ns> variant doesn't start (activate) the newly created watcher.
368
369=item $w->set ($pid)
370
371Reconfigures the watcher, see the constructor above for details. Can be at
372any time.
373
374=item $current_pid = $w->pid
375
376=item $old_pid = $w->pid ($new_pid)
377
378Returns the previously set process id and optionally set a new one.
379
380
381=item $w = EV::idle $callback
382
383=item $w = EV::idle_ns $callback
384
385Call the callback when there are no pending io, timer/periodic, signal or
386child events, i.e. when the process is idle.
387
388The process will not block as long as any idle watchers are active, and
389they will be called repeatedly until stopped.
390
391The C<idle_ns> variant doesn't start (activate) the newly created watcher.
392
393
394=item $w = EV::prepare $callback
395
396=item $w = EV::prepare_ns $callback
397
398Call the callback just before the process would block. You can still
399create/modify any watchers at this point.
400
401See the EV::check watcher, below, for explanations and an example.
402
403The C<prepare_ns> variant doesn't start (activate) the newly created watcher.
404
405
406=item $w = EV::check $callback
407
408=item $w = EV::check_ns $callback
409
410Call the callback just after the process wakes up again (after it has
411gathered events), but before any other callbacks have been invoked.
412
413This is used to integrate other event-based software into the EV
414mainloop: You register a prepare callback and in there, you create io and
415timer watchers as required by the other software. Here is a real-world
416example of integrating Net::SNMP (with some details left out):
417
418 our @snmp_watcher;
419
420 our $snmp_prepare = EV::prepare sub {
421 # do nothing unless active
422 $dispatcher->{_event_queue_h}
423 or return;
424
425 # make the dispatcher handle any outstanding stuff
426
427 # create an IO watcher for each and every socket
428 @snmp_watcher = (
429 (map { EV::io $_, EV::READ, sub { } }
430 keys %{ $dispatcher->{_descriptors} }),
431 );
432
433 # if there are any timeouts, also create a timer
434 push @snmp_watcher, EV::timer $event->[Net::SNMP::Dispatcher::_TIME] - EV::now, 0, sub { }
435 if $event->[Net::SNMP::Dispatcher::_ACTIVE];
436 };
437
438The callbacks are irrelevant, the only purpose of those watchers is
439to wake up the process as soon as one of those events occurs (socket
440readable, or timer timed out). The corresponding EV::check watcher will then
441clean up:
442
443 our $snmp_check = EV::check sub {
444 # destroy all watchers
445 @snmp_watcher = ();
446
447 # make the dispatcher handle any new stuff
448 };
449
450The callbacks of the created watchers will not be called as the watchers
451are destroyed before this cna happen (remember EV::check gets called
452first).
453
454The C<check_ns> variant doesn't start (activate) the newly created watcher.
234 455
235=back 456=back
236 457
237=head1 THE EV::Event CLASS
238
239All EV functions creating an event watcher (designated by C<my $w =>
240above) support the following methods on the returned watcher object:
241
242=over 4
243
244=item $w->add ($timeout)
245
246Stops and (re-)starts the event watcher, setting the optional timeout to
247the given value, or clearing the timeout if none is given.
248
249=item $w->start
250
251Stops and (re-)starts the event watcher without touching the timeout.
252
253=item $w->del
254
255=item $w->stop
256
257Stop the event watcher if it was started.
258
259=item $current_callback = $w->cb
260
261=item $old_callback = $w->cb ($new_callback)
262
263Return the previously set callback and optionally set a new one.
264
265=item $current_fh = $w->fh
266
267=item $old_fh = $w->fh ($new_fh)
268
269Returns the previously set filehandle and optionally set a new one (also
270clears the EV::SIGNAL flag when setting a filehandle).
271
272=item $current_signal = $w->signal
273
274=item $old_signal = $w->signal ($new_signal)
275
276Returns the previously set signal number and optionally set a new one (also sets
277the EV::SIGNAL flag when setting a signal).
278
279=item $current_eventmask = $w->events
280
281=item $old_eventmask = $w->events ($new_eventmask)
282
283Returns the previously set event mask and optionally set a new one.
284
285=item $w->timeout ($after, $repeat)
286
287Resets the timeout (see C<EV::timer> for details).
288
289=item $w->timeout_abs ($at, $interval)
290
291Resets the timeout (see C<EV::timer_abs> for details).
292
293=item $w->priority_set ($priority)
294
295Set the priority of the watcher to C<$priority> (0 <= $priority < $EV::NPRI).
296
297=back
298
299=head1 THREADS 458=head1 THREADS
300 459
301Threads are not supported by this in any way. Perl pseudo-threads is evil 460Threads are not supported by this in any way. Perl pseudo-threads is evil
302and must die. 461stuff and must die.
303
304=head1 BUGS
305
306Lots. Libevent itself isn't well tested and rather buggy, and this module
307is quite new at the moment.
308
309Please note that the epoll method is not, in general, reliable in programs
310that use fork (even if no libveent calls are being made in the forked
311process). If your program behaves erratically, try setting the environment
312variable C<EVENT_NOEPOLL> first when running the program.
313
314In general, if you fork, then you can only use the EV module in one of the
315children.
316 462
317=cut 463=cut
318 464
319our $DIED = sub { 465our $DIED = sub {
320 warn "EV: error in callback (ignoring): $@"; 466 warn "EV: error in callback (ignoring): $@";
… …
326 472
3271; 4731;
328 474
329=head1 SEE ALSO 475=head1 SEE ALSO
330 476
331 L<EV::DNS>, L<event(3)>, L<event.h>, L<evdns.h>.
332 L<EV::AnyEvent>. 477 L<EV::DNS>, L<EV::AnyEvent>.
333 478
334=head1 AUTHOR 479=head1 AUTHOR
335 480
336 Marc Lehmann <schmorp@schmorp.de> 481 Marc Lehmann <schmorp@schmorp.de>
337 http://home.schmorp.de/ 482 http://home.schmorp.de/

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines