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
 191   inline void delay (tstamp interval)
 192   {
 193     ev_sleep (interval);
 194   }
 195
 196   inline int version_major ()
 197   {
 198     return ev_version_major ();
 199   }
 200
 201   inline int version_minor ()
 202   {
 203     return ev_version_minor ();
 204   }
 205
 206   inline unsigned int supported_backends ()
 207   {
 208     return ev_supported_backends ();
 209   }
 210
 211   inline unsigned int recommended_backends ()
 212   {
 213     return ev_recommended_backends ();
 214   }
 215
 216   inline unsigned int embeddable_backends ()
 217   {
 218     return ev_embeddable_backends ();
 219   }
 220
 221   inline void set_allocator (void *(*cb)(void *ptr, long size))
 222   {
 223     ev_set_allocator (cb);
 224   }
 225
 226   inline void set_syserr_cb (void (*cb)(const char *msg))
 227   {
 228     ev_set_syserr_cb (cb);
 229   }
 230
 231
 232   inline ev_tstamp now (EV_P)
 233   {
 234     return ev_now (EV_A);
 235   }
 236
 237   #if EV_MULTIPLICITY
 238     #define EV_CONSTRUCT                                                                \
 239       (EV_P = EV_DEFAULT)                                                               \
 240       {                                                                                 \
 241         set (EV_A);                                                                     \
 242       }
 243   #else
 244     #define EV_CONSTRUCT                                                                \
 245       ()                                                                                \
 246       {                                                                                 \
 247       }
 248   #endif
 249
 250   /* using a template here would require quite a bit more lines,
 251    * so a macro solution was chosen */
 252   #define EV_BEGIN_WATCHER(cppstem,cstem)                                               \
 253                                                                                         \
 254   struct cppstem : base<ev_ ## cstem, cppstem>                                          \
 255   {                                                                                     \
 256     void start ()                                                                       \
 257     {                                                                                   \
 258       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
 259     }                                                                                   \
 260                                                                                         \
 261     void stop ()                                                                        \
 262     {                                                                                   \
 263       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
 264     }                                                                                   \
 265                                                                                         \
 266     cppstem EV_CONSTRUCT                                                                \
 267                                                                                         \
 268     ~cppstem ()                                                                         \
 269     {                                                                                   \
 270       stop ();                                                                          \
 271     }                                                                                   \
 272                                                                                         \
 273     using base<ev_ ## cstem, cppstem>::set;                                             \
 274                                                                                         \
 275   private:                                                                              \
 276                                                                                         \
 277     cppstem (const cppstem &o);                                                         \
 278                                                                                         \
 279     cppstem & operator =(const cppstem &o);                                             \
 280                                                                                         \
 281   public:
 282
 283   #define EV_END_WATCHER(cppstem,cstem)                                                 \
 284   };
 285
 286   EV_BEGIN_WATCHER (io, io)
 287     void set (int fd, int events)
 288     {
 289       int active = is_active ();
 290       if (active) stop ();
 291       ev_io_set (static_cast<ev_io *>(this), fd, events);
 292       if (active) start ();
 293     }
 294
 295     void set (int events)
 296     {
 297       int active = is_active ();
 298       if (active) stop ();
 299       ev_io_set (static_cast<ev_io *>(this), fd, events);
 300       if (active) start ();
 301     }
 302
 303     void start (int fd, int events)
 304     {
 305       set (fd, events);
 306       start ();
 307     }
 308   EV_END_WATCHER (io, io)
 309
 310   EV_BEGIN_WATCHER (timer, timer)
 311     void set (ev_tstamp after, ev_tstamp repeat = 0.)
 312     {
 313       int active = is_active ();
 314       if (active) stop ();
 315       ev_timer_set (static_cast<ev_timer *>(this), after, repeat);
 316       if (active) start ();
 317     }
 318
 319     void start (ev_tstamp after, ev_tstamp repeat = 0.)
 320     {
 321       set (after, repeat);
 322       start ();
 323     }
 324
 325     void again ()
 326     {
 327       ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
 328     }
 329   EV_END_WATCHER (timer, timer)
 330
 331   #if EV_PERIODIC_ENABLE
 332   EV_BEGIN_WATCHER (periodic, periodic)
 333     void set (ev_tstamp at, ev_tstamp interval = 0.)
 334     {
 335       int active = is_active ();
 336       if (active) stop ();
 337       ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);
 338       if (active) start ();
 339     }
 340
 341     void start (ev_tstamp at, ev_tstamp interval = 0.)
 342     {
 343       set (at, interval);
 344       start ();
 345     }
 346
 347     void again ()
 348     {
 349       ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
 350     }
 351   EV_END_WATCHER (periodic, periodic)
 352   #endif
 353
 354   EV_BEGIN_WATCHER (sig, signal)
 355     void set (int signum)
 356     {
 357       int active = is_active ();
 358       if (active) stop ();
 359       ev_signal_set (static_cast<ev_signal *>(this), signum);
 360       if (active) start ();
 361     }
 362
 363     void start (int signum)
 364     {
 365       set (signum);
 366       start ();
 367     }
 368   EV_END_WATCHER (sig, signal)
 369
 370   EV_BEGIN_WATCHER (child, child)
 371     void set (int pid)
 372     {
 373       int active = is_active ();
 374       if (active) stop ();
 375       ev_child_set (static_cast<ev_child *>(this), pid);
 376       if (active) start ();
 377     }
 378
 379     void start (int pid)
 380     {
 381       set (pid);
 382       start ();
 383     }
 384   EV_END_WATCHER (child, child)
 385
 386   #if EV_STAT_ENABLE
 387   EV_BEGIN_WATCHER (stat, stat)
 388     void set (const char *path, ev_tstamp interval = 0.)
 389     {
 390       int active = is_active ();
 391       if (active) stop ();
 392       ev_stat_set (static_cast<ev_stat *>(this), path, interval);
 393       if (active) start ();
 394     }
 395
 396     void start (const char *path, ev_tstamp interval = 0.)
 397     {
 398       stop ();
 399       set (path, interval);
 400       start ();
 401     }
 402
 403     void update ()
 404     {
 405       ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
 406     }
 407   EV_END_WATCHER (stat, stat)
 408   #endif
 409
 410   EV_BEGIN_WATCHER (idle, idle)
 411     void set () { }
 412   EV_END_WATCHER (idle, idle)
 413
 414   EV_BEGIN_WATCHER (prepare, prepare)
 415     void set () { }
 416   EV_END_WATCHER (prepare, prepare)
 417
 418   EV_BEGIN_WATCHER (check, check)
 419     void set () { }
 420   EV_END_WATCHER (check, check)
 421
 422   #if EV_EMBED_ENABLE
 423   EV_BEGIN_WATCHER (embed, embed)
 424     void start (struct ev_loop *embedded_loop)
 425     {
 426       stop ();
 427       ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
 428       start ();
 429     }
 430
 431     void sweep ()
 432     {
 433       ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
 434     }
 435   EV_END_WATCHER (embed, embed)
 436   #endif
 437
 438   #if EV_FORK_ENABLE
 439   EV_BEGIN_WATCHER (fork, fork)
 440     void set () { }
 441   EV_END_WATCHER (fork, fork)
 442   #endif
 443
 444   #undef EV_CONSTRUCT
 445   #undef EV_BEGIN_WATCHER
 446   #undef EV_END_WATCHER
 447 }
 448
 449 #endif
 450