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

Comparing EV/EV.pm (file contents):
Revision 1.138 by root, Sun May 6 16:30:27 2012 UTC vs.
Revision 1.153 by root, Sun Oct 28 23:51:23 2018 UTC

       my ($w, $revents) = @_;
       warn $w->path, " has changed somehow.\n";
    };
    # MAINLOOP
-   EV::run;                # loop until EV::unloop is called or all watchers stop
+   EV::run;                # loop until EV::break is called or all watchers stop
    EV::run EV::RUN_ONCE;   # block until at least one event could be handled
    EV::run EV::RUN_NOWAIT; # try to handle same events, but do not block
 =head1 BEFORE YOU START USING THIS MODULE
 package EV;
 use common::sense;
 BEGIN {
-   our $VERSION = '4.11';
+   our $VERSION = 4.22;
    use XSLoader;
+   local $^W = 0; # avoid spurious warning
    XSLoader::load "EV", $VERSION;
 }
 @EV::IO::ISA       =
 @EV::Timer::ISA    =
 =item $active = EV::run [$flags]
 =item $active = $loop->run ([$flags])
 Begin checking for events and calling callbacks. It returns when a
-callback calls EV::unloop or the flasg are nonzero (in which case the
+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 returnv alue can generally be interpreted as "if true, there is
+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
 | EV::WRITE>, indicating the type of I/O event you want to wait for. If
 you do not want to wait for some I/O event, specify C<undef> for
 C<$fh_or_undef> and C<0> for C<$events>).
 If timeout is C<undef> or negative, then there will be no
-timeout. Otherwise a EV::timer with this value will be started.
+timeout. Otherwise an C<EV::timer> with this value will be started.
 When an error occurs or either the timeout or I/O watcher triggers, then
 the callback will be called with the received event set (in general
 you can expect it to be a combination of C<EV::ERROR>, C<EV::READ>,
 C<EV::WRITE> and C<EV::TIMER>).
 =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
 time as second argument.
 I<This callback MUST NOT stop or destroy this or any other periodic
 watcher, ever, and MUST NOT call any event loop functions or methods>. If
 you need to stop it, return 1e30 and stop it afterwards. You may create
-and start a C<EV::prepare> watcher for this task.
+and start an C<EV::prepare> watcher for this task.
 It must return the next time to trigger, based on the passed time value
 (that is, the lowest time value larger than or equal to to the second
 argument). It will usually be called just before the callback will be
 triggered, but might be called at other times, too.
 This can be used to create very complex timers, such as a timer that
-triggers on each midnight, local time (actually 24 hours after the last
+triggers on each midnight, local time (actually one day after the last
-midnight, to keep the example simple. If you know a way to do it correctly
+midnight, to keep the example simple):
-in about the same space (without requiring elaborate modules), drop me a
-note :):
    my $daily = EV::periodic 0, 0, sub {
       my ($w, $now) = @_;
       use Time::Local ();
       my (undef, undef, undef, $d, $m, $y) = localtime $now;
-      86400 + Time::Local::timelocal 0, 0, 0, $d, $m, $y
+      Time::Local::timelocal_nocheck 0, 0, 0, $d + 1, $m, $y
    }, sub {
       print "it's midnight or likely shortly after, now\n";
    };
 =back

Diff Legend

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

Comparing EV/EV.pm (file contents): Revision 1.138 by root, Sun May 6 16:30:27 2012 UTC vs. Revision 1.153 by root, Sun Oct 28 23:51:23 2018 UTC

Diff Legend

Comparing EV/EV.pm (file contents):
Revision 1.138 by root, Sun May 6 16:30:27 2012 UTC vs.
Revision 1.153 by root, Sun Oct 28 23:51:23 2018 UTC