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

Comparing libev/ev.pod (file contents):
Revision 1.360 by root, Mon Jan 17 12:11:12 2011 UTC vs.
Revision 1.362 by root, Sun Jan 30 21:10:13 2011 UTC

… …
58 ev_timer_start (loop, &timeout_watcher); 58 ev_timer_start (loop, &timeout_watcher);
59 59
60 // now wait for events to arrive 60 // now wait for events to arrive
61 ev_run (loop, 0); 61 ev_run (loop, 0);
62 62
63 // unloop was called, so exit 63 // break was called, so exit
64 return 0; 64 return 0;
65 } 65 }
66 66
67=head1 ABOUT THIS DOCUMENT 67=head1 ABOUT THIS DOCUMENT
68 68
… …
868anymore. 868anymore.
869 869
870 ... queue jobs here, make sure they register event watchers as long 870 ... queue jobs here, make sure they register event watchers as long
871 ... as they still have work to do (even an idle watcher will do..) 871 ... as they still have work to do (even an idle watcher will do..)
872 ev_run (my_loop, 0); 872 ev_run (my_loop, 0);
873 ... jobs done or somebody called unloop. yeah! 873 ... jobs done or somebody called break. yeah!
874 874
875=item ev_break (loop, how) 875=item ev_break (loop, how)
876 876
877Can be used to make a call to C<ev_run> return early (but only after it 877Can be used to make a call to C<ev_run> return early (but only after it
878has processed all outstanding events). The C<how> argument must be either 878has processed all outstanding events). The C<how> argument must be either
… …
1378 1378
1379Before a watcher can be registered with the event looop it has to be 1379Before a watcher can be registered with the event looop it has to be
1380initialised. This can be done with a call to C<ev_TYPE_init>, or calls to 1380initialised. This can be done with a call to C<ev_TYPE_init>, or calls to
1381C<ev_init> followed by the watcher-specific C<ev_TYPE_set> function. 1381C<ev_init> followed by the watcher-specific C<ev_TYPE_set> function.
1382 1382
1383In this state it is simply some block of memory that is suitable for use 1383In this state it is simply some block of memory that is suitable for
1384in an event loop. It can be moved around, freed, reused etc. at will. 1384use in an event loop. It can be moved around, freed, reused etc. at
1385will - as long as you either keep the memory contents intact, or call
1386C<ev_TYPE_init> again.
1385 1387
1386=item started/running/active 1388=item started/running/active
1387 1389
1388Once a watcher has been started with a call to C<ev_TYPE_start> it becomes 1390Once a watcher has been started with a call to C<ev_TYPE_start> it becomes
1389property of the event loop, and is actively waiting for events. While in 1391property of the event loop, and is actively waiting for events. While in
… …
1417latter will clear any pending state the watcher might be in, regardless 1419latter will clear any pending state the watcher might be in, regardless
1418of whether it was active or not, so stopping a watcher explicitly before 1420of whether it was active or not, so stopping a watcher explicitly before
1419freeing it is often a good idea. 1421freeing it is often a good idea.
1420 1422
1421While stopped (and not pending) the watcher is essentially in the 1423While stopped (and not pending) the watcher is essentially in the
1422initialised state, that is it can be reused, moved, modified in any way 1424initialised state, that is, it can be reused, moved, modified in any way
1423you wish. 1425you wish (but when you trash the memory block, you need to C<ev_TYPE_init>
1426it again).
1424 1427
1425=back 1428=back
1426 1429
1427=head2 WATCHER PRIORITY MODELS 1430=head2 WATCHER PRIORITY MODELS
1428 1431
… …
3544 // now associate this with the loop 3547 // now associate this with the loop
3545 ev_set_userdata (EV_A_ u); 3548 ev_set_userdata (EV_A_ u);
3546 ev_set_invoke_pending_cb (EV_A_ l_invoke); 3549 ev_set_invoke_pending_cb (EV_A_ l_invoke);
3547 ev_set_loop_release_cb (EV_A_ l_release, l_acquire); 3550 ev_set_loop_release_cb (EV_A_ l_release, l_acquire);
3548 3551
3549 // then create the thread running ev_loop 3552 // then create the thread running ev_run
3550 pthread_create (&u->tid, 0, l_run, EV_A); 3553 pthread_create (&u->tid, 0, l_run, EV_A);
3551 } 3554 }
3552 3555
3553The callback for the C<ev_async> watcher does nothing: the watcher is used 3556The callback for the C<ev_async> watcher does nothing: the watcher is used
3554solely to wake up the event loop so it takes notice of any new watchers 3557solely to wake up the event loop so it takes notice of any new watchers

Diff Legend

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