… | |
… | |
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="Sat Nov 24 05:58:35 2007" /> |
9 | <meta name="created" content="Sat Nov 24 10:48:32 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> |
… | |
… | |
363 | </pre> |
364 | </pre> |
364 | </dd> |
365 | </dd> |
365 | <dt>ev_default_destroy ()</dt> |
366 | <dt>ev_default_destroy ()</dt> |
366 | <dd> |
367 | <dd> |
367 | <p>Destroys the default loop again (frees all memory and kernel state |
368 | <p>Destroys the default loop again (frees all memory and kernel state |
368 | etc.). This stops all registered event watchers (by not touching them in |
369 | etc.). None of the active event watchers will be stopped in the normal |
369 | any way whatsoever, although you cannot rely on this :).</p> |
370 | sense, so e.g. <code>ev_is_active</code> might still return true. It is your |
|
|
371 | responsibility to either stop all watchers cleanly yoursef <i>before</i> |
|
|
372 | calling this function, or cope with the fact afterwards (which is usually |
|
|
373 | the easiest thing, youc na just ignore the watchers and/or <code>free ()</code> them |
|
|
374 | for example).</p> |
370 | </dd> |
375 | </dd> |
371 | <dt>ev_loop_destroy (loop)</dt> |
376 | <dt>ev_loop_destroy (loop)</dt> |
372 | <dd> |
377 | <dd> |
373 | <p>Like <code>ev_default_destroy</code>, but destroys an event loop created by an |
378 | <p>Like <code>ev_default_destroy</code>, but destroys an event loop created by an |
374 | earlier call to <code>ev_loop_new</code>.</p> |
379 | earlier call to <code>ev_loop_new</code>.</p> |
… | |
… | |
535 | with a watcher-specific start function (<code>ev_<type>_start (loop, watcher |
540 | with a watcher-specific start function (<code>ev_<type>_start (loop, watcher |
536 | *)</code>), and you can stop watching for events at any time by calling the |
541 | *)</code>), and you can stop watching for events at any time by calling the |
537 | corresponding stop function (<code>ev_<type>_stop (loop, watcher *)</code>.</p> |
542 | corresponding stop function (<code>ev_<type>_stop (loop, watcher *)</code>.</p> |
538 | <p>As long as your watcher is active (has been started but not stopped) you |
543 | <p>As long as your watcher is active (has been started but not stopped) you |
539 | must not touch the values stored in it. Most specifically you must never |
544 | must not touch the values stored in it. Most specifically you must never |
540 | reinitialise it or call its set macro.</p> |
545 | reinitialise it or call its <code>set</code> macro.</p> |
541 | <p>You can check whether an event is active by calling the <code>ev_is_active |
|
|
542 | (watcher *)</code> macro. To see whether an event is outstanding (but the |
|
|
543 | callback for it has not been called yet) you can use the <code>ev_is_pending |
|
|
544 | (watcher *)</code> macro.</p> |
|
|
545 | <p>Each and every callback receives the event loop pointer as first, the |
546 | <p>Each and every callback receives the event loop pointer as first, the |
546 | registered watcher structure as second, and a bitset of received events as |
547 | registered watcher structure as second, and a bitset of received events as |
547 | third argument.</p> |
548 | third argument.</p> |
548 | <p>The received events usually include a single bit per event type received |
549 | <p>The received events usually include a single bit per event type received |
549 | (you can receive multiple events at the same time). The possible bit masks |
550 | (you can receive multiple events at the same time). The possible bit masks |
… | |
… | |
598 | your callbacks is well-written it can just attempt the operation and cope |
599 | your callbacks is well-written it can just attempt the operation and cope |
599 | with the error from read() or write(). This will not work in multithreaded |
600 | with the error from read() or write(). This will not work in multithreaded |
600 | programs, though, so beware.</p> |
601 | programs, though, so beware.</p> |
601 | </dd> |
602 | </dd> |
602 | </dl> |
603 | </dl> |
|
|
604 | |
|
|
605 | </div> |
|
|
606 | <h2 id="SUMMARY_OF_GENERIC_WATCHER_FUNCTIONS">SUMMARY OF GENERIC WATCHER FUNCTIONS</h2> |
|
|
607 | <div id="SUMMARY_OF_GENERIC_WATCHER_FUNCTIONS-2"> |
|
|
608 | <p>In the following description, <code>TYPE</code> stands for the watcher type, |
|
|
609 | e.g. <code>timer</code> for <code>ev_timer</code> watchers and <code>io</code> for <code>ev_io</code> watchers.</p> |
|
|
610 | <dl> |
|
|
611 | <dt><code>ev_init</code> (ev_TYPE *watcher, callback)</dt> |
|
|
612 | <dd> |
|
|
613 | <p>This macro initialises the generic portion of a watcher. The contents |
|
|
614 | of the watcher object can be arbitrary (so <code>malloc</code> will do). Only |
|
|
615 | the generic parts of the watcher are initialised, you <i>need</i> to call |
|
|
616 | the type-specific <code>ev_TYPE_set</code> macro afterwards to initialise the |
|
|
617 | type-specific parts. For each type there is also a <code>ev_TYPE_init</code> macro |
|
|
618 | which rolls both calls into one.</p> |
|
|
619 | <p>You can reinitialise a watcher at any time as long as it has been stopped |
|
|
620 | (or never started) and there are no pending events outstanding.</p> |
|
|
621 | <p>The callbakc is always of type <code>void (*)(ev_loop *loop, ev_TYPE *watcher, |
|
|
622 | int revents)</code>.</p> |
|
|
623 | </dd> |
|
|
624 | <dt><code>ev_TYPE_set</code> (ev_TYPE *, [args])</dt> |
|
|
625 | <dd> |
|
|
626 | <p>This macro initialises the type-specific parts of a watcher. You need to |
|
|
627 | call <code>ev_init</code> at least once before you call this macro, but you can |
|
|
628 | call <code>ev_TYPE_set</code> any number of times. You must not, however, call this |
|
|
629 | macro on a watcher that is active (it can be pending, however, which is a |
|
|
630 | difference to the <code>ev_init</code> macro).</p> |
|
|
631 | <p>Although some watcher types do not have type-specific arguments |
|
|
632 | (e.g. <code>ev_prepare</code>) you still need to call its <code>set</code> macro.</p> |
|
|
633 | </dd> |
|
|
634 | <dt><code>ev_TYPE_init</code> (ev_TYPE *watcher, callback, [args])</dt> |
|
|
635 | <dd> |
|
|
636 | <p>This convinience macro rolls both <code>ev_init</code> and <code>ev_TYPE_set</code> macro |
|
|
637 | calls into a single call. This is the most convinient method to initialise |
|
|
638 | a watcher. The same limitations apply, of course.</p> |
|
|
639 | </dd> |
|
|
640 | <dt><code>ev_TYPE_start</code> (loop *, ev_TYPE *watcher)</dt> |
|
|
641 | <dd> |
|
|
642 | <p>Starts (activates) the given watcher. Only active watchers will receive |
|
|
643 | events. If the watcher is already active nothing will happen.</p> |
|
|
644 | </dd> |
|
|
645 | <dt><code>ev_TYPE_stop</code> (loop *, ev_TYPE *watcher)</dt> |
|
|
646 | <dd> |
|
|
647 | <p>Stops the given watcher again (if active) and clears the pending |
|
|
648 | status. It is possible that stopped watchers are pending (for example, |
|
|
649 | non-repeating timers are being stopped when they become pending), but |
|
|
650 | <code>ev_TYPE_stop</code> ensures that the watcher is neither active nor pending. If |
|
|
651 | you want to free or reuse the memory used by the watcher it is therefore a |
|
|
652 | good idea to always call its <code>ev_TYPE_stop</code> function.</p> |
|
|
653 | </dd> |
|
|
654 | <dt>bool ev_is_active (ev_TYPE *watcher)</dt> |
|
|
655 | <dd> |
|
|
656 | <p>Returns a true value iff the watcher is active (i.e. it has been started |
|
|
657 | and not yet been stopped). As long as a watcher is active you must not modify |
|
|
658 | it.</p> |
|
|
659 | </dd> |
|
|
660 | <dt>bool ev_is_pending (ev_TYPE *watcher)</dt> |
|
|
661 | <dd> |
|
|
662 | <p>Returns a true value iff the watcher is pending, (i.e. it has outstanding |
|
|
663 | events but its callback has not yet been invoked). As long as a watcher |
|
|
664 | is pending (but not active) you must not call an init function on it (but |
|
|
665 | <code>ev_TYPE_set</code> is safe) and you must make sure the watcher is available to |
|
|
666 | libev (e.g. you cnanot <code>free ()</code> it).</p> |
|
|
667 | </dd> |
|
|
668 | <dt>callback = ev_cb (ev_TYPE *watcher)</dt> |
|
|
669 | <dd> |
|
|
670 | <p>Returns the callback currently set on the watcher.</p> |
|
|
671 | </dd> |
|
|
672 | <dt>ev_cb_set (ev_TYPE *watcher, callback)</dt> |
|
|
673 | <dd> |
|
|
674 | <p>Change the callback. You can change the callback at virtually any time |
|
|
675 | (modulo threads).</p> |
|
|
676 | </dd> |
|
|
677 | </dl> |
|
|
678 | |
|
|
679 | |
|
|
680 | |
|
|
681 | |
603 | |
682 | |
604 | </div> |
683 | </div> |
605 | <h2 id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</h2> |
684 | <h2 id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</h2> |
606 | <div id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH-2"> |
685 | <div id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH-2"> |
607 | <p>Each watcher has, by default, a member <code>void *data</code> that you can change |
686 | <p>Each watcher has, by default, a member <code>void *data</code> that you can change |
… | |
… | |
798 | <p>Periodic watchers are also timers of a kind, but they are very versatile |
877 | <p>Periodic watchers are also timers of a kind, but they are very versatile |
799 | (and unfortunately a bit complex).</p> |
878 | (and unfortunately a bit complex).</p> |
800 | <p>Unlike <code>ev_timer</code>'s, they are not based on real time (or relative time) |
879 | <p>Unlike <code>ev_timer</code>'s, they are not based on real time (or relative time) |
801 | but on wallclock time (absolute time). You can tell a periodic watcher |
880 | but on wallclock time (absolute time). You can tell a periodic watcher |
802 | to trigger "at" some specific point in time. For example, if you tell a |
881 | to trigger "at" some specific point in time. For example, if you tell a |
803 | periodic watcher to trigger in 10 seconds (by specifiying e.g. c<ev_now () |
882 | periodic watcher to trigger in 10 seconds (by specifiying e.g. <code>ev_now () |
804 | + 10.>) and then reset your system clock to the last year, then it will |
883 | + 10.</code>) and then reset your system clock to the last year, then it will |
805 | take a year to trigger the event (unlike an <code>ev_timer</code>, which would trigger |
884 | take a year to trigger the event (unlike an <code>ev_timer</code>, which would trigger |
806 | roughly 10 seconds later and of course not if you reset your system time |
885 | roughly 10 seconds later and of course not if you reset your system time |
807 | again).</p> |
886 | again).</p> |
808 | <p>They can also be used to implement vastly more complex timers, such as |
887 | <p>They can also be used to implement vastly more complex timers, such as |
809 | triggering an event on eahc midnight, local time.</p> |
888 | triggering an event on eahc midnight, local time.</p> |
… | |
… | |
1066 | |
1145 | |
1067 | </div> |
1146 | </div> |
1068 | <h2 id="code_ev_embed_code_when_one_backend_"><code>ev_embed</code> - when one backend isn't enough</h2> |
1147 | <h2 id="code_ev_embed_code_when_one_backend_"><code>ev_embed</code> - when one backend isn't enough</h2> |
1069 | <div id="code_ev_embed_code_when_one_backend_-2"> |
1148 | <div id="code_ev_embed_code_when_one_backend_-2"> |
1070 | <p>This is a rather advanced watcher type that lets you embed one event loop |
1149 | <p>This is a rather advanced watcher type that lets you embed one event loop |
1071 | into another.</p> |
1150 | into another (currently only <code>ev_io</code> events are supported in the embedded |
|
|
1151 | loop, other types of watchers might be handled in a delayed or incorrect |
|
|
1152 | fashion and must not be used).</p> |
1072 | <p>There are primarily two reasons you would want that: work around bugs and |
1153 | <p>There are primarily two reasons you would want that: work around bugs and |
1073 | prioritise I/O.</p> |
1154 | prioritise I/O.</p> |
1074 | <p>As an example for a bug workaround, the kqueue backend might only support |
1155 | <p>As an example for a bug workaround, the kqueue backend might only support |
1075 | sockets on some platform, so it is unusable as generic backend, but you |
1156 | sockets on some platform, so it is unusable as generic backend, but you |
1076 | still want to make use of it because you have many sockets and it scales |
1157 | still want to make use of it because you have many sockets and it scales |
… | |
… | |
1081 | <p>As for prioritising I/O: rarely you have the case where some fds have |
1162 | <p>As for prioritising I/O: rarely you have the case where some fds have |
1082 | to be watched and handled very quickly (with low latency), and even |
1163 | to be watched and handled very quickly (with low latency), and even |
1083 | priorities and idle watchers might have too much overhead. In this case |
1164 | priorities and idle watchers might have too much overhead. In this case |
1084 | you would put all the high priority stuff in one loop and all the rest in |
1165 | you would put all the high priority stuff in one loop and all the rest in |
1085 | a second one, and embed the second one in the first.</p> |
1166 | a second one, and embed the second one in the first.</p> |
|
|
1167 | <p>As long as the watcher is active, the callback will be invoked every time |
|
|
1168 | there might be events pending in the embedded loop. The callback must then |
|
|
1169 | call <code>ev_embed_sweep (mainloop, watcher)</code> to make a single sweep and invoke |
|
|
1170 | their callbacks (you could also start an idle watcher to give the embedded |
|
|
1171 | loop strictly lower priority for example). You can also set the callback |
|
|
1172 | to <code>0</code>, in which case the embed watcher will automatically execute the |
|
|
1173 | embedded loop sweep.</p> |
1086 | <p>As long as the watcher is started it will automatically handle events. The |
1174 | <p>As long as the watcher is started it will automatically handle events. The |
1087 | callback will be invoked whenever some events have been handled. You can |
1175 | callback will be invoked whenever some events have been handled. You can |
1088 | set the callback to <code>0</code> to avoid having to specify one if you are not |
1176 | set the callback to <code>0</code> to avoid having to specify one if you are not |
1089 | interested in that.</p> |
1177 | interested in that.</p> |
1090 | <p>Also, there have not currently been made special provisions for forking: |
1178 | <p>Also, there have not currently been made special provisions for forking: |
… | |
… | |
1117 | else |
1205 | else |
1118 | loop_lo = loop_hi; |
1206 | loop_lo = loop_hi; |
1119 | |
1207 | |
1120 | </pre> |
1208 | </pre> |
1121 | <dl> |
1209 | <dl> |
1122 | <dt>ev_embed_init (ev_embed *, callback, struct ev_loop *loop)</dt> |
1210 | <dt>ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)</dt> |
1123 | <dt>ev_embed_set (ev_embed *, callback, struct ev_loop *loop)</dt> |
1211 | <dt>ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)</dt> |
|
|
1212 | <dd> |
|
|
1213 | <p>Configures the watcher to embed the given loop, which must be |
|
|
1214 | embeddable. If the callback is <code>0</code>, then <code>ev_embed_sweep</code> will be |
|
|
1215 | invoked automatically, otherwise it is the responsibility of the callback |
|
|
1216 | to invoke it (it will continue to be called until the sweep has been done, |
|
|
1217 | if you do not want thta, you need to temporarily stop the embed watcher).</p> |
1124 | <dd> |
1218 | </dd> |
1125 | <p>Configures the watcher to embed the given loop, which must be embeddable.</p> |
1219 | <dt>ev_embed_sweep (loop, ev_embed *)</dt> |
|
|
1220 | <dd> |
|
|
1221 | <p>Make a single, non-blocking sweep over the embedded loop. This works |
|
|
1222 | similarly to <code>ev_loop (embedded_loop, EVLOOP_NONBLOCK)</code>, but in the most |
|
|
1223 | apropriate way for embedded loops.</p> |
1126 | </dd> |
1224 | </dd> |
1127 | </dl> |
1225 | </dl> |
1128 | |
1226 | |
1129 | |
1227 | |
1130 | |
1228 | |
… | |
… | |
1163 | |
1261 | |
1164 | ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0); |
1262 | ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0); |
1165 | |
1263 | |
1166 | </pre> |
1264 | </pre> |
1167 | </dd> |
1265 | </dd> |
1168 | <dt>ev_feed_event (loop, watcher, int events)</dt> |
1266 | <dt>ev_feed_event (ev_loop *, watcher *, int revents)</dt> |
1169 | <dd> |
1267 | <dd> |
1170 | <p>Feeds the given event set into the event loop, as if the specified event |
1268 | <p>Feeds the given event set into the event loop, as if the specified event |
1171 | had happened for the specified watcher (which must be a pointer to an |
1269 | had happened for the specified watcher (which must be a pointer to an |
1172 | initialised but not necessarily started event watcher).</p> |
1270 | initialised but not necessarily started event watcher).</p> |
1173 | </dd> |
1271 | </dd> |
1174 | <dt>ev_feed_fd_event (loop, int fd, int revents)</dt> |
1272 | <dt>ev_feed_fd_event (ev_loop *, int fd, int revents)</dt> |
1175 | <dd> |
1273 | <dd> |
1176 | <p>Feed an event on the given fd, as if a file descriptor backend detected |
1274 | <p>Feed an event on the given fd, as if a file descriptor backend detected |
1177 | the given events it.</p> |
1275 | the given events it.</p> |
1178 | </dd> |
1276 | </dd> |
1179 | <dt>ev_feed_signal_event (loop, int signum)</dt> |
1277 | <dt>ev_feed_signal_event (ev_loop *loop, int signum)</dt> |
1180 | <dd> |
1278 | <dd> |
1181 | <p>Feed an event as if the given signal occured (loop must be the default loop!).</p> |
1279 | <p>Feed an event as if the given signal occured (<code>loop</code> must be the default |
|
|
1280 | loop!).</p> |
1182 | </dd> |
1281 | </dd> |
1183 | </dl> |
1282 | </dl> |
1184 | |
1283 | |
1185 | |
1284 | |
1186 | |
1285 | |
… | |
… | |
1207 | </dl> |
1306 | </dl> |
1208 | |
1307 | |
1209 | </div> |
1308 | </div> |
1210 | <h1 id="C_SUPPORT">C++ SUPPORT</h1><p><a href="#TOP" class="toplink">Top</a></p> |
1309 | <h1 id="C_SUPPORT">C++ SUPPORT</h1><p><a href="#TOP" class="toplink">Top</a></p> |
1211 | <div id="C_SUPPORT_CONTENT"> |
1310 | <div id="C_SUPPORT_CONTENT"> |
1212 | <p>TBD.</p> |
1311 | <p>Libev comes with some simplistic wrapper classes for C++ that mainly allow |
|
|
1312 | you to use some convinience methods to start/stop watchers and also change |
|
|
1313 | the callback model to a model using method callbacks on objects.</p> |
|
|
1314 | <p>To use it,</p> |
|
|
1315 | <pre> #include <ev++.h> |
|
|
1316 | |
|
|
1317 | </pre> |
|
|
1318 | <p>(it is not installed by default). This automatically includes <cite>ev.h</cite> |
|
|
1319 | and puts all of its definitions (many of them macros) into the global |
|
|
1320 | namespace. All C++ specific things are put into the <code>ev</code> namespace.</p> |
|
|
1321 | <p>It should support all the same embedding options as <cite>ev.h</cite>, most notably |
|
|
1322 | <code>EV_MULTIPLICITY</code>.</p> |
|
|
1323 | <p>Here is a list of things available in the <code>ev</code> namespace:</p> |
|
|
1324 | <dl> |
|
|
1325 | <dt><code>ev::READ</code>, <code>ev::WRITE</code> etc.</dt> |
|
|
1326 | <dd> |
|
|
1327 | <p>These are just enum values with the same values as the <code>EV_READ</code> etc. |
|
|
1328 | macros from <cite>ev.h</cite>.</p> |
|
|
1329 | </dd> |
|
|
1330 | <dt><code>ev::tstamp</code>, <code>ev::now</code></dt> |
|
|
1331 | <dd> |
|
|
1332 | <p>Aliases to the same types/functions as with the <code>ev_</code> prefix.</p> |
|
|
1333 | </dd> |
|
|
1334 | <dt><code>ev::io</code>, <code>ev::timer</code>, <code>ev::periodic</code>, <code>ev::idle</code>, <code>ev::sig</code> etc.</dt> |
|
|
1335 | <dd> |
|
|
1336 | <p>For each <code>ev_TYPE</code> watcher in <cite>ev.h</cite> there is a corresponding class of |
|
|
1337 | the same name in the <code>ev</code> namespace, with the exception of <code>ev_signal</code> |
|
|
1338 | which is called <code>ev::sig</code> to avoid clashes with the <code>signal</code> macro |
|
|
1339 | defines by many implementations.</p> |
|
|
1340 | <p>All of those classes have these methods:</p> |
|
|
1341 | <p> |
|
|
1342 | <dl> |
|
|
1343 | <dt>ev::TYPE::TYPE (object *, object::method *)</dt> |
|
|
1344 | <dt>ev::TYPE::TYPE (object *, object::method *, struct ev_loop *)</dt> |
|
|
1345 | <dt>ev::TYPE::~TYPE</dt> |
|
|
1346 | <dd> |
|
|
1347 | <p>The constructor takes a pointer to an object and a method pointer to |
|
|
1348 | the event handler callback to call in this class. The constructor calls |
|
|
1349 | <code>ev_init</code> for you, which means you have to call the <code>set</code> method |
|
|
1350 | before starting it. If you do not specify a loop then the constructor |
|
|
1351 | automatically associates the default loop with this watcher.</p> |
|
|
1352 | <p>The destructor automatically stops the watcher if it is active.</p> |
|
|
1353 | </dd> |
|
|
1354 | <dt>w->set (struct ev_loop *)</dt> |
|
|
1355 | <dd> |
|
|
1356 | <p>Associates a different <code>struct ev_loop</code> with this watcher. You can only |
|
|
1357 | do this when the watcher is inactive (and not pending either).</p> |
|
|
1358 | </dd> |
|
|
1359 | <dt>w->set ([args])</dt> |
|
|
1360 | <dd> |
|
|
1361 | <p>Basically the same as <code>ev_TYPE_set</code>, with the same args. Must be |
|
|
1362 | called at least once. Unlike the C counterpart, an active watcher gets |
|
|
1363 | automatically stopped and restarted.</p> |
|
|
1364 | </dd> |
|
|
1365 | <dt>w->start ()</dt> |
|
|
1366 | <dd> |
|
|
1367 | <p>Starts the watcher. Note that there is no <code>loop</code> argument as the |
|
|
1368 | constructor already takes the loop.</p> |
|
|
1369 | </dd> |
|
|
1370 | <dt>w->stop ()</dt> |
|
|
1371 | <dd> |
|
|
1372 | <p>Stops the watcher if it is active. Again, no <code>loop</code> argument.</p> |
|
|
1373 | </dd> |
|
|
1374 | <dt>w->again () <code>ev::timer</code>, <code>ev::periodic</code> only</dt> |
|
|
1375 | <dd> |
|
|
1376 | <p>For <code>ev::timer</code> and <code>ev::periodic</code>, this invokes the corresponding |
|
|
1377 | <code>ev_TYPE_again</code> function.</p> |
|
|
1378 | </dd> |
|
|
1379 | <dt>w->sweep () <code>ev::embed</code> only</dt> |
|
|
1380 | <dd> |
|
|
1381 | <p>Invokes <code>ev_embed_sweep</code>.</p> |
|
|
1382 | </dd> |
|
|
1383 | </dl> |
|
|
1384 | </p> |
|
|
1385 | </dd> |
|
|
1386 | </dl> |
|
|
1387 | <p>Example: Define a class with an IO and idle watcher, start one of them in |
|
|
1388 | the constructor.</p> |
|
|
1389 | <pre> class myclass |
|
|
1390 | { |
|
|
1391 | ev_io io; void io_cb (ev::io &w, int revents); |
|
|
1392 | ev_idle idle void idle_cb (ev::idle &w, int revents); |
|
|
1393 | |
|
|
1394 | myclass (); |
|
|
1395 | } |
|
|
1396 | |
|
|
1397 | myclass::myclass (int fd) |
|
|
1398 | : io (this, &myclass::io_cb), |
|
|
1399 | idle (this, &myclass::idle_cb) |
|
|
1400 | { |
|
|
1401 | io.start (fd, ev::READ); |
|
|
1402 | } |
|
|
1403 | |
|
|
1404 | </pre> |
1213 | |
1405 | |
1214 | </div> |
1406 | </div> |
1215 | <h1 id="AUTHOR">AUTHOR</h1><p><a href="#TOP" class="toplink">Top</a></p> |
1407 | <h1 id="AUTHOR">AUTHOR</h1><p><a href="#TOP" class="toplink">Top</a></p> |
1216 | <div id="AUTHOR_CONTENT"> |
1408 | <div id="AUTHOR_CONTENT"> |
1217 | <p>Marc Lehmann <libev@schmorp.de>.</p> |
1409 | <p>Marc Lehmann <libev@schmorp.de>.</p> |