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

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.105 by root, Thu May 1 12:35:54 2008 UTC vs.
Revision 1.106 by root, Thu May 1 13:45:22 2008 UTC

    my $w = AnyEvent->timer (after => $seconds, cb => sub {
       ...
    });
    my $w = AnyEvent->condvar; # stores whether a condition was flagged
-   $w->wait; # enters "main loop" till $condvar gets ->broadcast
+   $w->wait; # enters "main loop" till $condvar gets ->send
-   $w->broadcast; # wake up current and all future wait's
+   $w->send; # wake up current and all future wait's
 =head1 WHY YOU SHOULD USE THIS MODULE (OR NOT)
 Glib, POE, IO::Async, Event... CPAN offers event models by the dozen
 nowadays. So what is different about AnyEvent?
   my $w = AnyEvent->child (
      pid => $pid,
      cb  => sub {
         my ($pid, $status) = @_;
         warn "pid $pid exited with status $status";
-        $done->broadcast;
+        $done->send;
      },
   );
   # do something else, then wait for process exit
   $done->wait;
 >> method, usually without arguments. The only argument pair allowed is
 C<cb>, which specifies a callback to be called when the condition variable
 becomes true.
 After creation, the conditon variable is "false" until it becomes "true"
-by calling the C<broadcast> method.
+by calling the C<send> method.
 Condition variables are similar to callbacks, except that you can
 optionally wait for them. They can also be called merge points - points
 in time where multiple outstandign events have been processed. And yet
 another way to call them is transations - each condition variable can be
 called or can synchronously C<< ->wait >> for the results.
 You can also use them to simulate traditional event loops - for example,
 you can block your main program until an event occurs - for example, you
 could C<< ->wait >> in your main program until the user clicks the Quit
-button of your app, which would C<< ->broadcast >> the "quit" event.
+button of your app, which would C<< ->send >> the "quit" event.
 Note that condition variables recurse into the event loop - if you have
 two pieces of code that call C<< ->wait >> in a round-robbin fashion, you
 lose. Therefore, condition variables are good to export to your caller, but
 you should avoid making a blocking wait yourself, at least in callbacks,
 easy (it is often useful to build your own transaction class on top of
 AnyEvent). To subclass, use C<AnyEvent::CondVar> as base class and call
 it's C<new> method in your own C<new> method.
 There are two "sides" to a condition variable - the "producer side" which
-eventually calls C<< -> broadcast >>, and the "consumer side", which waits
+eventually calls C<< -> send >>, and the "consumer side", which waits
-for the broadcast to occur.
+for the send to occur.
 Example:
    # wait till the result is ready
    my $result_ready = AnyEvent->condvar;
    # do something such as adding a timer
-   # or socket watcher the calls $result_ready->broadcast
+   # or socket watcher the calls $result_ready->send
    # when the "result" is ready.
    # in this case, we simply use a timer:
    my $w = AnyEvent->timer (
       after => 1,
-      cb    => sub { $result_ready->broadcast },
+      cb    => sub { $result_ready->send },
    );
    # this "blocks" (while handling events) till the callback
-   # calls broadcast
+   # calls send
    $result_ready->wait;
 =head3 METHODS FOR PRODUCERS
 These methods should only be used by the producing side, i.e. the
-code/module that eventually broadcasts the signal. Note that it is also
+code/module that eventually sends the signal. Note that it is also
 the producer side which creates the condvar in most cases, but it isn't
 uncommon for the consumer to create it as well.
 =over 4
-=item $cv->broadcast (...)
+=item $cv->send (...)
 Flag the condition as ready - a running C<< ->wait >> and all further
 calls to C<wait> will (eventually) return after this method has been
-called. If nobody is waiting the broadcast will be remembered.
+called. If nobody is waiting the send will be remembered.
 If a callback has been set on the condition variable, it is called
-immediately from within broadcast.
+immediately from within send.
-Any arguments passed to the C<broadcast> call will be returned by all
+Any arguments passed to the C<send> call will be returned by all
 future C<< ->wait >> calls.
 =item $cv->croak ($error)
-Similar to broadcast, but causes all call's wait C<< ->wait >> to invoke
+Similar to send, but causes all call's wait C<< ->wait >> to invoke
 C<Carp::croak> with the given error message/object/scalar.
 This can be used to signal any errors to the condition variable
 user/consumer.
 to use a condition variable for the whole process.
 Every call to C<< ->begin >> will increment a counter, and every call to
 C<< ->end >> will decrement it.  If the counter reaches C<0> in C<< ->end
 >>, the (last) callback passed to C<begin> will be executed. That callback
