[ViewVC] Diff of: cvs/libev/ev.pod

Comparing libev/ev.pod (file contents):
Revision 1.110 by root, Tue Dec 25 07:05:45 2007 UTC vs.
Revision 1.111 by root, Tue Dec 25 18:01:20 2007 UTC

 The events being watched.
 =back
+=head3 Examples
 Example: Call C<stdin_readable_cb> when STDIN_FILENO has become, well
 readable, but only once. Since it is likely line-buffered, you could
 attempt to read a whole line in the callback.
   static void
 or C<ev_timer_again> is called and determines the next timeout (if any),
 which is also when any modifications are taken into account.
 =back
+=head3 Examples
 Example: Create a timer that fires after 60 seconds.
   static void
   one_minute_cb (struct ev_loop *loop, struct ev_timer *w, int revents)
   {
 When active, contains the absolute time that the watcher is supposed to
 trigger next.
 =back
+=head3 Examples
 Example: Call a callback every hour, or, more precisely, whenever the
 system clock is divisible by 3600. The callback invocation times have
 potentially a lot of jittering, but good long-term stability.
   static void
 The process exit/trace status caused by C<rpid> (see your systems
 C<waitpid> and C<sys/wait.h> documentation for details).
 =back
+=head3 Examples
 Example: Try to exit cleanly on SIGINT and SIGTERM.
   static void
   sigint_cb (struct ev_loop *loop, struct ev_signal *w, int revents)
 kind. There is a C<ev_idle_set> macro, but using it is utterly pointless,
 believe me.
 =back
+=head3 Examples
 Example: Dynamically allocate an C<ev_idle> watcher, start it, and in the
 callback, free it. Also, use no error checking, as usual.
   static void
   idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents)
 parameters of any kind. There are C<ev_prepare_set> and C<ev_check_set>
 macros, but using them is utterly, utterly and completely pointless.
 =back
+=head3 Examples
 There are a number of principal ways to embed other event loops or modules
 into libev. Here are some ideas on how to include libadns into libev
 (there is a Perl module named C<EV::ADNS> that does this, which you could
 use for an actually working example. Another Perl module named C<EV::Glib>
 embeds a Glib main context into libev, and finally, C<Glib::EV> embeds EV
 portable one.
 So when you want to use this feature you will always have to be prepared
 that you cannot get an embeddable loop. The recommended way to get around
 this is to have a separate variables for your embeddable loop, try to
-create it, and if that fails, use the normal loop for everything:
+create it, and if that fails, use the normal loop for everything.
+=head3 Watcher-Specific Functions and Data Members
+=over 4
+=item ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)
+=item ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)
+Configures the watcher to embed the given loop, which must be
+embeddable. If the callback is C<0>, then C<ev_embed_sweep> will be
+invoked automatically, otherwise it is the responsibility of the callback
+to invoke it (it will continue to be called until the sweep has been done,
+if you do not want thta, you need to temporarily stop the embed watcher).
+=item ev_embed_sweep (loop, ev_embed *)
+Make a single, non-blocking sweep over the embedded loop. This works
+similarly to C<ev_loop (embedded_loop, EVLOOP_NONBLOCK)>, but in the most
+apropriate way for embedded loops.
+=item struct ev_loop *other [read-only]
+The embedded event loop.
+=back
+=head3 Examples
+Example: Try to get an embeddable event loop and embed it into the default
+event loop. If that is not possible, use the default loop. The default
+loop is stored in C<loop_hi>, while the mebeddable loop is stored in
+C<loop_lo> (which is C<loop_hi> in the acse no embeddable loop can be
+used).
   struct ev_loop *loop_hi = ev_default_init (0);
   struct ev_loop *loop_lo = 0;
   struct ev_embed embed;
       ev_embed_start (loop_hi, &embed);
     }
   else
     loop_lo = loop_hi;
-=head3 Watcher-Specific Functions and Data Members
+Example: Check if kqueue is available but not recommended and create
+a kqueue backend for use with sockets (which usually work with any
+kqueue implementation). Store the kqueue/socket-only event loop in
+C<loop_socket>. (One might optionally use C<EVFLAG_NOENV>, too).
-=over 4
+  struct ev_loop *loop = ev_default_init (0);
+  struct ev_loop *loop_socket = 0;
+  struct ev_embed embed;
+  if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE)
+    if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE))
+      {
+        ev_embed_init (&embed, 0, loop_socket);
+        ev_embed_start (loop, &embed);
+      }
-=item ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)
+  if (!loop_socket)
+    loop_socket = loop;
-=item ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)
+  // now use loop_socket for all sockets, and loop for everything else
-Configures the watcher to embed the given loop, which must be
-embeddable. If the callback is C<0>, then C<ev_embed_sweep> will be
-invoked automatically, otherwise it is the responsibility of the callback
-to invoke it (it will continue to be called until the sweep has been done,
-if you do not want thta, you need to temporarily stop the embed watcher).
-=item ev_embed_sweep (loop, ev_embed *)
-Make a single, non-blocking sweep over the embedded loop. This works
-similarly to C<ev_loop (embedded_loop, EVLOOP_NONBLOCK)>, but in the most
-apropriate way for embedded loops.
-=item struct ev_loop *other [read-only]
-The embedded event loop.
-=back
 =head2 C<ev_fork> - the audacity to resume the event loop after a fork
 Fork watchers are called when a C<fork ()> was detected (usually because

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.110 by root, Tue Dec 25 07:05:45 2007 UTC vs. Revision 1.111 by root, Tue Dec 25 18:01:20 2007 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.110 by root, Tue Dec 25 07:05:45 2007 UTC vs.
Revision 1.111 by root, Tue Dec 25 18:01:20 2007 UTC