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

Comparing libev/ev.pod (file contents):
Revision 1.118 by root, Thu Jan 10 06:00:55 2008 UTC vs.
Revision 1.121 by root, Mon Jan 28 12:13:54 2008 UTC

… …
483Like 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
484earlier call to C<ev_loop_new>. 484earlier call to C<ev_loop_new>.
485 485
486=item ev_default_fork () 486=item ev_default_fork ()
487 487
488This function sets a flag that causes subsequent C<ev_loop> iterations
488This function reinitialises the kernel state for backends that have 489to reinitialise the kernel state for backends that have one. Despite the
489one. 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
490after 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
491again 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.
492 494
493You 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
494only 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
495fork+exec, you don't have to call it. 497you just fork+exec, you don't have to call it at all.
496 498
497The 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
498it 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
499quite nicely into a call to C<pthread_atfork>: 501quite nicely into a call to C<pthread_atfork>:
500 502
501 pthread_atfork (0, 0, ev_default_fork); 503 pthread_atfork (0, 0, ev_default_fork);
502
503At the moment, C<EVBACKEND_SELECT> and C<EVBACKEND_POLL> are safe to use
504without calling this function, so if you force one of those backends you
505do not need to care.
506 504
507=item ev_loop_fork (loop) 505=item ev_loop_fork (loop)
508 506
509Like 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
510C<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
… …
1440 1438
1441=head3 Watcher-Specific Functions and Data Members 1439=head3 Watcher-Specific Functions and Data Members
1442 1440
1443=over 4 1441=over 4
1444 1442
1445=item ev_child_init (ev_child *, callback, int pid) 1443=item ev_child_init (ev_child *, callback, int pid, int trace)
1446 1444
1447=item ev_child_set (ev_child *, int pid) 1445=item ev_child_set (ev_child *, int pid, int trace)
1448 1446
1449Configures 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
1450I<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
1451at 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
1452the 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
1453C<waitpid> documentation). The C<rpid> member contains the pid of the 1451C<waitpid> documentation). The C<rpid> member contains the pid of the
1454process 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).
1455 1455
1456=item int pid [read-only] 1456=item int pid [read-only]
1457 1457
1458The 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.
1459 1459
… …
1695 static void 1695 static void
1696 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)
1697 { 1697 {
1698 free (w); 1698 free (w);
1699 // now do something you wanted to do when the program has 1699 // now do something you wanted to do when the program has
1700 // no longer asnything immediate to do. 1700 // no longer anything immediate to do.
1701 } 1701 }
1702 1702
1703 struct ev_idle *idle_watcher = malloc (sizeof (struct ev_idle)); 1703 struct ev_idle *idle_watcher = malloc (sizeof (struct ev_idle));
1704 ev_idle_init (idle_watcher, idle_cb); 1704 ev_idle_init (idle_watcher, idle_cb);
1705 ev_idle_start (loop, idle_cb); 1705 ev_idle_start (loop, idle_cb);
… …
2282Example: 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
2283the constructor. 2283the constructor.
2284 2284
2285 class myclass 2285 class myclass
2286 { 2286 {
2287 ev_io io; void io_cb (ev::io &w, int revents); 2287 ev::io io; void io_cb (ev::io &w, int revents);
2288 ev_idle idle void idle_cb (ev::idle &w, int revents); 2288 ev:idle idle void idle_cb (ev::idle &w, int revents);
2289 2289
2290 myclass (); 2290 myclass (int fd)
2291 }
2292
2293 myclass::myclass (int fd)
2294 { 2291 {
2295 io .set <myclass, &myclass::io_cb > (this); 2292 io .set <myclass, &myclass::io_cb > (this);
2296 idle.set <myclass, &myclass::idle_cb> (this); 2293 idle.set <myclass, &myclass::idle_cb> (this);
2297 2294
2298 io.start (fd, ev::READ); 2295 io.start (fd, ev::READ);
2296 }
2299 } 2297 };
2300 2298
2301 2299
2302=head1 MACRO MAGIC 2300=head1 MACRO MAGIC
2303 2301
2304Libev can be compiled with a variety of options, the most fundamantal 2302Libev can be compiled with a variety of options, the most fundamantal

Diff Legend

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