[ViewVC] Diff of: cvs/AnyEvent/README

Comparing AnyEvent/README (file contents):
Revision 1.6 by root, Wed Nov 1 01:22:19 2006 UTC vs.
Revision 1.15 by root, Wed Apr 16 15:10:10 2008 UTC

 NAME
     AnyEvent - provide framework for multiple event loops
-    Event, Coro, Glib, Tk, Perl - various supported event loops
+    EV, Event, Coro::EV, Coro::Event, Glib, Tk, Perl - various supported
+    event loops
 SYNOPSIS
        use AnyEvent;
        my $w = AnyEvent->io (fh => $fh, poll => "r|w", cb => sub {
        });
        my $w = AnyEvent->condvar; # stores wether a condition was flagged
        $w->wait; # enters "main loop" till $condvar gets ->broadcast
        $w->broadcast; # wake up current and all future wait's
+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?
+    Executive Summary: AnyEvent is *compatible*, AnyEvent is *free of
+    policy* and AnyEvent is *small and efficient*.
+    First and foremost, *AnyEvent is not an event model* itself, it only
+    interfaces to whatever event model the main program happens to use in a
+    pragmatic way. For event models and certain classes of immortals alike,
+    the statement "there can only be one" is a bitter reality, and AnyEvent
+    helps hiding the differences.
+    The goal of AnyEvent is to offer module authors the ability to do event
+    programming (waiting for I/O or timer events) without subscribing to a
+    religion, a way of living, and most importantly: without forcing your
+    module users into the same thing by forcing them to use the same event
+    model you use.
+    For modules like POE or IO::Async (which is actually doing all I/O
+    *synchronously*...), using them in your module is like joining a cult:
+    After you joined, you are dependent on them and you cannot use anything
+    else, as it is simply incompatible to everything that isn't itself.
+    AnyEvent + POE works fine. AnyEvent + Glib works fine. AnyEvent + Tk
+    works fine etc. etc. but none of these work together with the rest: POE
+    + IO::Async? no go. Tk + Event? no go. If your module uses one of those,
+    every user of your module has to use it, too. If your module uses
+    AnyEvent, it works transparently with all event models it supports
+    (including stuff like POE and IO::Async).
+    In addition of being free of having to use *the one and only true event
+    model*, AnyEvent also is free of bloat and policy: with POE or similar
+    modules, you get an enourmous amount of code and strict rules you have
+    to follow. AnyEvent, on the other hand, is lean and to the point by only
+    offering the functionality that is useful, in as thin as a wrapper as
+    technically possible.
+    Of course, if you want lots of policy (this can arguably be somewhat
+    useful) and you want to force your users to use the one and only event
+    model, you should *not* use this module.
 DESCRIPTION
     AnyEvent provides an identical interface to multiple event loops. This
     allows module authors to utilise an event loop without forcing module
     users to use the same event loop (as only a single event loop can
     The interface itself is vaguely similar but not identical to the Event
     module.
     On the first call of any method, the module tries to detect the
     currently loaded event loop by probing wether any of the following
-    modules is loaded: Coro::Event, Event, Glib, Tk. The first one found is
+    modules is loaded: Coro::EV, Coro::Event, EV, Event, Glib, Tk. The first
-    used. If none is found, the module tries to load these modules in the
+    one found is used. If none are found, the module tries to load these
-    order given. The first one that could be successfully loaded will be
+    modules in the order given. The first one that could be successfully
-    used. If still none could be found, AnyEvent will fall back to a
+    loaded will be used. If still none could be found, AnyEvent will fall
-    pure-perl event loop, which is also not very efficient.
+    back to a pure-perl event loop, which is also not very efficient.
     Because AnyEvent first checks for modules that are already loaded,
     loading an Event model explicitly before first using AnyEvent will
     likely make that model the default. For example:
     You can create I/O watcher by calling the "AnyEvent->io" method with the
     following mandatory arguments:
     "fh" the Perl *filehandle* (not filedescriptor) to watch for events.
     "poll" must be a string that is either "r" or "w", that creates a
-    watcher waiting for "r"eadable or "w"ritable events. "cb" teh callback
+    watcher waiting for "r"eadable or "w"ritable events. "cb" the callback
     to invoke everytime the filehandle becomes ready.
-    Only one io watcher per "fh" and "poll" combination is allowed (i.e. on
-    a socket you can have one r + one w, not any more (limitation comes from
-    Tk - if you are sure you are not using Tk this limitation is gone).
     Filehandles will be kept alive, so as long as the watcher exists, the
     filehandle exists, too.
     Example:
           chomp (my $input = <STDIN>);
           warn "read: $input\n";
           undef $w;
        });
