ev++.h

   1 /*
   2  * libev simple C++ wrapper classes
   3  *
   4  * Copyright (c) 2007,2008,2010 Marc Alexander Lehmann <libev@schmorp.de>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without modifica-
   8  * tion, are permitted provided that the following conditions are met:
   9  *
  10  *   1.  Redistributions of source code must retain the above copyright notice,
  11  *       this list of conditions and the following disclaimer.
  12  *
  13  *   2.  Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in the
  15  *       documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
  19  * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
  20  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
  21  * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
  25  * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  26  * OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * the GNU General Public License ("GPL") version 2 or any later version,
  30  * in which case the provisions of the GPL are applicable instead of
  31  * the above. If you wish to allow the use of your version of this file
  32  * only under the terms of the GPL and not to allow others to use your
  33  * version of this file under the BSD license, indicate your decision
  34  * by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL. If you do not delete the
  36  * provisions above, a recipient may use your version of this file under
  37  * either the BSD or the GPL.
  38  */
  39
  40 #ifndef EVPP_H__
  41 #define EVPP_H__
  42
  43 #ifdef EV_H
  44 # include EV_H
  45 #else
  46 # include "ev.h"
  47 #endif
  48
  49 #ifndef EV_USE_STDEXCEPT
  50 # define EV_USE_STDEXCEPT 1
  51 #endif
  52
  53 #if EV_USE_STDEXCEPT
  54 # include <stdexcept>
  55 #endif
  56
  57 namespace ev {
  58
  59   typedef ev_tstamp tstamp;
  60
  61   enum {
  62     UNDEF    = EV_UNDEF,
  63     NONE     = EV_NONE,
  64     READ     = EV_READ,
  65     WRITE    = EV_WRITE,
  66     EXCEPTION= EV_EXCEPTION,
  67 #if EV_COMPAT3
  68     TIMEOUT  = EV_TIMEOUT,
  69 #endif
  70     TIMER    = EV_TIMER,
  71     PERIODIC = EV_PERIODIC,
  72     SIGNAL   = EV_SIGNAL,
  73     CHILD    = EV_CHILD,
  74     STAT     = EV_STAT,
  75     IDLE     = EV_IDLE,
  76     CHECK    = EV_CHECK,
  77     PREPARE  = EV_PREPARE,
  78     FORK     = EV_FORK,
  79     ASYNC    = EV_ASYNC,
  80     EMBED    = EV_EMBED,
  81 #   undef ERROR // some systems stupidly #define ERROR
  82     ERROR    = EV_ERROR
  83   };
  84
  85   enum
  86   {
  87     AUTO      = EVFLAG_AUTO,
  88     NOENV     = EVFLAG_NOENV,
  89     FORKCHECK = EVFLAG_FORKCHECK,
  90
  91     SELECT    = EVBACKEND_SELECT,
  92     POLL      = EVBACKEND_POLL,
  93     EPOLL     = EVBACKEND_EPOLL,
  94     KQUEUE    = EVBACKEND_KQUEUE,
  95     DEVPOLL   = EVBACKEND_DEVPOLL,
  96     PORT      = EVBACKEND_PORT
  97   };
  98
  99   enum
 100   {
 101 #if EV_COMPAT3
 102     NONBLOCK = EVLOOP_NONBLOCK,
 103     ONESHOT  = EVLOOP_ONESHOT,
 104 #endif
 105     NOWAIT   = EVRUN_NOWAIT,
 106     ONCE     = EVRUN_ONCE
 107   };
 108
 109   enum how_t
 110   {
 111     ONE = EVBREAK_ONE,
 112     ALL = EVBREAK_ALL
 113   };
 114
 115   struct bad_loop
 116 #if EV_USE_STDEXCEPT
 117   : std::runtime_error
 118 #endif
 119   {
 120 #if EV_USE_STDEXCEPT
 121     bad_loop ()
 122     : std::runtime_error ("libev event loop cannot be initialized, bad value of LIBEV_FLAGS?")
 123     {
 124     }
 125 #endif
 126   };
 127
 128 #ifdef EV_AX
 129 #  undef EV_AX
 130 #endif
 131
 132 #ifdef EV_AX_
 133 #  undef EV_AX_
 134 #endif
 135
 136 #if EV_MULTIPLICITY
 137 #  define EV_AX  raw_loop
 138 #  define EV_AX_ raw_loop,
 139 #else
 140 #  define EV_AX
 141 #  define EV_AX_
 142 #endif
 143
 144   struct loop_ref
 145   {
 146     loop_ref (EV_P) throw ()
 147 #if EV_MULTIPLICITY
 148     : EV_AX (EV_A)
 149 #endif
 150     {
 151     }
 152
 153     bool operator == (const loop_ref &other) const throw ()
 154     {
 155 #if EV_MULTIPLICITY
 156       return EV_AX == other.EV_AX;
 157 #else
 158       return true;
 159 #endif
 160     }
 161
 162     bool operator != (const loop_ref &other) const throw ()
 163     {
 164 #if EV_MULTIPLICITY
 165       return ! (*this == other);
 166 #else
 167       return false;
 168 #endif
 169     }
 170
 171 #if EV_MULTIPLICITY
 172     bool operator == (const EV_P) const throw ()
 173     {
 174       return this->EV_AX == EV_A;
 175     }
 176
 177     bool operator != (const EV_P) const throw ()
 178     {
 179       return (*this == EV_A);
 180     }
 181
 182     operator struct ev_loop * () const throw ()
 183     {
 184       return EV_AX;
 185     }
 186
 187     operator const struct ev_loop * () const throw ()
 188     {
 189       return EV_AX;
 190     }
 191
 192     bool is_default () const throw ()
 193     {
 194       return EV_AX == ev_default_loop (0);
 195     }
 196 #endif
 197
 198 #if EV_COMPAT3
 199     void loop (int flags = 0)
 200     {
 201       ev_run (EV_AX_ flags);
 202     }
 203
 204     void unloop (how_t how = ONE) throw ()
 205     {
 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);
 218     }
 219
 220     void post_fork () throw ()
 221     {
 222       ev_loop_fork (EV_AX);
 223     }
 224
 225     unsigned int backend () const throw ()
 226     {
 227       return ev_backend (EV_AX);
 228     }
 229
 230     tstamp now () const throw ()
 231     {
 232       return ev_now (EV_AX);
 233     }
 234
 235     void ref () throw ()
 236     {
 237       ev_ref (EV_AX);
 238     }
 239
 240     void unref () throw ()
 241     {
 242       ev_unref (EV_AX);
 243     }
 244
 245 #if EV_FEATURE_API
 246     unsigned int iteration () const throw ()
 247     {
 248       return ev_iteration (EV_AX);
 249     }
 250
 251     unsigned int depth () const throw ()
 252     {
 253       return ev_depth (EV_AX);
 254     }
 255
 256     void set_io_collect_interval (tstamp interval) throw ()
 257     {
 258       ev_set_io_collect_interval (EV_AX_ interval);
 259     }
 260
 261     void set_timeout_collect_interval (tstamp interval) throw ()
 262     {
 263       ev_set_timeout_collect_interval (EV_AX_ interval);
 264     }
 265 #endif
 266
 267     // function callback
 268     void once (int fd, int events, tstamp timeout, void (*cb)(int, void *), void *arg = 0) throw ()
 269     {
 270       ev_once (EV_AX_ fd, events, timeout, cb, arg);
 271     }
 272
 273     // method callback
 274     template<class K, void (K::*method)(int)>
 275     void once (int fd, int events, tstamp timeout, K *object) throw ()
 276     {
 277       once (fd, events, timeout, method_thunk<K, method>, object);
 278     }
 279
 280     // default method == operator ()
 281     template<class K>
 282     void once (int fd, int events, tstamp timeout, K *object) throw ()
 283     {
 284       once (fd, events, timeout, method_thunk<K, &K::operator ()>, object);
 285     }
 286
 287     template<class K, void (K::*method)(int)>
 288     static void method_thunk (int revents, void *arg)
 289     {
 290       (static_cast<K *>(arg)->*method)
 291         (revents);
 292     }
 293
 294     // no-argument method callback
 295     template<class K, void (K::*method)()>
 296     void once (int fd, int events, tstamp timeout, K *object) throw ()
 297     {
 298       once (fd, events, timeout, method_noargs_thunk<K, method>, object);
 299     }
 300
 301     template<class K, void (K::*method)()>
 302     static void method_noargs_thunk (int revents, void *arg)
 303     {
 304       (static_cast<K *>(arg)->*method)
 305         ();
 306     }
 307
 308     // simpler function callback
 309     template<void (*cb)(int)>
 310     void once (int fd, int events, tstamp timeout) throw ()
 311     {
 312       once (fd, events, timeout, simpler_func_thunk<cb>);
 313     }
 314
 315     template<void (*cb)(int)>
 316     static void simpler_func_thunk (int revents, void *arg)
 317     {
 318       (*cb)
 319         (revents);
 320     }
 321
 322     // simplest function callback
 323     template<void (*cb)()>
 324     void once (int fd, int events, tstamp timeout) throw ()
 325     {
 326       once (fd, events, timeout, simplest_func_thunk<cb>);
 327     }
 328
 329     template<void (*cb)()>
 330     static void simplest_func_thunk (int revents, void *arg)
 331     {
 332       (*cb)
 333         ();
 334     }
 335
 336     void feed_fd_event (int fd, int revents) throw ()
 337     {
 338       ev_feed_fd_event (EV_AX_ fd, revents);
 339     }
 340
 341     void feed_signal_event (int signum) throw ()
 342     {
 343       ev_feed_signal_event (EV_AX_ signum);
 344     }
 345
 346 #if EV_MULTIPLICITY
 347     struct ev_loop* EV_AX;
 348 #endif
 349
 350   };
 351
 352 #if EV_MULTIPLICITY
 353   struct dynamic_loop : loop_ref
 354   {
 355
 356     dynamic_loop (unsigned int flags = AUTO) throw (bad_loop)
 357     : loop_ref (ev_loop_new (flags))
 358     {
 359       if (!EV_AX)
 360         throw bad_loop ();
 361     }
 362
 363     ~dynamic_loop () throw ()
 364     {
 365       ev_loop_destroy (EV_AX);
 366       EV_AX = 0;
 367     }
 368
 369   private:
 370
 371     dynamic_loop (const dynamic_loop &);
 372
 373     dynamic_loop & operator= (const dynamic_loop &);
 374
 375   };
 376 #endif
 377
 378   struct default_loop : loop_ref
 379   {
 380     default_loop (unsigned int flags = AUTO) throw (bad_loop)
 381 #if EV_MULTIPLICITY
 382     : loop_ref (ev_default_loop (flags))
 383 #endif
 384     {
 385       if (
 386 #if EV_MULTIPLICITY
 387           !EV_AX
 388 #else
 389           !ev_default_loop (flags)
 390 #endif
 391       )
 392         throw bad_loop ();
 393     }
 394
 395   private:
 396     default_loop (const default_loop &);
 397     default_loop &operator = (const default_loop &);
 398   };
 399
 400   inline loop_ref get_default_loop () throw ()
 401   {
 402 #if EV_MULTIPLICITY
 403     return ev_default_loop (0);
 404 #else
 405     return loop_ref ();
 406 #endif
 407   }
 408
 409 #undef EV_AX
 410 #undef EV_AX_
 411
 412 #undef EV_PX
 413 #undef EV_PX_
 414 #if EV_MULTIPLICITY
 415 #  define EV_PX  loop_ref EV_A
 416 #  define EV_PX_ loop_ref EV_A_
 417 #else
 418 #  define EV_PX
 419 #  define EV_PX_
 420 #endif
 421
 422   template<class ev_watcher, class watcher>
 423   struct base : ev_watcher
 424   {
 425     #if EV_MULTIPLICITY
 426       EV_PX;
 427
 428       // loop set
 429       void set (EV_P) throw ()
 430       {
 431         this->EV_A = EV_A;
 432       }
 433     #endif
 434
 435     base (EV_PX) throw ()
 436     #if EV_MULTIPLICITY
 437       : EV_A (EV_A)
 438     #endif
 439     {
 440       ev_init (this, 0);
 441     }
 442
 443     void set_ (const void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) throw ()
 444     {
 445       this->data = (void *)data;
 446       ev_set_cb (static_cast<ev_watcher *>(this), cb);
 447     }
 448
 449     // function callback
 450     template<void (*function)(watcher &w, int)>
 451     void set (void *data = 0) throw ()
 452     {
 453       set_ (data, function_thunk<function>);
 454     }
 455
 456     template<void (*function)(watcher &w, int)>
 457     static void function_thunk (EV_P_ ev_watcher *w, int revents)
 458     {
 459       function
 460         (*static_cast<watcher *>(w), revents);
 461     }
 462
 463     // method callback
 464     template<class K, void (K::*method)(watcher &w, int)>
 465     void set (K *object) throw ()
 466     {
 467       set_ (object, method_thunk<K, method>);
 468     }
 469
 470     // default method == operator ()
 471     template<class K>
 472     void set (K *object) throw ()
 473     {
 474       set_ (object, method_thunk<K, &K::operator ()>);
 475     }
 476
 477     template<class K, void (K::*method)(watcher &w, int)>
 478     static void method_thunk (EV_P_ ev_watcher *w, int revents)
 479     {
 480       (static_cast<K *>(w->data)->*method)
 481         (*static_cast<watcher *>(w), revents);
 482     }
 483
 484     // no-argument callback
 485     template<class K, void (K::*method)()>
 486     void set (K *object) throw ()
 487     {
 488       set_ (object, method_noargs_thunk<K, method>);
 489     }
 490
 491     template<class K, void (K::*method)()>
 492     static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
 493     {
 494       (static_cast<K *>(w->data)->*method)
 495         ();
 496     }
 497
 498     void operator ()(int events = EV_UNDEF)
 499     {
 500       return
 501         ev_cb (static_cast<ev_watcher *>(this))
 502           (static_cast<ev_watcher *>(this), events);
 503     }
 504
 505     bool is_active () const throw ()
 506     {
 507       return ev_is_active (static_cast<const ev_watcher *>(this));
 508     }
 509
 510     bool is_pending () const throw ()
 511     {
 512       return ev_is_pending (static_cast<const ev_watcher *>(this));
 513     }
 514
 515     void feed_event (int revents) throw ()
 516     {
 517       ev_feed_event (EV_A_ static_cast<ev_watcher *>(this), revents);
 518     }
 519   };
 520
 521   inline tstamp now (EV_P) throw ()
 522   {
 523     return ev_now (EV_A);
 524   }
 525
 526   inline void delay (tstamp interval) throw ()
 527   {
 528     ev_sleep (interval);
 529   }
 530
 531   inline int version_major () throw ()
 532   {
 533     return ev_version_major ();
 534   }
 535
 536   inline int version_minor () throw ()
 537   {
 538     return ev_version_minor ();
 539   }
 540
 541   inline unsigned int supported_backends () throw ()
 542   {
 543     return ev_supported_backends ();
 544   }
 545
 546   inline unsigned int recommended_backends () throw ()
 547   {
 548     return ev_recommended_backends ();
 549   }
 550
 551   inline unsigned int embeddable_backends () throw ()
 552   {
 553     return ev_embeddable_backends ();
 554   }
 555
 556   inline void set_allocator (void *(*cb)(void *ptr, long size) throw ()) throw ()
 557   {
 558     ev_set_allocator (cb);
 559   }
 560
 561   inline void set_syserr_cb (void (*cb)(const char *msg) throw ()) throw ()
 562   {
 563     ev_set_syserr_cb (cb);
 564   }
 565
 566   #if EV_MULTIPLICITY
 567     #define EV_CONSTRUCT(cppstem,cstem)                                                 \
 568       (EV_PX = get_default_loop ()) throw ()                                            \
 569         : base<ev_ ## cstem, cppstem> (EV_A)                                            \
 570       {                                                                                 \
 571       }
 572   #else
 573     #define EV_CONSTRUCT(cppstem,cstem)                                                 \
 574       () throw ()                                                                       \
 575       {                                                                                 \
 576       }
 577   #endif
 578
 579   /* using a template here would require quite a few more lines,
 580    * so a macro solution was chosen */
 581   #define EV_BEGIN_WATCHER(cppstem,cstem)                                               \
 582                                                                                         \
 583   struct cppstem : base<ev_ ## cstem, cppstem>                                          \
 584   {                                                                                     \
 585     void start () throw ()                                                              \
 586     {                                                                                   \
 587       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
 588     }                                                                                   \
 589                                                                                         \
 590     void stop () throw ()                                                               \
 591     {                                                                                   \
 592       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
 593     }                                                                                   \
 594                                                                                         \
 595     cppstem EV_CONSTRUCT(cppstem,cstem)                                                 \
 596                                                                                         \
 597     ~cppstem () throw ()                                                                \
 598     {                                                                                   \
 599       stop ();                                                                          \
 600     }                                                                                   \
 601                                                                                         \
 602     using base<ev_ ## cstem, cppstem>::set;                                             \
 603                                                                                         \
 604   private:                                                                              \
 605                                                                                         \
 606     cppstem (const cppstem &o);                                                         \
 607                                                                                         \
 608     cppstem &operator =(const cppstem &o);                                              \
 609                                                                                         \
 610   public:
 611
 612   #define EV_END_WATCHER(cppstem,cstem)                                                 \
 613   };
 614
 615   EV_BEGIN_WATCHER (io, io)
 616     void set (int fd, int events) throw ()
 617     {
 618       int active = is_active ();
 619       if (active) stop ();
 620       ev_io_set (static_cast<ev_io *>(this), fd, events);
 621       if (active) start ();
 622     }
 623
 624     void set (int events) throw ()
 625     {
 626       int active = is_active ();
 627       if (active) stop ();
 628       ev_io_set (static_cast<ev_io *>(this), fd, events);
 629       if (active) start ();
 630     }
 631
 632     void start (int fd, int events) throw ()
 633     {
 634       set (fd, events);
 635       start ();
 636     }
 637   EV_END_WATCHER (io, io)
 638
 639   EV_BEGIN_WATCHER (timer, timer)
 640     void set (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
 641     {
 642       int active = is_active ();
 643       if (active) stop ();
 644       ev_timer_set (static_cast<ev_timer *>(this), after, repeat);
 645       if (active) start ();
 646     }
 647
 648     void start (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
 649     {
 650       set (after, repeat);
 651       start ();
 652     }
 653
 654     void again () throw ()
 655     {
 656       ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
 657     }
 658
 659     ev_tstamp remaining ()
 660     {
 661       return ev_timer_remaining (EV_A_ static_cast<ev_timer *>(this));
 662     }
 663   EV_END_WATCHER (timer, timer)
 664
 665   #if EV_PERIODIC_ENABLE
 666   EV_BEGIN_WATCHER (periodic, periodic)
 667     void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()
 668     {
 669       int active = is_active ();
 670       if (active) stop ();
 671       ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);
 672       if (active) start ();
 673     }
 674
 675     void start (ev_tstamp at, ev_tstamp interval = 0.) throw ()
 676     {
 677       set (at, interval);
 678       start ();
 679     }
 680
 681     void again () throw ()
 682     {
 683       ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
 684     }
 685   EV_END_WATCHER (periodic, periodic)
 686   #endif
 687
 688   #if EV_SIGNAL_ENABLE
 689   EV_BEGIN_WATCHER (sig, signal)
 690     void set (int signum) throw ()
 691     {
 692       int active = is_active ();
 693       if (active) stop ();
 694       ev_signal_set (static_cast<ev_signal *>(this), signum);
 695       if (active) start ();
 696     }
 697
 698     void start (int signum) throw ()
 699     {
 700       set (signum);
 701       start ();
 702     }
 703   EV_END_WATCHER (sig, signal)
 704   #endif
 705
 706   #if EV_CHILD_ENABLE
 707   EV_BEGIN_WATCHER (child, child)
 708     void set (int pid, int trace = 0) throw ()
 709     {
 710       int active = is_active ();
 711       if (active) stop ();
 712       ev_child_set (static_cast<ev_child *>(this), pid, trace);
 713       if (active) start ();
 714     }
 715
 716     void start (int pid, int trace = 0) throw ()
 717     {
 718       set (pid, trace);
 719       start ();
 720     }
 721   EV_END_WATCHER (child, child)
 722   #endif
 723
 724   #if EV_STAT_ENABLE
 725   EV_BEGIN_WATCHER (stat, stat)
 726     void set (const char *path, ev_tstamp interval = 0.) throw ()
 727     {
 728       int active = is_active ();
 729       if (active) stop ();
 730       ev_stat_set (static_cast<ev_stat *>(this), path, interval);
 731       if (active) start ();
 732     }
 733
 734     void start (const char *path, ev_tstamp interval = 0.) throw ()
 735     {
 736       stop ();
 737       set (path, interval);
 738       start ();
 739     }
 740
 741     void update () throw ()
 742     {
 743       ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
 744     }
 745   EV_END_WATCHER (stat, stat)
 746   #endif
 747
 748   #if EV_IDLE_ENABLE
 749   EV_BEGIN_WATCHER (idle, idle)
 750     void set () throw () { }
 751   EV_END_WATCHER (idle, idle)
 752   #endif
 753
 754   #if EV_PREPARE_ENABLE
 755   EV_BEGIN_WATCHER (prepare, prepare)
 756     void set () throw () { }
 757   EV_END_WATCHER (prepare, prepare)
 758   #endif
 759
 760   #if EV_CHECK_ENABLE
 761   EV_BEGIN_WATCHER (check, check)
 762     void set () throw () { }
 763   EV_END_WATCHER (check, check)
 764   #endif
 765
 766   #if EV_EMBED_ENABLE
 767   EV_BEGIN_WATCHER (embed, embed)
 768     void set_embed (struct ev_loop *embedded_loop) throw ()
 769     {
 770       int active = is_active ();
 771       if (active) stop ();
 772       ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
 773       if (active) start ();
 774     }
 775
 776     void start (struct ev_loop *embedded_loop) throw ()
 777     {
 778       set (embedded_loop);
 779       start ();
 780     }
 781
 782     void sweep ()
 783     {
 784       ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
 785     }
 786   EV_END_WATCHER (embed, embed)
 787   #endif
 788
 789   #if EV_FORK_ENABLE
 790   EV_BEGIN_WATCHER (fork, fork)
 791     void set () throw () { }
 792   EV_END_WATCHER (fork, fork)
 793   #endif
 794
 795   #if EV_ASYNC_ENABLE
 796   EV_BEGIN_WATCHER (async, async)
 797     void send () throw ()
 798     {
 799       ev_async_send (EV_A_ static_cast<ev_async *>(this));
 800     }
 801
 802     bool async_pending () throw ()
 803     {
 804       return ev_async_pending (static_cast<ev_async *>(this));
 805     }
 806   EV_END_WATCHER (async, async)
 807   #endif
 808
 809   #undef EV_PX
 810   #undef EV_PX_
 811   #undef EV_CONSTRUCT
 812   #undef EV_BEGIN_WATCHER
 813   #undef EV_END_WATCHER
 814 }
 815
 816 #endif
 817