ev++.h

   1 /*
   2  * libev simple C++ wrapper classes
   3  *
   4  * Copyright (c) 2007 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 namespace ev {
  50
  51   typedef ev_tstamp tstamp;
  52
  53   enum {
  54     UNDEF    = EV_UNDEF,
  55     NONE     = EV_NONE,
  56     READ     = EV_READ,
  57     WRITE    = EV_WRITE,
  58     TIMEOUT  = EV_TIMEOUT,
  59     PERIODIC = EV_PERIODIC,
  60     SIGNAL   = EV_SIGNAL,
  61     CHILD    = EV_CHILD,
  62     STAT     = EV_STAT,
  63     IDLE     = EV_IDLE,
  64     CHECK    = EV_CHECK,
  65     PREPARE  = EV_PREPARE,
  66     FORK     = EV_FORK,
  67     EMBED    = EV_EMBED,
  68     ERROR    = EV_ERROR,
  69   };
  70
  71   enum
  72   {
  73     AUTO = EVFLAG_AUTO,
  74     NOENV = EVFLAG_NOENV,
  75     FORKCHECK = EVFLAG_FORKCHECK,
  76     SELECT = EVBACKEND_SELECT,
  77     POLL = EVBACKEND_POLL,
  78     EPOLL = EVBACKEND_EPOLL,
  79     KQUEUE = EVBACKEND_KQUEUE,
  80     DEVPOLL = EVBACKEND_DEVPOLL,
  81     PORT = EVBACKEND_PORT
  82   };
  83
  84   enum
  85   {
  86     NONBLOCK = EVLOOP_NONBLOCK,
  87     ONESHOT = EVLOOP_ONESHOT
  88   };
  89
  90   enum how_t
  91   {
  92     ONE = EVUNLOOP_ONE,
  93     ALL = EVUNLOOP_ALL
  94   };
  95
  96   template<class ev_watcher, class watcher>
  97   struct base : ev_watcher
  98   {
  99     #if EV_MULTIPLICITY
 100       EV_P;
 101
 102       void set (EV_P)
 103       {
 104         this->EV_A = EV_A;
 105       }
 106     #endif
 107
 108     base ()
 109     {
 110       ev_init (this, 0);
 111     }
 112
 113     void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents))
 114     {
 115       this->data = data;
 116       ev_set_cb (static_cast<ev_watcher *>(this), cb);
 117     }
 118
 119     // method callback
 120     template<class K, void (K::*method)(watcher &w, int)>
 121     void set (K *object)
 122     {
 123       set_ (object, method_thunk<K, method>);
 124     }
 125
 126     template<class K, void (K::*method)(watcher &w, int)>
 127     static void method_thunk (EV_P_ ev_watcher *w, int revents)
 128     {
 129       K *obj = static_cast<K *>(w->data);
 130       (obj->*method) (*static_cast<watcher *>(w), revents);
 131     }
 132
 133     // const method callback
 134     template<class K, void (K::*method)(watcher &w, int) const>
 135     void set (const K *object)
 136     {
 137       set_ (object, const_method_thunk<K, method>);
 138     }
 139
 140     template<class K, void (K::*method)(watcher &w, int) const>
 141     static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
 142     {
 143       K *obj = static_cast<K *>(w->data);
 144       (static_cast<K *>(w->data)->*method) (*static_cast<watcher *>(w), revents);
 145     }
 146
 147     // function callback
 148     template<void (*function)(watcher &w, int)>
 149     void set (void *data = 0)
 150     {
 151       set_ (data, function_thunk<function>);
 152     }
 153
 154     template<void (*function)(watcher &w, int)>
 155     static void function_thunk (EV_P_ ev_watcher *w, int revents)
 156     {
 157       function (*static_cast<watcher *>(w), revents);
 158     }
 159
 160     // simple callback
 161     template<class K, void (K::*method)()>
 162     void set (K *object)
 163     {
 164       set_ (object, method_noargs_thunk<K, method>);
 165     }
 166
 167     template<class K, void (K::*method)()>
 168     static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
 169     {
 170       K *obj = static_cast<K *>(w->data);
 171       (obj->*method) ();
 172     }
 173
 174     void operator ()(int events = EV_UNDEF)
 175     {
 176       return ev_cb (static_cast<ev_watcher *>(this))
 177         (static_cast<ev_watcher *>(this), events);
 178     }
 179
 180     bool is_active () const
 181     {
 182       return ev_is_active (static_cast<const ev_watcher *>(this));
 183     }
 184
 185     bool is_pending () const
 186     {
 187       return ev_is_pending (static_cast<const ev_watcher *>(this));
 188     }
 189
 190     void feed_event (int revents)
 191     {
 192       ev_feed_event (EV_A_ static_cast<const ev_watcher *>(this), revents);
 193     }
 194   };
 195
 196   inline void delay (tstamp interval)
 197   {
 198     ev_sleep (interval);
 199   }
 200
 201   inline int version_major ()
 202   {
 203     return ev_version_major ();
 204   }
 205
 206   inline int version_minor ()
 207   {
 208     return ev_version_minor ();
 209   }
 210
 211   inline unsigned int supported_backends ()
 212   {
 213     return ev_supported_backends ();
 214   }
 215
 216   inline unsigned int recommended_backends ()
 217   {
 218     return ev_recommended_backends ();
 219   }
 220
 221   inline unsigned int embeddable_backends ()
 222   {
 223     return ev_embeddable_backends ();
 224   }
 225
 226   inline void set_allocator (void *(*cb)(void *ptr, long size))
 227   {
 228     ev_set_allocator (cb);
 229   }
 230
 231   inline void set_syserr_cb (void (*cb)(const char *msg))
 232   {
 233     ev_set_syserr_cb (cb);
 234   }
 235
 236
 237   inline ev_tstamp now (EV_P)
 238   {
 239     return ev_now (EV_A);
 240   }
 241
 242   #if EV_MULTIPLICITY
 243     #define EV_CONSTRUCT                                                                \
 244       (EV_P = EV_DEFAULT)                                                               \
 245       {                                                                                 \
 246         set (EV_A);                                                                     \
 247       }
 248   #else
 249     #define EV_CONSTRUCT                                                                \
 250       ()                                                                                \
 251       {                                                                                 \
 252       }
 253   #endif
 254
 255   /* using a template here would require quite a bit more lines,
 256    * so a macro solution was chosen */
 257   #define EV_BEGIN_WATCHER(cppstem,cstem)                                               \
 258                                                                                         \
 259   struct cppstem : base<ev_ ## cstem, cppstem>                                          \
 260   {                                                                                     \
 261     void start ()                                                                       \
 262     {                                                                                   \
 263       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
 264     }                                                                                   \
 265                                                                                         \
 266     void stop ()                                                                        \
 267     {                                                                                   \
 268       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
 269     }                                                                                   \
 270                                                                                         \
 271     cppstem EV_CONSTRUCT                                                                \
 272                                                                                         \
 273     ~cppstem ()                                                                         \
 274     {                                                                                   \
 275       stop ();                                                                          \
 276     }                                                                                   \
 277                                                                                         \
 278     using base<ev_ ## cstem, cppstem>::set;                                             \
 279                                                                                         \
 280   private:                                                                              \
 281                                                                                         \
 282     cppstem (const cppstem &o);                                                         \
 283                                                                                         \
 284     cppstem & operator =(const cppstem &o);                                             \
 285                                                                                         \
 286   public:
 287
 288   #define EV_END_WATCHER(cppstem,cstem)                                                 \
 289   };
 290
 291   EV_BEGIN_WATCHER (io, io)
 292     void set (int fd, int events)
 293     {
 294       int active = is_active ();
 295       if (active) stop ();
 296       ev_io_set (static_cast<ev_io *>(this), fd, events);
 297       if (active) start ();
 298     }
 299
 300     void set (int events)
 301     {
 302       int active = is_active ();
 303       if (active) stop ();
 304       ev_io_set (static_cast<ev_io *>(this), fd, events);
 305       if (active) start ();
 306     }
 307
 308     void start (int fd, int events)
 309     {
 310       set (fd, events);
 311       start ();
 312     }
 313   EV_END_WATCHER (io, io)
 314
 315   EV_BEGIN_WATCHER (timer, timer)
 316     void set (ev_tstamp after, ev_tstamp repeat = 0.)
 317     {
 318       int active = is_active ();
 319       if (active) stop ();
 320       ev_timer_set (static_cast<ev_timer *>(this), after, repeat);
 321       if (active) start ();
 322     }
 323
 324     void start (ev_tstamp after, ev_tstamp repeat = 0.)
 325     {
 326       set (after, repeat);
 327       start ();
 328     }
 329
 330     void again ()
 331     {
 332       ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
 333     }
 334   EV_END_WATCHER (timer, timer)
 335
 336   #if EV_PERIODIC_ENABLE
 337   EV_BEGIN_WATCHER (periodic, periodic)
 338     void set (ev_tstamp at, ev_tstamp interval = 0.)
 339     {
 340       int active = is_active ();
 341       if (active) stop ();
 342       ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);
 343       if (active) start ();
 344     }
 345
 346     void start (ev_tstamp at, ev_tstamp interval = 0.)
 347     {
 348       set (at, interval);
 349       start ();
 350     }
 351
 352     void again ()
 353     {
 354       ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
 355     }
 356   EV_END_WATCHER (periodic, periodic)
 357   #endif
 358
 359   EV_BEGIN_WATCHER (sig, signal)
 360     void set (int signum)
 361     {
 362       int active = is_active ();
 363       if (active) stop ();
 364       ev_signal_set (static_cast<ev_signal *>(this), signum);
 365       if (active) start ();
 366     }
 367
 368     void start (int signum)
 369     {
 370       set (signum);
 371       start ();
 372     }
 373   EV_END_WATCHER (sig, signal)
 374
 375   EV_BEGIN_WATCHER (child, child)
 376     void set (int pid)
 377     {
 378       int active = is_active ();
 379       if (active) stop ();
 380       ev_child_set (static_cast<ev_child *>(this), pid);
 381       if (active) start ();
 382     }
 383
 384     void start (int pid)
 385     {
 386       set (pid);
 387       start ();
 388     }
 389   EV_END_WATCHER (child, child)
 390
 391   #if EV_STAT_ENABLE
 392   EV_BEGIN_WATCHER (stat, stat)
 393     void set (const char *path, ev_tstamp interval = 0.)
 394     {
 395       int active = is_active ();
 396       if (active) stop ();
 397       ev_stat_set (static_cast<ev_stat *>(this), path, interval);
 398       if (active) start ();
 399     }
 400
 401     void start (const char *path, ev_tstamp interval = 0.)
 402     {
 403       stop ();
 404       set (path, interval);
 405       start ();
 406     }
 407
 408     void update ()
 409     {
 410       ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
 411     }
 412   EV_END_WATCHER (stat, stat)
 413   #endif
 414
 415   EV_BEGIN_WATCHER (idle, idle)
 416     void set () { }
 417   EV_END_WATCHER (idle, idle)
 418
 419   EV_BEGIN_WATCHER (prepare, prepare)
 420     void set () { }
 421   EV_END_WATCHER (prepare, prepare)
 422
 423   EV_BEGIN_WATCHER (check, check)
 424     void set () { }
 425   EV_END_WATCHER (check, check)
 426
 427   #if EV_EMBED_ENABLE
 428   EV_BEGIN_WATCHER (embed, embed)
 429     void start (struct ev_loop *embedded_loop)
 430     {
 431       stop ();
 432       ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
 433       start ();
 434     }
 435
 436     void sweep ()
 437     {
 438       ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
 439     }
 440   EV_END_WATCHER (embed, embed)
 441   #endif
 442
 443   #if EV_FORK_ENABLE
 444   EV_BEGIN_WATCHER (fork, fork)
 445     void set () { }
 446   EV_END_WATCHER (fork, fork)
 447   #endif
 448
 449   #undef EV_CONSTRUCT
 450   #undef EV_BEGIN_WATCHER
 451   #undef EV_END_WATCHER
 452 }
 453
 454 #endif
 455