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

Comparing libev/ev++.h (file contents):
Revision 1.41 by root, Tue Sep 30 18:35:47 2008 UTC vs.
Revision 1.54 by root, Fri Oct 22 05:57:55 2010 UTC

1/* 1/*
2 * libev simple C++ wrapper classes 2 * libev simple C++ wrapper classes
3 * 3 *
4 * Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de> 4 * Copyright (c) 2007,2008,2010 Marc Alexander Lehmann <libev@schmorp.de>
5 * All rights reserved. 5 * All rights reserved.
6 * 6 *
7 * Redistribution and use in source and binary forms, with or without modifica- 7 * Redistribution and use in source and binary forms, with or without modifica-
8 * tion, are permitted provided that the following conditions are met: 8 * tion, are permitted provided that the following conditions are met:
9 * 9 *
… …
56 56
57namespace ev { 57namespace ev {
58 58
59 typedef ev_tstamp tstamp; 59 typedef ev_tstamp tstamp;
60 60
61 enum { 61 enum
62 {
62 UNDEF = EV_UNDEF, 63 UNDEF = EV_UNDEF,
63 NONE = EV_NONE, 64 NONE = EV_NONE,
64 READ = EV_READ, 65 READ = EV_READ,
65 WRITE = EV_WRITE, 66 WRITE = EV_WRITE,
67#if EV_COMPAT3
66 TIMEOUT = EV_TIMEOUT, 68 TIMEOUT = EV_TIMEOUT,
69#endif
70 TIMER = EV_TIMER,
67 PERIODIC = EV_PERIODIC, 71 PERIODIC = EV_PERIODIC,
68 SIGNAL = EV_SIGNAL, 72 SIGNAL = EV_SIGNAL,
69 CHILD = EV_CHILD, 73 CHILD = EV_CHILD,
70 STAT = EV_STAT, 74 STAT = EV_STAT,
71 IDLE = EV_IDLE, 75 IDLE = EV_IDLE,
72 CHECK = EV_CHECK, 76 CHECK = EV_CHECK,
73 PREPARE = EV_PREPARE, 77 PREPARE = EV_PREPARE,
74 FORK = EV_FORK, 78 FORK = EV_FORK,
75 ASYNC = EV_ASYNC, 79 ASYNC = EV_ASYNC,
76 EMBED = EV_EMBED, 80 EMBED = EV_EMBED,
81# undef ERROR // some systems stupidly #define ERROR
77 ERROR = EV_ERROR, 82 ERROR = EV_ERROR
78 }; 83 };
79 84
80 enum 85 enum
81 { 86 {
82 AUTO = EVFLAG_AUTO, 87 AUTO = EVFLAG_AUTO,
… …
91 PORT = EVBACKEND_PORT 96 PORT = EVBACKEND_PORT
92 }; 97 };
93 98
94 enum 99 enum
95 { 100 {
101#if EV_COMPAT3
96 NONBLOCK = EVLOOP_NONBLOCK, 102 NONBLOCK = EVLOOP_NONBLOCK,
97 ONESHOT = EVLOOP_ONESHOT 103 ONESHOT = EVLOOP_ONESHOT,
104#endif
105 NOWAIT = EVRUN_NOWAIT,
106 ONCE = EVRUN_ONCE
98 }; 107 };
99 108
100 enum how_t 109 enum how_t
101 { 110 {
102 ONE = EVUNLOOP_ONE, 111 ONE = EVBREAK_ONE,
103 ALL = EVUNLOOP_ALL 112 ALL = EVBREAK_ALL
104 }; 113 };
105 114
106 struct bad_loop 115 struct bad_loop
107#if EV_USE_STDEXCEPT 116#if EV_USE_STDEXCEPT
108 : std::runtime_error 117 : std::runtime_error
… …
158 return false; 167 return false;
159#endif 168#endif
160 } 169 }
161 170
162#if EV_MULTIPLICITY 171#if EV_MULTIPLICITY
163 bool operator == (struct ev_loop *other) const throw () 172 bool operator == (const EV_P) const throw ()
164 { 173 {
165 return this->EV_AX == other; 174 return this->EV_AX == EV_A;
166 }
167
168 bool operator != (struct ev_loop *other) const throw ()
169 { 175 }
170 return ! (*this == other); 176
177 bool operator != (const EV_P) const throw ()
171 } 178 {
172
173 bool operator == (const struct ev_loop *other) const throw ()
174 {
175 return this->EV_AX == other;
176 }
177
178 bool operator != (const struct ev_loop *other) const throw ()
179 {
180 return (*this == other); 179 return (*this == EV_A);
181 } 180 }
182 181
183 operator struct ev_loop * () const throw () 182 operator struct ev_loop * () const throw ()
184 { 183 {
185 return EV_AX; 184 return EV_AX;
… …
194 { 193 {
195 return EV_AX == ev_default_loop (0); 194 return EV_AX == ev_default_loop (0);
196 } 195 }
197#endif 196#endif
198 197
198#if EV_COMPAT3
199 void loop (int flags = 0) 199 void loop (int flags = 0)
200 { 200 {
201 ev_loop (EV_AX_ flags); 201 ev_run (EV_AX_ flags);
202 } 202 }
203 203
204 void unloop (how_t how = ONE) throw () 204 void unloop (how_t how = ONE) throw ()
205 { 205 {
206 ev_unloop (EV_AX_ how); 206 ev_break (EV_AX_ how);
207 }
208#endif
209
210 void run (int flags = 0)
211 {
212 ev_run (EV_AX_ flags);
213 }
214
215 void break_loop (how_t how = ONE) throw ()
216 {
217 ev_break (EV_AX_ how);
207 } 218 }
208 219
209 void post_fork () throw () 220 void post_fork () throw ()
210 { 221 {
211#if EV_MULTIPLICITY 222#if EV_MULTIPLICITY
… …
213#else 224#else
214 ev_default_fork (); 225 ev_default_fork ();
215#endif 226#endif
216 } 227 }
217 228
218 unsigned int count () const throw ()
219 {
220 return ev_loop_count (EV_AX);
221 }
222
223 unsigned int backend () const throw () 229 unsigned int backend () const throw ()
224 { 230 {
225 return ev_backend (EV_AX); 231 return ev_backend (EV_AX);
226 } 232 }
227 233
… …
238 void unref () throw () 244 void unref () throw ()
239 { 245 {
240 ev_unref (EV_AX); 246 ev_unref (EV_AX);
241 } 247 }
242 248
249#if EV_FEATURE_API
250 unsigned int iteration () const throw ()
251 {
252 return ev_iteration (EV_AX);
253 }
254
255 unsigned int depth () const throw ()
256 {
257 return ev_depth (EV_AX);
258 }
259
243 void set_io_collect_interval (tstamp interval) throw () 260 void set_io_collect_interval (tstamp interval) throw ()
244 { 261 {
245 ev_set_io_collect_interval (EV_AX_ interval); 262 ev_set_io_collect_interval (EV_AX_ interval);
246 } 263 }
247 264
248 void set_timeout_collect_interval (tstamp interval) throw () 265 void set_timeout_collect_interval (tstamp interval) throw ()
249 { 266 {
250 ev_set_timeout_collect_interval (EV_AX_ interval); 267 ev_set_timeout_collect_interval (EV_AX_ interval);
251 } 268 }
269#endif
252 270
253 // function callback 271 // function callback
254 void once (int fd, int events, tstamp timeout, void (*cb)(int, void *), void* arg = 0) throw () 272 void once (int fd, int events, tstamp timeout, void (*cb)(int, void *), void *arg = 0) throw ()
255 { 273 {
256 ev_once (EV_AX_ fd, events, timeout, cb, arg); 274 ev_once (EV_AX_ fd, events, timeout, cb, arg);
257 } 275 }
258 276
259 // method callback 277 // method callback
… …
261 void once (int fd, int events, tstamp timeout, K *object) throw () 279 void once (int fd, int events, tstamp timeout, K *object) throw ()
262 { 280 {
263 once (fd, events, timeout, method_thunk<K, method>, object); 281 once (fd, events, timeout, method_thunk<K, method>, object);
264 } 282 }
265 283
284 // default method == operator ()
285 template<class K>
286 void once (int fd, int events, tstamp timeout, K *object) throw ()
287 {
288 once (fd, events, timeout, method_thunk<K, &K::operator ()>, object);
289 }
290
266 template<class K, void (K::*method)(int)> 291 template<class K, void (K::*method)(int)>
267 static void method_thunk (int revents, void* arg) 292 static void method_thunk (int revents, void *arg)
268 {
269 K *obj = static_cast<K *>(arg);
270 (obj->*method) (revents);
271 } 293 {
294 static_cast<K *>(arg)->*method
295 (revents);
296 }
272 297
273 // const method callback 298 // no-argument method callback
274 template<class K, void (K::*method)(int) const>
275 void once (int fd, int events, tstamp timeout, const K *object) throw ()
276 {
277 once (fd, events, timeout, const_method_thunk<K, method>, object);
278 }
279
280 template<class K, void (K::*method)(int) const>
281 static void const_method_thunk (int revents, void* arg)
282 {
283 K *obj = static_cast<K *>(arg);
284 (obj->*method) (revents);
285 }
286
287 // simple method callback
288 template<class K, void (K::*method)()> 299 template<class K, void (K::*method)()>
289 void once (int fd, int events, tstamp timeout, K *object) throw () 300 void once (int fd, int events, tstamp timeout, K *object) throw ()
290 { 301 {
291 once (fd, events, timeout, method_noargs_thunk<K, method>, object); 302 once (fd, events, timeout, method_noargs_thunk<K, method>, object);
292 } 303 }
293 304
294 template<class K, void (K::*method)()> 305 template<class K, void (K::*method)()>
295 static void method_noargs_thunk (int revents, void* arg) 306 static void method_noargs_thunk (int revents, void *arg)
296 { 307 {
297 K *obj = static_cast<K *>(arg); 308 static_cast<K *>(arg)->*method
298 (obj->*method) (); 309 ();
299 } 310 }
300 311
301 // simpler function callback 312 // simpler function callback
302 template<void (*cb)(int)> 313 template<void (*cb)(int)>
303 void once (int fd, int events, tstamp timeout) throw () 314 void once (int fd, int events, tstamp timeout) throw ()
304 { 315 {
305 once (fd, events, timeout, simpler_func_thunk<cb>); 316 once (fd, events, timeout, simpler_func_thunk<cb>);
306 } 317 }
307 318
308 template<void (*cb)(int)> 319 template<void (*cb)(int)>
309 static void simpler_func_thunk (int revents, void* arg) 320 static void simpler_func_thunk (int revents, void *arg)
310 { 321 {
322 (*cb)
311 (*cb) (revents); 323 (revents);
312 } 324 }
313 325
314 // simplest function callback 326 // simplest function callback
315 template<void (*cb)()> 327 template<void (*cb)()>
316 void once (int fd, int events, tstamp timeout) throw () 328 void once (int fd, int events, tstamp timeout) throw ()
317 { 329 {
318 once (fd, events, timeout, simplest_func_thunk<cb>); 330 once (fd, events, timeout, simplest_func_thunk<cb>);
319 } 331 }
320 332
321 template<void (*cb)()> 333 template<void (*cb)()>
322 static void simplest_func_thunk (int revents, void* arg) 334 static void simplest_func_thunk (int revents, void *arg)
323 { 335 {
324 (*cb) (); 336 (*cb)
337 ();
325 } 338 }
326 339
327 void feed_fd_event (int fd, int revents) throw () 340 void feed_fd_event (int fd, int revents) throw ()
328 { 341 {
329 ev_feed_fd_event (EV_AX_ fd, revents); 342 ev_feed_fd_event (EV_AX_ fd, revents);
… …
419 struct base : ev_watcher 432 struct base : ev_watcher
420 { 433 {
421 #if EV_MULTIPLICITY 434 #if EV_MULTIPLICITY
422 EV_PX; 435 EV_PX;
423 436
437 // loop set
424 void set (EV_PX) throw () 438 void set (EV_P) throw ()
425 { 439 {
426 this->EV_A = EV_A; 440 this->EV_A = EV_A;
427 } 441 }
428 #endif 442 #endif
429 443
… …
433 #endif 447 #endif
434 { 448 {
435 ev_init (this, 0); 449 ev_init (this, 0);
436 } 450 }
437 451
438 void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) throw () 452 void set_ (const void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) throw ()
439 { 453 {
440 this->data = data; 454 this->data = (void *)data;
441 ev_set_cb (static_cast<ev_watcher *>(this), cb); 455 ev_set_cb (static_cast<ev_watcher *>(this), cb);
456 }
457
458 // function callback
459 template<void (*function)(watcher &w, int)>
460 void set (void *data = 0) throw ()
461 {
462 set_ (data, function_thunk<function>);
463 }
464
465 template<void (*function)(watcher &w, int)>
466 static void function_thunk (EV_P_ ev_watcher *w, int revents)
467 {
468 function
469 (*static_cast<watcher *>(w), revents);
442 } 470 }
443 471
444 // method callback 472 // method callback
445 template<class K, void (K::*method)(watcher &w, int)> 473 template<class K, void (K::*method)(watcher &w, int)>
446 void set (K *object) throw () 474 void set (K *object) throw ()
447 { 475 {
448 set_ (object, method_thunk<K, method>); 476 set_ (object, method_thunk<K, method>);
449 } 477 }
450 478
479 // default method == operator ()
480 template<class K>
481 void set (K *object) throw ()
482 {
483 set_ (object, method_thunk<K, &K::operator ()>);
484 }
485
451 template<class K, void (K::*method)(watcher &w, int)> 486 template<class K, void (K::*method)(watcher &w, int)>
452 static void method_thunk (EV_P_ ev_watcher *w, int revents) 487 static void method_thunk (EV_P_ ev_watcher *w, int revents)
453 { 488 {
454 K *obj = static_cast<K *>(w->data); 489 (static_cast<K *>(w->data)->*method)
455 (obj->*method) (*static_cast<watcher *>(w), revents);
456 }
457
458 // const method callback
459 template<class K, void (K::*method)(watcher &w, int) const>
460 void set (const K *object) throw ()
461 {
462 set_ (object, const_method_thunk<K, method>);
463 }
464
465 template<class K, void (K::*method)(watcher &w, int) const>
466 static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
467 {
468 K *obj = static_cast<K *>(w->data);
469 (static_cast<K *>(w->data)->*method) (*static_cast<watcher *>(w), revents);
470 }
471
472 // function callback
473 template<void (*function)(watcher &w, int)>
474 void set (void *data = 0) throw ()
475 {
476 set_ (data, function_thunk<function>);
477 }
478
479 template<void (*function)(watcher &w, int)>
480 static void function_thunk (EV_P_ ev_watcher *w, int revents)
481 {
482 function (*static_cast<watcher *>(w), revents); 490 (*static_cast<watcher *>(w), revents);
483 } 491 }
484 492
485 // simple callback 493 // no-argument callback
486 template<class K, void (K::*method)()> 494 template<class K, void (K::*method)()>
487 void set (K *object) throw () 495 void set (K *object) throw ()
488 { 496 {
489 set_ (object, method_noargs_thunk<K, method>); 497 set_ (object, method_noargs_thunk<K, method>);
490 } 498 }
491 499
492 template<class K, void (K::*method)()> 500 template<class K, void (K::*method)()>
493 static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents) 501 static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
494 { 502 {
495 K *obj = static_cast<K *>(w->data); 503 (static_cast<K *>(w->data)->*method)
496 (obj->*method) (); 504 ();
497 } 505 }
498 506
499 void operator ()(int events = EV_UNDEF) 507 void operator ()(int events = EV_UNDEF)
500 { 508 {
509 return
501 return ev_cb (static_cast<ev_watcher *>(this)) 510 ev_cb (static_cast<ev_watcher *>(this))
502 (static_cast<ev_watcher *>(this), events); 511 (static_cast<ev_watcher *>(this), events);
503 } 512 }
504 513
505 bool is_active () const throw () 514 bool is_active () const throw ()
506 { 515 {
507 return ev_is_active (static_cast<const ev_watcher *>(this)); 516 return ev_is_active (static_cast<const ev_watcher *>(this));
… …
653 662
654 void again () throw () 663 void again () throw ()
655 { 664 {
656 ev_timer_again (EV_A_ static_cast<ev_timer *>(this)); 665 ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
657 } 666 }
667
668 ev_tstamp remaining ()
669 {
670 return ev_timer_remaining (EV_A_ static_cast<ev_timer *>(this));
671 }
658 EV_END_WATCHER (timer, timer) 672 EV_END_WATCHER (timer, timer)
659 673
660 #if EV_PERIODIC_ENABLE 674 #if EV_PERIODIC_ENABLE
661 EV_BEGIN_WATCHER (periodic, periodic) 675 EV_BEGIN_WATCHER (periodic, periodic)
662 void set (ev_tstamp at, ev_tstamp interval = 0.) throw () 676 void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()
… …
678 ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this)); 692 ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
679 } 693 }
680 EV_END_WATCHER (periodic, periodic) 694 EV_END_WATCHER (periodic, periodic)
681 #endif 695 #endif
682 696
697 #if EV_SIGNAL_ENABLE
683 EV_BEGIN_WATCHER (sig, signal) 698 EV_BEGIN_WATCHER (sig, signal)
684 void set (int signum) throw () 699 void set (int signum) throw ()
685 { 700 {
686 int active = is_active (); 701 int active = is_active ();
687 if (active) stop (); 702 if (active) stop ();
… …
693 { 708 {
694 set (signum); 709 set (signum);
695 start (); 710 start ();
696 } 711 }
697 EV_END_WATCHER (sig, signal) 712 EV_END_WATCHER (sig, signal)
713 #endif
698 714
715 #if EV_CHILD_ENABLE
699 EV_BEGIN_WATCHER (child, child) 716 EV_BEGIN_WATCHER (child, child)
700 void set (int pid, int trace = 0) throw () 717 void set (int pid, int trace = 0) throw ()
701 { 718 {
702 int active = is_active (); 719 int active = is_active ();
703 if (active) stop (); 720 if (active) stop ();
… …
709 { 726 {
710 set (pid, trace); 727 set (pid, trace);
711 start (); 728 start ();
712 } 729 }
713 EV_END_WATCHER (child, child) 730 EV_END_WATCHER (child, child)
731 #endif
714 732
715 #if EV_STAT_ENABLE 733 #if EV_STAT_ENABLE
716 EV_BEGIN_WATCHER (stat, stat) 734 EV_BEGIN_WATCHER (stat, stat)
717 void set (const char *path, ev_tstamp interval = 0.) throw () 735 void set (const char *path, ev_tstamp interval = 0.) throw ()
718 { 736 {
… …
734 ev_stat_stat (EV_A_ static_cast<ev_stat *>(this)); 752 ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
735 } 753 }
736 EV_END_WATCHER (stat, stat) 754 EV_END_WATCHER (stat, stat)
737 #endif 755 #endif
738 756
757 #if EV_IDLE_ENABLE
739 EV_BEGIN_WATCHER (idle, idle) 758 EV_BEGIN_WATCHER (idle, idle)
740 void set () throw () { } 759 void set () throw () { }
741 EV_END_WATCHER (idle, idle) 760 EV_END_WATCHER (idle, idle)
761 #endif
742 762
763 #if EV_PREPARE_ENABLE
743 EV_BEGIN_WATCHER (prepare, prepare) 764 EV_BEGIN_WATCHER (prepare, prepare)
744 void set () throw () { } 765 void set () throw () { }
745 EV_END_WATCHER (prepare, prepare) 766 EV_END_WATCHER (prepare, prepare)
767 #endif
746 768
769 #if EV_CHECK_ENABLE
747 EV_BEGIN_WATCHER (check, check) 770 EV_BEGIN_WATCHER (check, check)
748 void set () throw () { } 771 void set () throw () { }
749 EV_END_WATCHER (check, check) 772 EV_END_WATCHER (check, check)
773 #endif
750 774
751 #if EV_EMBED_ENABLE 775 #if EV_EMBED_ENABLE
752 EV_BEGIN_WATCHER (embed, embed) 776 EV_BEGIN_WATCHER (embed, embed)
753 void set (struct ev_loop *embedded_loop) throw () 777 void set (struct ev_loop *embedded_loop) throw ()
754 { 778 {
… …
777 EV_END_WATCHER (fork, fork) 801 EV_END_WATCHER (fork, fork)
778 #endif 802 #endif
779 803
780 #if EV_ASYNC_ENABLE 804 #if EV_ASYNC_ENABLE
781 EV_BEGIN_WATCHER (async, async) 805 EV_BEGIN_WATCHER (async, async)
782 void set () throw () { }
783
784 void send () throw () 806 void send () throw ()
785 { 807 {
786 ev_async_send (EV_A_ static_cast<ev_async *>(this)); 808 ev_async_send (EV_A_ static_cast<ev_async *>(this));
787 } 809 }
788 810

Diff Legend

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