-is I<supposed> to call C<< ->broadcast >>, but that is not required. If no
+is I<supposed> to call C<< ->send >>, but that is not required. If no
-callback was set, C<broadcast> will be called without any arguments.
+callback was set, C<send> will be called without any arguments.
 Let's clarify this with the ping example:
    my $cv = AnyEvent->condvar;
    my %result;
-   $cv->begin (sub { $cv->broadcast (\%result) });
+   $cv->begin (sub { $cv->send (\%result) });
    for my $host (@list_of_hosts) {
       $cv->begin;
       ping_host_then_call_callback $host, sub {
          $result{$host} = ...;
    }
    $cv->end;
 This code fragment supposedly pings a number of hosts and calls
-C<broadcast> after results for all then have have been gathered - in any
+C<send> after results for all then have have been gathered - in any
 order. To achieve this, the code issues a call to C<begin> when it starts
 each ping request and calls C<end> when it has received some result for
 it. Since C<begin> and C<end> only maintain a counter, the order in which
 results arrive is not relevant.
 There is an additional bracketing call to C<begin> and C<end> outside the
 loop, which serves two important purposes: first, it sets the callback
 to be called once the counter reaches C<0>, and second, it ensures that
-broadcast is called even when C<no> hosts are being pinged (the loop
+C<send> is called even when C<no> hosts are being pinged (the loop
 doesn't execute once).
 This is the general pattern when you "fan out" into multiple subrequests:
 use an outer C<begin>/C<end> pair to set the callback and ensure C<end>
 is called at least once, and then, for each subrequest you start, call
 =head3 METHODS FOR CONSUMERS
 These methods should only be used by the consuming side, i.e. the
 code awaits the condition.
+=over 4
 =item $cv->wait
-Wait (blocking if necessary) until the C<< ->broadcast >> or C<< ->croak
+Wait (blocking if necessary) until the C<< ->send >> or C<< ->croak
 >> methods have been called on c<$cv>, while servicing other watchers
 normally.
 You can only wait once on a condition - additional calls are valid but
 will return immediately.
 If an error condition has been set by calling C<< ->croak >>, then this
 function will call C<croak>.
-In list context, all parameters passed to C<broadcast> will be returned,
+In list context, all parameters passed to C<send> will be returned,
 in scalar context only the first one will be returned.
 Not all event models support a blocking wait - some die in that case
 (programs might want to do that to stay interactive), so I<if you are
 using this from a module, never require a blocking wait>, but let the
 You can ensure that C<< -wait >> never blocks by setting a callback and
 only calling C<< ->wait >> from within that callback (or at a later
 time). This will work even when the event loop does not support blocking
 waits otherwise.
+=item $bool = $cv->ready
+Returns true when the condition is "true", i.e. whether C<send> or
+C<croak> have been called.
+=item $cb = $cv->cb ([new callback])
+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
+C<send> or C<croak> are called. Calling C<wait> inside the callback
+or at any later time is guaranteed not to block.
 =back
 =head1 GLOBAL VARIABLES AND FUNCTIONS
 decide which event module to use as soon as the first method is called, so
 by calling AnyEvent in your module body you force the user of your module
 to load the event module first.
 Never call C<< ->wait >> on a condition variable unless you I<know> that
-the C<< ->broadcast >> method has been called on it already. This is
+the C<< ->send >> method has been called on it already. This is
 because it will stall the whole program, and the whole point of using
 events is to stay interactive.
 It is fine, however, to call C<< ->wait >> when the user of your module
 requests it (i.e. if you create a http request object ad have a method
    [Event::Lib::           => AnyEvent::Impl::EventLib::], # too buggy
    [Qt::                   => AnyEvent::Impl::Qt::],       # requires special main program
    [POE::Kernel::          => AnyEvent::Impl::POE::],      # lasciate ogni speranza
 );
-our %method = map +($_ => 1), qw(io timer signal child condvar broadcast wait one_event DESTROY);
+our %method = map +($_ => 1), qw(io timer signal child condvar one_event DESTROY);
 sub detect() {
    unless ($MODEL) {
       no strict 'refs';

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent.pm (file contents): Revision 1.105 by root, Thu May 1 12:35:54 2008 UTC vs. Revision 1.106 by root, Thu May 1 13:45:22 2008 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.105 by root, Thu May 1 12:35:54 2008 UTC vs.
Revision 1.106 by root, Thu May 1 13:45:22 2008 UTC