… | |
… | |
4 | <head> |
4 | <head> |
5 | <title>libev</title> |
5 | <title>libev</title> |
6 | <meta name="description" content="Pod documentation for libev" /> |
6 | <meta name="description" content="Pod documentation for libev" /> |
7 | <meta name="inputfile" content="<standard input>" /> |
7 | <meta name="inputfile" content="<standard input>" /> |
8 | <meta name="outputfile" content="<standard output>" /> |
8 | <meta name="outputfile" content="<standard output>" /> |
9 | <meta name="created" content="Fri Nov 23 17:17:04 2007" /> |
9 | <meta name="created" content="Sat Nov 24 08:13:46 2007" /> |
10 | <meta name="generator" content="Pod::Xhtml 1.57" /> |
10 | <meta name="generator" content="Pod::Xhtml 1.57" /> |
11 | <link rel="stylesheet" href="http://res.tst.eu/pod.css"/></head> |
11 | <link rel="stylesheet" href="http://res.tst.eu/pod.css"/></head> |
12 | <body> |
12 | <body> |
13 | <div class="pod"> |
13 | <div class="pod"> |
14 | <!-- INDEX START --> |
14 | <!-- INDEX START --> |
… | |
… | |
21 | <li><a href="#CONVENTIONS">CONVENTIONS</a></li> |
21 | <li><a href="#CONVENTIONS">CONVENTIONS</a></li> |
22 | <li><a href="#TIME_REPRESENTATION">TIME REPRESENTATION</a></li> |
22 | <li><a href="#TIME_REPRESENTATION">TIME REPRESENTATION</a></li> |
23 | <li><a href="#GLOBAL_FUNCTIONS">GLOBAL FUNCTIONS</a></li> |
23 | <li><a href="#GLOBAL_FUNCTIONS">GLOBAL FUNCTIONS</a></li> |
24 | <li><a href="#FUNCTIONS_CONTROLLING_THE_EVENT_LOOP">FUNCTIONS CONTROLLING THE EVENT LOOP</a></li> |
24 | <li><a href="#FUNCTIONS_CONTROLLING_THE_EVENT_LOOP">FUNCTIONS CONTROLLING THE EVENT LOOP</a></li> |
25 | <li><a href="#ANATOMY_OF_A_WATCHER">ANATOMY OF A WATCHER</a> |
25 | <li><a href="#ANATOMY_OF_A_WATCHER">ANATOMY OF A WATCHER</a> |
|
|
26 | <ul><li><a href="#SUMMARY_OF_GENERIC_WATCHER_FUNCTIONS">SUMMARY OF GENERIC WATCHER FUNCTIONS</a></li> |
26 | <ul><li><a href="#ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</a></li> |
27 | <li><a href="#ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</a></li> |
27 | </ul> |
28 | </ul> |
28 | </li> |
29 | </li> |
29 | <li><a href="#WATCHER_TYPES">WATCHER TYPES</a> |
30 | <li><a href="#WATCHER_TYPES">WATCHER TYPES</a> |
30 | <ul><li><a href="#code_ev_io_code_is_this_file_descrip"><code>ev_io</code> - is this file descriptor readable or writable</a></li> |
31 | <ul><li><a href="#code_ev_io_code_is_this_file_descrip"><code>ev_io</code> - is this file descriptor readable or writable</a></li> |
31 | <li><a href="#code_ev_timer_code_relative_and_opti"><code>ev_timer</code> - relative and optionally recurring timeouts</a></li> |
32 | <li><a href="#code_ev_timer_code_relative_and_opti"><code>ev_timer</code> - relative and optionally recurring timeouts</a></li> |
32 | <li><a href="#code_ev_periodic_code_to_cron_or_not"><code>ev_periodic</code> - to cron or not to cron</a></li> |
33 | <li><a href="#code_ev_periodic_code_to_cron_or_not"><code>ev_periodic</code> - to cron or not to cron</a></li> |
33 | <li><a href="#code_ev_signal_code_signal_me_when_a"><code>ev_signal</code> - signal me when a signal gets signalled</a></li> |
34 | <li><a href="#code_ev_signal_code_signal_me_when_a"><code>ev_signal</code> - signal me when a signal gets signalled</a></li> |
34 | <li><a href="#code_ev_child_code_wait_for_pid_stat"><code>ev_child</code> - wait for pid status changes</a></li> |
35 | <li><a href="#code_ev_child_code_wait_for_pid_stat"><code>ev_child</code> - wait for pid status changes</a></li> |
35 | <li><a href="#code_ev_idle_code_when_you_ve_got_no"><code>ev_idle</code> - when you've got nothing better to do</a></li> |
36 | <li><a href="#code_ev_idle_code_when_you_ve_got_no"><code>ev_idle</code> - when you've got nothing better to do</a></li> |
36 | <li><a href="#code_ev_prepare_code_and_code_ev_che"><code>ev_prepare</code> and <code>ev_check</code> - customise your event loop</a></li> |
37 | <li><a href="#code_ev_prepare_code_and_code_ev_che"><code>ev_prepare</code> and <code>ev_check</code> - customise your event loop</a></li> |
|
|
38 | <li><a href="#code_ev_embed_code_when_one_backend_"><code>ev_embed</code> - when one backend isn't enough</a></li> |
37 | </ul> |
39 | </ul> |
38 | </li> |
40 | </li> |
39 | <li><a href="#OTHER_FUNCTIONS">OTHER FUNCTIONS</a></li> |
41 | <li><a href="#OTHER_FUNCTIONS">OTHER FUNCTIONS</a></li> |
40 | <li><a href="#LIBEVENT_EMULATION">LIBEVENT EMULATION</a></li> |
42 | <li><a href="#LIBEVENT_EMULATION">LIBEVENT EMULATION</a></li> |
41 | <li><a href="#C_SUPPORT">C++ SUPPORT</a></li> |
43 | <li><a href="#C_SUPPORT">C++ SUPPORT</a></li> |
… | |
… | |
156 | recommended for this platform. This set is often smaller than the one |
158 | recommended for this platform. This set is often smaller than the one |
157 | returned by <code>ev_supported_backends</code>, as for example kqueue is broken on |
159 | returned by <code>ev_supported_backends</code>, as for example kqueue is broken on |
158 | most BSDs and will not be autodetected unless you explicitly request it |
160 | most BSDs and will not be autodetected unless you explicitly request it |
159 | (assuming you know what you are doing). This is the set of backends that |
161 | (assuming you know what you are doing). This is the set of backends that |
160 | libev will probe for if you specify no backends explicitly.</p> |
162 | libev will probe for if you specify no backends explicitly.</p> |
|
|
163 | </dd> |
|
|
164 | <dt>unsigned int ev_embeddable_backends ()</dt> |
|
|
165 | <dd> |
|
|
166 | <p>Returns the set of backends that are embeddable in other event loops. This |
|
|
167 | is the theoretical, all-platform, value. To find which backends |
|
|
168 | might be supported on the current system, you would need to look at |
|
|
169 | <code>ev_embeddable_backends () & ev_supported_backends ()</code>, likewise for |
|
|
170 | recommended ones.</p> |
|
|
171 | <p>See the description of <code>ev_embed</code> watchers for more info.</p> |
161 | </dd> |
172 | </dd> |
162 | <dt>ev_set_allocator (void *(*cb)(void *ptr, long size))</dt> |
173 | <dt>ev_set_allocator (void *(*cb)(void *ptr, long size))</dt> |
163 | <dd> |
174 | <dd> |
164 | <p>Sets the allocation function to use (the prototype is similar to the |
175 | <p>Sets the allocation function to use (the prototype is similar to the |
165 | realloc C function, the semantics are identical). It is used to allocate |
176 | realloc C function, the semantics are identical). It is used to allocate |
… | |
… | |
525 | with a watcher-specific start function (<code>ev_<type>_start (loop, watcher |
536 | with a watcher-specific start function (<code>ev_<type>_start (loop, watcher |
526 | *)</code>), and you can stop watching for events at any time by calling the |
537 | *)</code>), and you can stop watching for events at any time by calling the |
527 | corresponding stop function (<code>ev_<type>_stop (loop, watcher *)</code>.</p> |
538 | corresponding stop function (<code>ev_<type>_stop (loop, watcher *)</code>.</p> |
528 | <p>As long as your watcher is active (has been started but not stopped) you |
539 | <p>As long as your watcher is active (has been started but not stopped) you |
529 | must not touch the values stored in it. Most specifically you must never |
540 | must not touch the values stored in it. Most specifically you must never |
530 | reinitialise it or call its set macro.</p> |
541 | reinitialise it or call its <code>set</code> macro.</p> |
531 | <p>You can check whether an event is active by calling the <code>ev_is_active |
|
|
532 | (watcher *)</code> macro. To see whether an event is outstanding (but the |
|
|
533 | callback for it has not been called yet) you can use the <code>ev_is_pending |
|
|
534 | (watcher *)</code> macro.</p> |
|
|
535 | <p>Each and every callback receives the event loop pointer as first, the |
542 | <p>Each and every callback receives the event loop pointer as first, the |
536 | registered watcher structure as second, and a bitset of received events as |
543 | registered watcher structure as second, and a bitset of received events as |
537 | third argument.</p> |
544 | third argument.</p> |
538 | <p>The received events usually include a single bit per event type received |
545 | <p>The received events usually include a single bit per event type received |
539 | (you can receive multiple events at the same time). The possible bit masks |
546 | (you can receive multiple events at the same time). The possible bit masks |
… | |
… | |
588 | your callbacks is well-written it can just attempt the operation and cope |
595 | your callbacks is well-written it can just attempt the operation and cope |
589 | with the error from read() or write(). This will not work in multithreaded |
596 | with the error from read() or write(). This will not work in multithreaded |
590 | programs, though, so beware.</p> |
597 | programs, though, so beware.</p> |
591 | </dd> |
598 | </dd> |
592 | </dl> |
599 | </dl> |
|
|
600 | |
|
|
601 | </div> |
|
|
602 | <h2 id="SUMMARY_OF_GENERIC_WATCHER_FUNCTIONS">SUMMARY OF GENERIC WATCHER FUNCTIONS</h2> |
|
|
603 | <div id="SUMMARY_OF_GENERIC_WATCHER_FUNCTIONS-2"> |
|
|
604 | <p>In the following description, <code>TYPE</code> stands for the watcher type, |
|
|
605 | e.g. <code>timer</code> for <code>ev_timer</code> watchers and <code>io</code> for <code>ev_io</code> watchers.</p> |
|
|
606 | <dl> |
|
|
607 | <dt><code>ev_init</code> (ev_TYPE *watcher, callback)</dt> |
|
|
608 | <dd> |
|
|
609 | <p>This macro initialises the generic portion of a watcher. The contents |
|
|
610 | of the watcher object can be arbitrary (so <code>malloc</code> will do). Only |
|
|
611 | the generic parts of the watcher are initialised, you <i>need</i> to call |
|
|
612 | the type-specific <code>ev_TYPE_set</code> macro afterwards to initialise the |
|
|
613 | type-specific parts. For each type there is also a <code>ev_TYPE_init</code> macro |
|
|
614 | which rolls both calls into one.</p> |
|
|
615 | <p>You can reinitialise a watcher at any time as long as it has been stopped |
|
|
616 | (or never started) and there are no pending events outstanding.</p> |
|
|
617 | <p>The callbakc is always of type <code>void (*)(ev_loop *loop, ev_TYPE *watcher, |
|
|
618 | int revents)</code>.</p> |
|
|
619 | </dd> |
|
|
620 | <dt><code>ev_TYPE_set</code> (ev_TYPE *, [args])</dt> |
|
|
621 | <dd> |
|
|
622 | <p>This macro initialises the type-specific parts of a watcher. You need to |
|
|
623 | call <code>ev_init</code> at least once before you call this macro, but you can |
|
|
624 | call <code>ev_TYPE_set</code> any number of times. You must not, however, call this |
|
|
625 | macro on a watcher that is active (it can be pending, however, which is a |
|
|
626 | difference to the <code>ev_init</code> macro).</p> |
|
|
627 | <p>Although some watcher types do not have type-specific arguments |
|
|
628 | (e.g. <code>ev_prepare</code>) you still need to call its <code>set</code> macro.</p> |
|
|
629 | </dd> |
|
|
630 | <dt><code>ev_TYPE_init</code> (ev_TYPE *watcher, callback, [args])</dt> |
|
|
631 | <dd> |
|
|
632 | <p>This convinience macro rolls both <code>ev_init</code> and <code>ev_TYPE_set</code> macro |
|
|
633 | calls into a single call. This is the most convinient method to initialise |
|
|
634 | a watcher. The same limitations apply, of course.</p> |
|
|
635 | </dd> |
|
|
636 | <dt><code>ev_TYPE_start</code> (loop *, ev_TYPE *watcher)</dt> |
|
|
637 | <dd> |
|
|
638 | <p>Starts (activates) the given watcher. Only active watchers will receive |
|
|
639 | events. If the watcher is already active nothing will happen.</p> |
|
|
640 | </dd> |
|
|
641 | <dt><code>ev_TYPE_stop</code> (loop *, ev_TYPE *watcher)</dt> |
|
|
642 | <dd> |
|
|
643 | <p>Stops the given watcher again (if active) and clears the pending |
|
|
644 | status. It is possible that stopped watchers are pending (for example, |
|
|
645 | non-repeating timers are being stopped when they become pending), but |
|
|
646 | <code>ev_TYPE_stop</code> ensures that the watcher is neither active nor pending. If |
|
|
647 | you want to free or reuse the memory used by the watcher it is therefore a |
|
|
648 | good idea to always call its <code>ev_TYPE_stop</code> function.</p> |
|
|
649 | </dd> |
|
|
650 | <dt>bool ev_is_active (ev_TYPE *watcher)</dt> |
|
|
651 | <dd> |
|
|
652 | <p>Returns a true value iff the watcher is active (i.e. it has been started |
|
|
653 | and not yet been stopped). As long as a watcher is active you must not modify |
|
|
654 | it.</p> |
|
|
655 | </dd> |
|
|
656 | <dt>bool ev_is_pending (ev_TYPE *watcher)</dt> |
|
|
657 | <dd> |
|
|
658 | <p>Returns a true value iff the watcher is pending, (i.e. it has outstanding |
|
|
659 | events but its callback has not yet been invoked). As long as a watcher |
|
|
660 | is pending (but not active) you must not call an init function on it (but |
|
|
661 | <code>ev_TYPE_set</code> is safe) and you must make sure the watcher is available to |
|
|
662 | libev (e.g. you cnanot <code>free ()</code> it).</p> |
|
|
663 | </dd> |
|
|
664 | <dt>callback = ev_cb (ev_TYPE *watcher)</dt> |
|
|
665 | <dd> |
|
|
666 | <p>Returns the callback currently set on the watcher.</p> |
|
|
667 | </dd> |
|
|
668 | <dt>ev_cb_set (ev_TYPE *watcher, callback)</dt> |
|
|
669 | <dd> |
|
|
670 | <p>Change the callback. You can change the callback at virtually any time |
|
|
671 | (modulo threads).</p> |
|
|
672 | </dd> |
|
|
673 | </dl> |
|
|
674 | |
|
|
675 | |
|
|
676 | |
|
|
677 | |
593 | |
678 | |
594 | </div> |
679 | </div> |
595 | <h2 id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</h2> |
680 | <h2 id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</h2> |
596 | <div id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH-2"> |
681 | <div id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH-2"> |
597 | <p>Each watcher has, by default, a member <code>void *data</code> that you can change |
682 | <p>Each watcher has, by default, a member <code>void *data</code> that you can change |
… | |
… | |
931 | <p>Configures the watcher to trigger on the given signal number (usually one |
1016 | <p>Configures the watcher to trigger on the given signal number (usually one |
932 | of the <code>SIGxxx</code> constants).</p> |
1017 | of the <code>SIGxxx</code> constants).</p> |
933 | </dd> |
1018 | </dd> |
934 | </dl> |
1019 | </dl> |
935 | |
1020 | |
|
|
1021 | |
|
|
1022 | |
|
|
1023 | |
|
|
1024 | |
936 | </div> |
1025 | </div> |
937 | <h2 id="code_ev_child_code_wait_for_pid_stat"><code>ev_child</code> - wait for pid status changes</h2> |
1026 | <h2 id="code_ev_child_code_wait_for_pid_stat"><code>ev_child</code> - wait for pid status changes</h2> |
938 | <div id="code_ev_child_code_wait_for_pid_stat-2"> |
1027 | <div id="code_ev_child_code_wait_for_pid_stat-2"> |
939 | <p>Child watchers trigger when your process receives a SIGCHLD in response to |
1028 | <p>Child watchers trigger when your process receives a SIGCHLD in response to |
940 | some child status changes (most typically when a child of yours dies).</p> |
1029 | some child status changes (most typically when a child of yours dies).</p> |
… | |
… | |
1013 | <h2 id="code_ev_prepare_code_and_code_ev_che"><code>ev_prepare</code> and <code>ev_check</code> - customise your event loop</h2> |
1102 | <h2 id="code_ev_prepare_code_and_code_ev_che"><code>ev_prepare</code> and <code>ev_check</code> - customise your event loop</h2> |
1014 | <div id="code_ev_prepare_code_and_code_ev_che-2"> |
1103 | <div id="code_ev_prepare_code_and_code_ev_che-2"> |
1015 | <p>Prepare and check watchers are usually (but not always) used in tandem: |
1104 | <p>Prepare and check watchers are usually (but not always) used in tandem: |
1016 | prepare watchers get invoked before the process blocks and check watchers |
1105 | prepare watchers get invoked before the process blocks and check watchers |
1017 | afterwards.</p> |
1106 | afterwards.</p> |
1018 | <p>Their main purpose is to integrate other event mechanisms into libev. This |
1107 | <p>Their main purpose is to integrate other event mechanisms into libev and |
1019 | could be used, for example, to track variable changes, implement your own |
1108 | their use is somewhat advanced. This could be used, for example, to track |
1020 | watchers, integrate net-snmp or a coroutine library and lots more.</p> |
1109 | variable changes, implement your own watchers, integrate net-snmp or a |
|
|
1110 | coroutine library and lots more.</p> |
1021 | <p>This is done by examining in each prepare call which file descriptors need |
1111 | <p>This is done by examining in each prepare call which file descriptors need |
1022 | to be watched by the other library, registering <code>ev_io</code> watchers for |
1112 | to be watched by the other library, registering <code>ev_io</code> watchers for |
1023 | them and starting an <code>ev_timer</code> watcher for any timeouts (many libraries |
1113 | them and starting an <code>ev_timer</code> watcher for any timeouts (many libraries |
1024 | provide just this functionality). Then, in the check watcher you check for |
1114 | provide just this functionality). Then, in the check watcher you check for |
1025 | any events that occured (by checking the pending status of all watchers |
1115 | any events that occured (by checking the pending status of all watchers |
… | |
… | |
1042 | parameters of any kind. There are <code>ev_prepare_set</code> and <code>ev_check_set</code> |
1132 | parameters of any kind. There are <code>ev_prepare_set</code> and <code>ev_check_set</code> |
1043 | macros, but using them is utterly, utterly and completely pointless.</p> |
1133 | macros, but using them is utterly, utterly and completely pointless.</p> |
1044 | </dd> |
1134 | </dd> |
1045 | </dl> |
1135 | </dl> |
1046 | <p>Example: *TODO*.</p> |
1136 | <p>Example: *TODO*.</p> |
|
|
1137 | |
|
|
1138 | |
|
|
1139 | |
|
|
1140 | |
|
|
1141 | |
|
|
1142 | </div> |
|
|
1143 | <h2 id="code_ev_embed_code_when_one_backend_"><code>ev_embed</code> - when one backend isn't enough</h2> |
|
|
1144 | <div id="code_ev_embed_code_when_one_backend_-2"> |
|
|
1145 | <p>This is a rather advanced watcher type that lets you embed one event loop |
|
|
1146 | into another (currently only <code>ev_io</code> events are supported in the embedded |
|
|
1147 | loop, other types of watchers might be handled in a delayed or incorrect |
|
|
1148 | fashion and must not be used).</p> |
|
|
1149 | <p>There are primarily two reasons you would want that: work around bugs and |
|
|
1150 | prioritise I/O.</p> |
|
|
1151 | <p>As an example for a bug workaround, the kqueue backend might only support |
|
|
1152 | sockets on some platform, so it is unusable as generic backend, but you |
|
|
1153 | still want to make use of it because you have many sockets and it scales |
|
|
1154 | so nicely. In this case, you would create a kqueue-based loop and embed it |
|
|
1155 | into your default loop (which might use e.g. poll). Overall operation will |
|
|
1156 | be a bit slower because first libev has to poll and then call kevent, but |
|
|
1157 | at least you can use both at what they are best.</p> |
|
|
1158 | <p>As for prioritising I/O: rarely you have the case where some fds have |
|
|
1159 | to be watched and handled very quickly (with low latency), and even |
|
|
1160 | priorities and idle watchers might have too much overhead. In this case |
|
|
1161 | you would put all the high priority stuff in one loop and all the rest in |
|
|
1162 | a second one, and embed the second one in the first.</p> |
|
|
1163 | <p>As long as the watcher is active, the callback will be invoked every time |
|
|
1164 | there might be events pending in the embedded loop. The callback must then |
|
|
1165 | call <code>ev_embed_sweep (mainloop, watcher)</code> to make a single sweep and invoke |
|
|
1166 | their callbacks (you could also start an idle watcher to give the embedded |
|
|
1167 | loop strictly lower priority for example). You can also set the callback |
|
|
1168 | to <code>0</code>, in which case the embed watcher will automatically execute the |
|
|
1169 | embedded loop sweep.</p> |
|
|
1170 | <p>As long as the watcher is started it will automatically handle events. The |
|
|
1171 | callback will be invoked whenever some events have been handled. You can |
|
|
1172 | set the callback to <code>0</code> to avoid having to specify one if you are not |
|
|
1173 | interested in that.</p> |
|
|
1174 | <p>Also, there have not currently been made special provisions for forking: |
|
|
1175 | when you fork, you not only have to call <code>ev_loop_fork</code> on both loops, |
|
|
1176 | but you will also have to stop and restart any <code>ev_embed</code> watchers |
|
|
1177 | yourself.</p> |
|
|
1178 | <p>Unfortunately, not all backends are embeddable, only the ones returned by |
|
|
1179 | <code>ev_embeddable_backends</code> are, which, unfortunately, does not include any |
|
|
1180 | portable one.</p> |
|
|
1181 | <p>So when you want to use this feature you will always have to be prepared |
|
|
1182 | that you cannot get an embeddable loop. The recommended way to get around |
|
|
1183 | this is to have a separate variables for your embeddable loop, try to |
|
|
1184 | create it, and if that fails, use the normal loop for everything:</p> |
|
|
1185 | <pre> struct ev_loop *loop_hi = ev_default_init (0); |
|
|
1186 | struct ev_loop *loop_lo = 0; |
|
|
1187 | struct ev_embed embed; |
|
|
1188 | |
|
|
1189 | // see if there is a chance of getting one that works |
|
|
1190 | // (remember that a flags value of 0 means autodetection) |
|
|
1191 | loop_lo = ev_embeddable_backends () & ev_recommended_backends () |
|
|
1192 | ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ()) |
|
|
1193 | : 0; |
|
|
1194 | |
|
|
1195 | // if we got one, then embed it, otherwise default to loop_hi |
|
|
1196 | if (loop_lo) |
|
|
1197 | { |
|
|
1198 | ev_embed_init (&embed, 0, loop_lo); |
|
|
1199 | ev_embed_start (loop_hi, &embed); |
|
|
1200 | } |
|
|
1201 | else |
|
|
1202 | loop_lo = loop_hi; |
|
|
1203 | |
|
|
1204 | </pre> |
|
|
1205 | <dl> |
|
|
1206 | <dt>ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)</dt> |
|
|
1207 | <dt>ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)</dt> |
|
|
1208 | <dd> |
|
|
1209 | <p>Configures the watcher to embed the given loop, which must be |
|
|
1210 | embeddable. If the callback is <code>0</code>, then <code>ev_embed_sweep</code> will be |
|
|
1211 | invoked automatically, otherwise it is the responsibility of the callback |
|
|
1212 | to invoke it (it will continue to be called until the sweep has been done, |
|
|
1213 | if you do not want thta, you need to temporarily stop the embed watcher).</p> |
|
|
1214 | </dd> |
|
|
1215 | <dt>ev_embed_sweep (loop, ev_embed *)</dt> |
|
|
1216 | <dd> |
|
|
1217 | <p>Make a single, non-blocking sweep over the embedded loop. This works |
|
|
1218 | similarly to <code>ev_loop (embedded_loop, EVLOOP_NONBLOCK)</code>, but in the most |
|
|
1219 | apropriate way for embedded loops.</p> |
|
|
1220 | </dd> |
|
|
1221 | </dl> |
1047 | |
1222 | |
1048 | |
1223 | |
1049 | |
1224 | |
1050 | |
1225 | |
1051 | |
1226 | |
… | |
… | |
1082 | |
1257 | |
1083 | ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0); |
1258 | ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0); |
1084 | |
1259 | |
1085 | </pre> |
1260 | </pre> |
1086 | </dd> |
1261 | </dd> |
1087 | <dt>ev_feed_event (loop, watcher, int events)</dt> |
1262 | <dt>ev_feed_event (ev_loop *, watcher *, int revents)</dt> |
1088 | <dd> |
1263 | <dd> |
1089 | <p>Feeds the given event set into the event loop, as if the specified event |
1264 | <p>Feeds the given event set into the event loop, as if the specified event |
1090 | had happened for the specified watcher (which must be a pointer to an |
1265 | had happened for the specified watcher (which must be a pointer to an |
1091 | initialised but not necessarily started event watcher).</p> |
1266 | initialised but not necessarily started event watcher).</p> |
1092 | </dd> |
1267 | </dd> |
1093 | <dt>ev_feed_fd_event (loop, int fd, int revents)</dt> |
1268 | <dt>ev_feed_fd_event (ev_loop *, int fd, int revents)</dt> |
1094 | <dd> |
1269 | <dd> |
1095 | <p>Feed an event on the given fd, as if a file descriptor backend detected |
1270 | <p>Feed an event on the given fd, as if a file descriptor backend detected |
1096 | the given events it.</p> |
1271 | the given events it.</p> |
1097 | </dd> |
1272 | </dd> |
1098 | <dt>ev_feed_signal_event (loop, int signum)</dt> |
1273 | <dt>ev_feed_signal_event (ev_loop *loop, int signum)</dt> |
1099 | <dd> |
1274 | <dd> |
1100 | <p>Feed an event as if the given signal occured (loop must be the default loop!).</p> |
1275 | <p>Feed an event as if the given signal occured (<code>loop</code> must be the default |
|
|
1276 | loop!).</p> |
1101 | </dd> |
1277 | </dd> |
1102 | </dl> |
1278 | </dl> |
1103 | |
1279 | |
1104 | |
1280 | |
1105 | |
1281 | |