[ViewVC] Diff of: cvs/EV/EV.pm

Comparing EV/EV.pm (file contents):
Revision 1.133 by root, Tue Jan 11 02:31:24 2011 UTC vs.
Revision 1.151 by root, Tue Sep 4 23:14:45 2018 UTC

       my ($w, $revents) = @_;
       warn $w->path, " has changed somehow.\n";
    };
    # MAINLOOP
-   EV::loop;           # loop until EV::unloop is called or all watchers stop
+   EV::run;                # loop until EV::break is called or all watchers stop
-   EV::loop EV::LOOP_ONESHOT;  # block until at least one event could be handled
+   EV::run EV::RUN_ONCE;   # block until at least one event could be handled
-   EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block
+   EV::run EV::RUN_NOWAIT; # try to handle same events, but do not block
 =head1 BEFORE YOU START USING THIS MODULE
 If you only need timer, I/O, signal, child and idle watchers and not the
 advanced functionality of this module, consider using L<AnyEvent> instead,
 package EV;
 use common::sense;
 BEGIN {
-   our $VERSION = '4.02';
+   our $VERSION = 4.22;
    use XSLoader;
+   local $^W = 0; # avoid spurious warning
    XSLoader::load "EV", $VERSION;
 }
 @EV::IO::ISA       =
 @EV::Timer::ISA    =
 Must be called after a fork in the child, before entering or continuing
 the event loop. An alternative is to use C<EV::FLAG_FORKCHECK> which calls
 this function automatically, at some performance loss (refer to the libev
 documentation).
-=item $loop->loop_verify
+=item $loop->verify
 Calls C<ev_verify> to make internal consistency checks (for debugging
 libev) and abort the program if any data structures were found to be
 corrupted.
 =item $backend = $loop->backend
 Returns an integer describing the backend used by libev (EV::BACKEND_SELECT
 or EV::BACKEND_EPOLL).
-=item EV::loop [$flags]
+=item $active = EV::run [$flags]
-=item $loop->loop ([$flags])
+=item $active = $loop->run ([$flags])
 Begin checking for events and calling callbacks. It returns when a
-callback calls EV::unloop.
+callback calls EV::break or the flags are nonzero (in which case the
+return value is true) or when there are no active watchers which reference
+the loop (keepalive is true), in which case the return value will be
+false. The return value can generally be interpreted as "if true, there is
+more work left to do".
 The $flags argument can be one of the following:
-   0                as above
+   0               as above
-   EV::LOOP_ONCE    block at most once (wait, but do not loop)
+   EV::RUN_ONCE    block at most once (wait, but do not loop)
-   EV::LOOP_NOWAIT  do not block at all (fetch/handle events but do not wait)
+   EV::RUN_NOWAIT  do not block at all (fetch/handle events but do not wait)
 =item EV::break [$how]
 =item $loop->break ([$how])
 return as fast as possible.
 When called with an argument of EV::BREAK_CANCEL, any pending break will
 be cancelled.
-=item $count = EV::loop_count
+=item $count = EV::iteration
-=item $count = $loop->loop_count
+=item $count = $loop->iteration
 Return the number of times the event loop has polled for new
 events. Sometimes useful as a generation counter.
 =item EV::once $fh_or_undef, $events, $timeout, $cb->($revents)
 =item $w = $loop->timer ($after, $repeat, $callback)
 =item $w = $loop->timer_ns ($after, $repeat, $callback)
-Calls the callback after C<$after> seconds (which may be fractional). If
+Calls the callback after C<$after> seconds (which may be fractional or
-C<$repeat> is non-zero, the timer will be restarted (with the $repeat
+negative). If C<$repeat> is non-zero, the timer will be restarted (with
-value as $after) after the callback returns.
+the $repeat value as $after) after the callback returns.
 This means that the callback would be called roughly after C<$after>
 seconds, and then every C<$repeat> seconds. The timer does his best not
 to drift, but it will not invoke the timer more often then once per event
 loop iteration, and might drift in other cases. If that isn't acceptable,
 in front of the machine while the timer is running and changes the system
 clock, the timer will nevertheless run (roughly) the same time.
 The C<timer_ns> variant doesn't start (activate) the newly created watcher.
-=item $w->set ($after, $repeat)
+=item $w->set ($after, $repeat = 0)
 Reconfigures the watcher, see the constructor above for details. Can be called at
 any time.
 =item $w->again
+=item $w->again ($repeat)
 Similar to the C<start> method, but has special semantics for repeating timers:
 If the timer is active and non-repeating, it will be stopped.
 This behaviour is useful when you have a timeout for some IO
 operation. You create a timer object with the same value for C<$after> and
 C<$repeat>, and then, in the read/write watcher, run the C<again> method
 on the timeout.
+If called with a C<$repeat> argument, then it uses this a timer repeat
+value.
+=item $after = $w->remaining
+Calculates and returns the remaining time till the timer will fire.
 =back
 =head3 PERIODIC WATCHERS - to cron or not to cron?
 surpasses this time.
 =item * repeating interval timer ($interval > 0, $reschedule_cb = 0)
 In this mode the watcher will always be scheduled to time out at the
-next C<$at + N * $interval> time (for some integer N) and then repeat,
+next C<$at + N * $interval> time (for the lowest integer N) and then repeat,
-regardless of any time jumps.
+regardless of any time jumps. Note that, since C<N> can be negative, the
+first trigger can happen before C<$at>.
 This can be used to create timers that do not drift with respect to system
 time:
    my $hourly = EV::periodic 0, 3600, 0, sub { print "once/hour\n" };
 That doesn't mean there will always be 3600 seconds in between triggers,
-but only that the the clalback will be called when the system time shows a
+but only that the the callback will be called when the system time shows a
 full hour (UTC).
 Another way to think about it (for the mathematically inclined) is that
 EV::periodic will try to run the callback in this mode at the next
 possible time where C<$time = $at (mod $interval)>, regardless of any time
 =item $w = EV::async $callback
 =item $w = EV::async_ns $callback
+=item $w = $loop->async ($callback)
+=item $w = $loop->async_ns ($callback)
 =item $w->send
 =item $bool = $w->async_pending
 =back
+=head3 CLEANUP WATCHERS - how to clean up when the event loop goes away
+Cleanup watchers are not supported on the Perl level, they can only be
+used via XS currently.
 =head1 PERL SIGNALS
 While Perl signal handling (C<%SIG>) is not affected by EV, the behaviour

Diff Legend

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

Comparing EV/EV.pm (file contents): Revision 1.133 by root, Tue Jan 11 02:31:24 2011 UTC vs. Revision 1.151 by root, Tue Sep 4 23:14:45 2018 UTC

Diff Legend

Comparing EV/EV.pm (file contents):
Revision 1.133 by root, Tue Jan 11 02:31:24 2011 UTC vs.
Revision 1.151 by root, Tue Sep 4 23:14:45 2018 UTC