ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.pod
(Generate patch)

Comparing libev/ev.pod (file contents):
Revision 1.117 by root, Wed Jan 9 04:15:39 2008 UTC vs.
Revision 1.121 by root, Mon Jan 28 12:13:54 2008 UTC

… …
260flags. If that is troubling you, check C<ev_backend ()> afterwards). 260flags. If that is troubling you, check C<ev_backend ()> afterwards).
261 261
262If you don't know what event loop to use, use the one returned from this 262If you don't know what event loop to use, use the one returned from this
263function. 263function.
264 264
265The default loop is the only loop that can handle C<ev_signal> and
266C<ev_child> watchers, and to do this, it always registers a handler
267for C<SIGCHLD>. If this is a problem for your app you can either
268create a dynamic loop with C<ev_loop_new> that doesn't do that, or you
269can simply overwrite the C<SIGCHLD> signal handler I<after> calling
270C<ev_default_init>.
271
265The flags argument can be used to specify special behaviour or specific 272The flags argument can be used to specify special behaviour or specific
266backends to use, and is usually specified as C<0> (or C<EVFLAG_AUTO>). 273backends to use, and is usually specified as C<0> (or C<EVFLAG_AUTO>).
267 274
268The following flags are supported: 275The following flags are supported:
269 276
… …
476Like C<ev_default_destroy>, but destroys an event loop created by an 483Like C<ev_default_destroy>, but destroys an event loop created by an
477earlier call to C<ev_loop_new>. 484earlier call to C<ev_loop_new>.
478 485
479=item ev_default_fork () 486=item ev_default_fork ()
480 487
488This function sets a flag that causes subsequent C<ev_loop> iterations
481This function reinitialises the kernel state for backends that have 489to reinitialise the kernel state for backends that have one. Despite the
482one. Despite the name, you can call it anytime, but it makes most sense 490name, you can call it anytime, but it makes most sense after forking, in
483after forking, in either the parent or child process (or both, but that 491the child process (or both child and parent, but that again makes little
484again makes little sense). 492sense). You I<must> call it in the child before using any of the libev
493functions, and it will only take effect at the next C<ev_loop> iteration.
485 494
486You I<must> call this function in the child process after forking if and 495On the other hand, you only need to call this function in the child
487only if you want to use the event library in both processes. If you just 496process if and only if you want to use the event library in the child. If
488fork+exec, you don't have to call it. 497you just fork+exec, you don't have to call it at all.
489 498
490The function itself is quite fast and it's usually not a problem to call 499The function itself is quite fast and it's usually not a problem to call
491it just in case after a fork. To make this easy, the function will fit in 500it just in case after a fork. To make this easy, the function will fit in
492quite nicely into a call to C<pthread_atfork>: 501quite nicely into a call to C<pthread_atfork>:
493 502
494 pthread_atfork (0, 0, ev_default_fork); 503 pthread_atfork (0, 0, ev_default_fork);
495
496At the moment, C<EVBACKEND_SELECT> and C<EVBACKEND_POLL> are safe to use
497without calling this function, so if you force one of those backends you
498do not need to care.
499 504
500=item ev_loop_fork (loop) 505=item ev_loop_fork (loop)
501 506
502Like C<ev_default_fork>, but acts on an event loop created by 507Like C<ev_default_fork>, but acts on an event loop created by
503C<ev_loop_new>. Yes, you have to call this on every allocated event loop 508C<ev_loop_new>. Yes, you have to call this on every allocated event loop
… …
1433 1438
1434=head3 Watcher-Specific Functions and Data Members 1439=head3 Watcher-Specific Functions and Data Members
1435 1440
1436=over 4 1441=over 4
1437 1442
1438=item ev_child_init (ev_child *, callback, int pid) 1443=item ev_child_init (ev_child *, callback, int pid, int trace)
1439 1444
1440=item ev_child_set (ev_child *, int pid) 1445=item ev_child_set (ev_child *, int pid, int trace)
1441 1446
1442Configures the watcher to wait for status changes of process C<pid> (or 1447Configures the watcher to wait for status changes of process C<pid> (or
1443I<any> process if C<pid> is specified as C<0>). The callback can look 1448I<any> process if C<pid> is specified as C<0>). The callback can look
1444at the C<rstatus> member of the C<ev_child> watcher structure to see 1449at the C<rstatus> member of the C<ev_child> watcher structure to see
1445the status word (use the macros from C<sys/wait.h> and see your systems 1450the status word (use the macros from C<sys/wait.h> and see your systems
1446C<waitpid> documentation). The C<rpid> member contains the pid of the 1451C<waitpid> documentation). The C<rpid> member contains the pid of the
1447process causing the status change. 1452process causing the status change. C<trace> must be either C<0> (only
1453activate the watcher when the process terminates) or C<1> (additionally
1454activate the watcher when the process is stopped or continued).
1448 1455
1449=item int pid [read-only] 1456=item int pid [read-only]
1450 1457
1451The process id this watcher watches out for, or C<0>, meaning any process id. 1458The process id this watcher watches out for, or C<0>, meaning any process id.
1452 1459
… …
1688 static void 1695 static void
1689 idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) 1696 idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents)
1690 { 1697 {
1691 free (w); 1698 free (w);
1692 // now do something you wanted to do when the program has 1699 // now do something you wanted to do when the program has
1693 // no longer asnything immediate to do. 1700 // no longer anything immediate to do.
1694 } 1701 }
1695 1702
1696 struct ev_idle *idle_watcher = malloc (sizeof (struct ev_idle)); 1703 struct ev_idle *idle_watcher = malloc (sizeof (struct ev_idle));
1697 ev_idle_init (idle_watcher, idle_cb); 1704 ev_idle_init (idle_watcher, idle_cb);
1698 ev_idle_start (loop, idle_cb); 1705 ev_idle_start (loop, idle_cb);
… …
2275Example: Define a class with an IO and idle watcher, start one of them in 2282Example: Define a class with an IO and idle watcher, start one of them in
2276the constructor. 2283the constructor.
2277 2284
2278 class myclass 2285 class myclass
2279 { 2286 {
2280 ev_io io; void io_cb (ev::io &w, int revents); 2287 ev::io io; void io_cb (ev::io &w, int revents);
2281 ev_idle idle void idle_cb (ev::idle &w, int revents); 2288 ev:idle idle void idle_cb (ev::idle &w, int revents);
2282 2289
2283 myclass (); 2290 myclass (int fd)
2284 }
2285
2286 myclass::myclass (int fd)
2287 { 2291 {
2288 io .set <myclass, &myclass::io_cb > (this); 2292 io .set <myclass, &myclass::io_cb > (this);
2289 idle.set <myclass, &myclass::idle_cb> (this); 2293 idle.set <myclass, &myclass::idle_cb> (this);
2290 2294
2291 io.start (fd, ev::READ); 2295 io.start (fd, ev::READ);
2296 }
2292 } 2297 };
2293 2298
2294 2299
2295=head1 MACRO MAGIC 2300=head1 MACRO MAGIC
2296 2301
2297Libev can be compiled with a variety of options, the most fundamantal 2302Libev can be compiled with a variety of options, the most fundamantal
… …
2556be detected at runtime. 2561be detected at runtime.
2557 2562
2558=item EV_H 2563=item EV_H
2559 2564
2560The name of the F<ev.h> header file used to include it. The default if 2565The name of the F<ev.h> header file used to include it. The default if
2561undefined is C<"ev.h"> in F<event.h> and F<ev.c>. This can be used to 2566undefined is C<"ev.h"> in F<event.h>, F<ev.c> and F<ev++.h>. This can be
2562virtually rename the F<ev.h> header file in case of conflicts. 2567used to virtually rename the F<ev.h> header file in case of conflicts.
2563 2568
2564=item EV_CONFIG_H 2569=item EV_CONFIG_H
2565 2570
2566If C<EV_STANDALONE> isn't C<1>, this variable can be used to override 2571If C<EV_STANDALONE> isn't C<1>, this variable can be used to override
2567F<ev.c>'s idea of where to find the F<config.h> file, similarly to 2572F<ev.c>'s idea of where to find the F<config.h> file, similarly to
2568C<EV_H>, above. 2573C<EV_H>, above.
2569 2574
2570=item EV_EVENT_H 2575=item EV_EVENT_H
2571 2576
2572Similarly to C<EV_H>, this macro can be used to override F<event.c>'s idea 2577Similarly to C<EV_H>, this macro can be used to override F<event.c>'s idea
2573of how the F<event.h> header can be found, the dfeault is C<"event.h">. 2578of how the F<event.h> header can be found, the default is C<"event.h">.
2574 2579
2575=item EV_PROTOTYPES 2580=item EV_PROTOTYPES
2576 2581
2577If defined to be C<0>, then F<ev.h> will not define any function 2582If defined to be C<0>, then F<ev.h> will not define any function
2578prototypes, but still define all the structs and other symbols. This is 2583prototypes, but still define all the structs and other symbols. This is

Diff Legend

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