-  TIMER WATCHERS
+  TIME WATCHERS
-    You can create a timer watcher by calling the "AnyEvent->timer" method
+    You can create a time watcher by calling the "AnyEvent->timer" method
     with the following mandatory arguments:
     "after" after how many seconds (fractions are supported) should the
     timer activate. "cb" the callback to invoke.
        my $w = AnyEvent->timer (after => 7.7, cb => sub {
           warn "timeout\n";
        });
        # to cancel the timer:
-       undef $w
+       undef $w;
   CONDITION WATCHERS
     Condition watchers can be created by calling the "AnyEvent->condvar"
     method without any arguments.
     A condition watcher watches for a condition - precisely that the
     "->broadcast" method has been called.
+    Note that condition watchers recurse into the event loop - if you have
+    two watchers that call "->wait" in a round-robbin fashion, you lose.
+    Therefore, condition watchers are good to export to your caller, but you
+    should avoid making a blocking wait, at least in callbacks, as this
+    usually asks for trouble.
     The watcher has only two methods:
     $cv->wait
         Wait (blocking if necessary) until the "->broadcast" method has been
         called on c<$cv>, while servicing other watchers normally.
-        Not all event models support a blocking wait - some die in that
-        case, so if you are using this from a module, never require a
-        blocking wait, but let the caller decide wether the call will block
-        or not (for example, by coupling condition variables with some kind
-        of request results and supporting callbacks so the caller knows that
-        getting the result will not block, while still suppporting blockign
-        waits if the caller so desires).
         You can only wait once on a condition - additional calls will return
         immediately.
+        Not all event models support a blocking wait - some die in that case
+        (programs might want to do that so they stay interactive), so *if
+        you are using this from a module, never require a blocking wait*,
+        but let the caller decide wether the call will block or not (for
+        example, by coupling condition variables with some kind of request
+        results and supporting callbacks so the caller knows that getting
+        the result will not block, while still suppporting blocking waits if
+        the caller so desires).
+        Another reason *never* to "->wait" in a module is that you cannot
+        sensibly have two "->wait"'s in parallel, as that would require
+        multiple interpreters or coroutines/threads, none of which
+        "AnyEvent" can supply (the coroutine-aware backends "Coro::EV" and
+        "Coro::Event" explicitly support concurrent "->wait"'s from
+        different coroutines, however).
     $cv->broadcast
         Flag the condition as ready - a running "->wait" and all further
         calls to "wait" will return after this method has been called. If
         nobody is waiting the broadcast will be remembered..
            # do something such as adding a timer
            # or socket watcher the calls $result_ready->broadcast
            # when the "result" is ready.
            $result_ready->wait;
