[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent.pm

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.265 by root, Wed Jul 29 13:10:58 2009 UTC vs.
Revision 1.273 by root, Thu Aug 6 13:45:04 2009 UTC

 my variables are only visible after the statement in which they are
 declared.
 =head2 I/O WATCHERS
+   $w = AnyEvent->io (
+      fh   => <filehandle_or_fileno>,
+      poll => <"r" or "w">,
+      cb   => <callback>,
+   );
 You can create an I/O watcher by calling the C<< AnyEvent->io >> method
 with the following mandatory key-value pairs as arguments:
 C<fh> is the Perl I<file handle> (or a naked file descriptor) to watch
 for events (AnyEvent might or might not keep a reference to this file
       undef $w;
    });
 =head2 TIME WATCHERS
+   $w = AnyEvent->timer (after => <seconds>, cb => <callback>);
+   $w = AnyEvent->timer (
+      after    => <fractional_seconds>,
+      interval => <fractional_seconds>,
+      cb       => <callback>,
+   );
 You can create a time watcher by calling the C<< AnyEvent->timer >>
 method with the following mandatory arguments:
 C<after> specifies after how many seconds (fractional values are
 supported) the callback should be invoked. C<cb> is the callback to invoke
 =back
 =head2 SIGNAL WATCHERS
+   $w = AnyEvent->signal (signal => <uppercase_signal_name>, cb => <callback>);
 You can watch for signals using a signal watcher, C<signal> is the signal
 I<name> in uppercase and without any C<SIG> prefix, C<cb> is the Perl
 callback to be invoked whenever a signal occurs.
 Although the callback might get passed parameters, their value and
    my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
 =head3 Signal Races, Delays and Workarounds
 Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
-callbacks to signals in a generic way, which is a pity, as you cannot do
+callbacks to signals in a generic way, which is a pity, as you cannot
-race-free signal handling in perl. AnyEvent will try to do it's best, but
+do race-free signal handling in perl, requiring C libraries for
+this. AnyEvent will try to do it's best, which means in some cases,
-in some cases, signals will be delayed. The maximum time a signal might
+signals will be delayed. The maximum time a signal might be delayed is
-be delayed is specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10
+specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10 seconds). This
-seconds). This variable can be changed only before the first signal
+variable can be changed only before the first signal watcher is created,
-watcher is created, and should be left alone otherwise. Higher values
+and should be left alone otherwise. This variable determines how often
+AnyEvent polls for signals (in case a wake-up was missed). Higher values
 will cause fewer spurious wake-ups, which is better for power and CPU
+saving.
-saving. All these problems can be avoided by installing the optional
+All these problems can be avoided by installing the optional
-L<Async::Interrupt> module. This will not work with inherently broken
+L<Async::Interrupt> module, which works with most event loops. It will not
-event loops such as L<Event> or L<Event::Lib> (and not with L<POE>
+work with inherently broken event loops such as L<Event> or L<Event::Lib>
-currently, as POE does it's own workaround with one-second latency). With
+(and not with L<POE> currently, as POE does it's own workaround with
-those, you just have to suffer the delays.
+one-second latency). For those, you just have to suffer the delays.
 =head2 CHILD PROCESS WATCHERS
+   $w = AnyEvent->child (pid => <process id>, cb => <callback>);
 You can also watch on a child process exit and catch its exit status.
 The child process is specified by the C<pid> argument (one some backends,
 using C<0> watches for any child process exit, on others this will
    # do something else, then wait for process exit
    $done->recv;
 =head2 IDLE WATCHERS
+   $w = AnyEvent->idle (cb => <callback>);
 Sometimes there is a need to do something, but it is not so important
 to do it instantly, but only when there is nothing better to do. This
 "nothing better to do" is usually defined to be "no other events need
 attention by the event loop".
       });
    });
 =head2 CONDITION VARIABLES
+   $cv = AnyEvent->condvar;
+   $cv->send (<list>);
+   my @res = $cv->recv;
 If you are familiar with some event loops you will know that all of them
 require you to run some blocking "loop", "run" or similar function that
 will actively watch for new events and call your callbacks.
 AnyEvent is slightly different: it expects somebody else to run the event
 =item $cb = $cv->cb ($cb->($cv))
 This is a mutator function that returns the callback set and optionally
 replaces it before doing so.
-The callback will be called when the condition becomes "true", i.e. when
+The callback will be called when the condition becomes (or already was)
-C<send> or C<croak> are called, with the only argument being the condition
+"true", i.e. when C<send> or C<croak> are called (or were called), with
-variable itself. Calling C<recv> inside the callback or at any later time
+the only argument being the condition variable itself. Calling C<recv>
-is guaranteed not to block.
+inside the callback or at any later time is guaranteed not to block.
 =back
 =head1 SUPPORTED EVENT LOOPS/BACKENDS
 BEGIN { AnyEvent::common_sense }
 use Carp ();