+  SIGNAL WATCHERS
+    You can listen for signals using a signal watcher, "signal" is the
+    signal *name* without any "SIG" prefix. Multiple signals events can be
+    clumped together into one callback invocation, and callback invocation
+    might or might not be asynchronous.
+    These watchers might use %SIG, so programs overwriting those signals
+    directly will likely not work correctly.
+    Example: exit on SIGINT
+       my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
+  CHILD PROCESS WATCHERS
+    You can also listen for the status of a child process specified by the
+    "pid" argument (or any child if the pid argument is 0). The watcher will
+    trigger as often as status change for the child are received. This works
+    by installing a signal handler for "SIGCHLD". The callback will be
+    called with the pid and exit status (as returned by waitpid).
+    Example: wait for pid 1333
+      my $w = AnyEvent->child (pid => 1333, cb => sub { warn "exit status $?" });
+GLOBALS
+    $AnyEvent::MODEL
+        Contains "undef" until the first watcher is being created. Then it
+        contains the event model that is being used, which is the name of
+        the Perl class implementing the model. This class is usually one of
+        the "AnyEvent::Impl:xxx" modules, but can be any other class in the
+        case AnyEvent has been extended at runtime (e.g. in *rxvt-unicode*).
+        The known classes so far are:
+           AnyEvent::Impl::CoroEV    based on Coro::EV, best choice.
+           AnyEvent::Impl::CoroEvent based on Coro::Event, second best choice.
+           AnyEvent::Impl::EV        based on EV (an interface to libev, also best choice).
+           AnyEvent::Impl::Event     based on Event, also second best choice :)
+           AnyEvent::Impl::Glib      based on Glib, third-best choice.
+           AnyEvent::Impl::Tk        based on Tk, very bad choice.
+           AnyEvent::Impl::Perl      pure-perl implementation, inefficient but portable.
+    AnyEvent::detect
+        Returns $AnyEvent::MODEL, forcing autodetection of the event model
+        if necessary. You should only call this function right before you
+        would have created an AnyEvent watcher anyway, that is, very late at
+        runtime.
 WHAT TO DO IN A MODULE
     As a module author, you should "use AnyEvent" and call AnyEvent methods
     freely, but you should not load a specific event module or rely on it.
     This tells AnyEvent to (literally) use the "urxvt::anyevent::"
     package/class when it finds the "urxvt" package/module is loaded. When
     AnyEvent is loaded and asked to find a suitable event model, it will
     first check for the presence of urxvt.
-    The class should prove implementations for all watcher types (see
+    The class should provide implementations for all watcher types (see
     AnyEvent::Impl::Event (source code), AnyEvent::Impl::Glib (Source code)
     and so on for actual examples, use "perldoc -m AnyEvent::Impl::Glib" to
     see the sources).
     The above isn't fictitious, the *rxvt-unicode* (a.k.a. urxvt) uses the
     *rxvt-unicode* distribution.
     *rxvt-unicode* also cheats a bit by not providing blocking access to
     condition variables: code blocking while waiting for a condition will
     "die". This still works with most modules/usages, and blocking calls
-    must not be in an interactive appliation, so it makes sense.
+    must not be in an interactive application, so it makes sense.
 ENVIRONMENT VARIABLES
     The following environment variables are used by this module:
     "PERL_ANYEVENT_VERBOSE" when set to 2 or higher, reports which event
     1. Blocking:
        my $data = $fcp->client_get ($url);
-    2. Blocking, but parallelizing:
+    2. Blocking, but running in parallel:
        my @datas = map $_->result,
                       map $fcp->txn_client_get ($_),
                          @urls;
     Both blocking examples work without the module user having to know
     anything about events.
-    3a. Event-based in a main program, using any support Event module:
+    3a. Event-based in a main program, using any supported event module:
-       use Event;
+       use EV;
        $fcp->txn_client_get ($url)->cb (sub {
           my $txn = shift;
           my $data = $txn->result;
           ...
        });
-       Event::loop;
+       EV::loop;
     3b. The module user could use AnyEvent, too:
        use AnyEvent;
        });
        $quit->wait;
 SEE ALSO
-    Event modules: Coro::Event, Coro, Event, Glib::Event, Glib.
+    Event modules: Coro::EV, EV, EV::Glib, Glib::EV, Coro::Event, Event,
+    Glib::Event, Glib, Coro, Tk.
-    Implementations: AnyEvent::Impl::Coro, AnyEvent::Impl::Event,
+    Implementations: AnyEvent::Impl::CoroEV, AnyEvent::Impl::EV,
-    AnyEvent::Impl::Glib, AnyEvent::Impl::Tk.
+    AnyEvent::Impl::CoroEvent, AnyEvent::Impl::Event, AnyEvent::Impl::Glib,
+    AnyEvent::Impl::Tk, AnyEvent::Impl::Perl.
-    Nontrivial usage example: Net::FCP.
+    Nontrivial usage examples: Net::FCP, Net::XMPP2.

Diff Legend

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

Comparing AnyEvent/README (file contents): Revision 1.6 by root, Wed Nov 1 01:22:19 2006 UTC vs. Revision 1.15 by root, Wed Apr 16 15:10:10 2008 UTC

Diff Legend

Comparing AnyEvent/README (file contents):
Revision 1.6 by root, Wed Nov 1 01:22:19 2006 UTC vs.
Revision 1.15 by root, Wed Apr 16 15:10:10 2008 UTC