-our $VERSION = 4.881;
+our $VERSION = 4.91;
 our $MODEL;
 our $AUTOLOAD;
 our @ISA;
    # we assume CLOEXEC is already set by perl in all important cases
    ($fh2, $rw)
 }
+#############################################################################
+# "new" API, currently only emulation of it
+#############################################################################
+package AE;
+sub io($$$) {
+   AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
+}
+sub timer($$$) {
+   AnyEvent->timer (after => $_[0], interval => $_[1], cb => $_[2]);
+}
+sub signal($$) {
+   AnyEvent->signal (signal => $_[0], cb => $_[1]);
+}
+sub child($$) {
+   AnyEvent->child (pid => $_[0], cb => $_[1]);
+}
+sub idle($) {
+   AnyEvent->idle (cb => $_[0]);
+}
+sub cv(;&) {
+   AnyEvent->condvar (@_ ? (cb => $_[0]) : ())
+}
+sub now() {
+   AnyEvent->now
+}
+sub now_update() {
+   AnyEvent->now_update
+}
+sub time() {
+   AnyEvent->time
+}
 package AnyEvent::Base;
 # default implementations for many methods
 sub _time {
 # install a dummy wakeup watcher to reduce signal catching latency
 sub _sig_add() {
    unless ($SIG_COUNT++) {
       # try to align timer on a full-second boundary, if possible
-      my $NOW = AnyEvent->now;
+      my $NOW = AE::now;
-      $SIG_TW = AnyEvent->timer (
+      $SIG_TW = AE::timer
-         after    => $MAX_SIGNAL_LATENCY - ($NOW - int $NOW),
+         $MAX_SIGNAL_LATENCY - ($NOW - int $NOW),
-         interval => $MAX_SIGNAL_LATENCY,
+         $MAX_SIGNAL_LATENCY,
-         cb       => sub { }, # just for the PERL_ASYNC_CHECK
+         sub { } # just for the PERL_ASYNC_CHECK
-      );
+      ;
    }
 }
 sub _sig_del {
    undef $SIG_TW
       # probe for availability of Async::Interrupt
       if (_have_async_interrupt) {
          warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8;
          $SIGPIPE_R = new Async::Interrupt::EventPipe;
-         $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R->fileno, poll => "r", cb => \&_signal_exec);
+         $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
       } else {
          warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
          require Fcntl;
          }
          $SIGPIPE_R
             or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
-         $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
+         $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
       }
       *signal = sub {
          my (undef, %arg) = @_;
    $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/
                 ? 1
                 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
    unless ($CHLD_W) {
-      $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
+      $CHLD_W = AE::signal CHLD => \&_sigchld;
       # child could be a zombie already, so make at least one round
       &_sigchld;
    }
    bless [$pid, $arg{cb}], "AnyEvent::Base::child"
          # never use more then 50% of the time for the idle watcher,
          # within some limits
          $w = 0.0001 if $w < 0.0001;
          $w = 5      if $w > 5;
-         $w = AnyEvent->timer (after => $w, cb => $rcb);
+         $w = AE::timer $w, 0, $rcb;
       } else {
          # clean up...
          undef $w;
          undef $rcb;
       }
    };
-   $w = AnyEvent->timer (after => 0.05, cb => $rcb);
+   $w = AE::timer 0.05, 0, $rcb;
    bless \\$cb, "AnyEvent::Base::idle"
 }
 sub AnyEvent::Base::idle::DESTROY {
    Carp::croak $_[0]{_ae_croak} if $_[0]{_ae_croak};
    wantarray ? @{ $_[0]{_ae_sent} } : $_[0]{_ae_sent}[0]
 }
 sub cb {
-   $_[0]{_ae_cb} = $_[1] if @_ > 1;
+   my $cv = shift;
+   @_
+      and $cv->{_ae_cb} = shift
+      and $cv->{_ae_sent}
+      and (delete $cv->{_ae_cb})->($cv);
-   $_[0]{_ae_cb}
+   $cv->{_ae_cb}
 }
 sub begin {
    ++$_[0]{_ae_counter};
    $_[0]{_ae_end_cb} = $_[1] if @_ > 1;

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent.pm (file contents): Revision 1.265 by root, Wed Jul 29 13:10:58 2009 UTC vs. Revision 1.273 by root, Thu Aug 6 13:45:04 2009 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.265 by root, Wed Jul 29 13:10:58 2009 UTC vs.
Revision 1.273 by root, Thu Aug 6 13:45:04 2009 UTC