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   template<class ev_watcher, class watcher>
  72   struct base : ev_watcher
  73   {
  74     #if EV_MULTIPLICITY
  75       EV_P;
  76
  77       void set (EV_P)
  78       {
  79         this->EV_A = EV_A;
  80       }
  81     #endif
  82
  83     base ()
  84     {
  85       ev_init (this, 0);
  86     }
  87
  88     void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents))
  89     {
  90       this->data = data;
  91       ev_set_cb (static_cast<ev_watcher *>(this), cb);
  92     }
  93
  94     // method callback
  95     template<class K, void (K::*method)(watcher &w, int)>
  96     void set (K *object)
  97     {
  98       set_ (object, method_thunk<K, method>);
  99     }
 100
 101     template<class K, void (K::*method)(watcher &w, int)>
 102     static void method_thunk (EV_P_ ev_watcher *w, int revents)
 103     {
 104       K *obj = static_cast<K *>(w->data);
 105       (obj->*method) (*static_cast<watcher *>(w), revents);
 106     }
 107
 108     // const method callback
 109     template<class K, void (K::*method)(watcher &w, int) const>
 110     void set (const K *object)
 111     {
 112       set_ (object, const_method_thunk<K, method>);
 113     }
 114
 115     template<class K, void (K::*method)(watcher &w, int) const>
 116     static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
 117     {
 118       K *obj = static_cast<K *>(w->data);
 119       (static_cast<K *>(w->data)->*method) (*static_cast<watcher *>(w), revents);
 120     }
 121
 122     // function callback
 123     template<void (*function)(watcher &w, int)>
 124     void set (void *data = 0)
 125     {
 126       set_ (data, function_thunk<function>);
 127     }
 128
 129     template<void (*function)(watcher &w, int)>
 130     static void function_thunk (EV_P_ ev_watcher *w, int revents)
 131     {
 132       function (*static_cast<watcher *>(w), revents);
 133     }
 134
 135     // simple callback
 136     template<class K, void (K::*method)()>
 137     void set (K *object)
 138     {
 139       set_ (object, method_noargs_thunk<K, method>);
 140     }
 141
 142     template<class K, void (K::*method)()>
 143     static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
 144     {
 145       K *obj = static_cast<K *>(w->data);
 146       (obj->*method) ();
 147     }
 148
 149     void operator ()(int events = EV_UNDEF)
 150     {
 151       return ev_cb (static_cast<ev_watcher *>(this))
 152         (static_cast<ev_watcher *>(this), events);
 153     }
 154
 155     bool is_active () const
 156     {
 157       return ev_is_active (static_cast<const ev_watcher *>(this));
 158     }
 159
 160     bool is_pending () const
 161     {
 162       return ev_is_pending (static_cast<const ev_watcher *>(this));
 163     }
 164   };
 165
 166
 167   inline ev_tstamp now (EV_P)
 168   {
 169     return ev_now (EV_A);
 170   }
 171
 172   #if EV_MULTIPLICITY
 173     #define EV_CONSTRUCT                                                                \
 174       (EV_P = EV_DEFAULT)                                                               \
 175       {                                                                                 \
 176         set (EV_A);                                                                     \
 177       }
 178   #else
 179     #define EV_CONSTRUCT                                                                \
 180       ()                                                                                \
 181       {                                                                                 \
 182       }
 183   #endif
 184
 185   /* using a template here would require quite a bit more lines,
 186    * so a macro solution was chosen */
 187   #define EV_BEGIN_WATCHER(cppstem,cstem)                                               \
 188                                                                                         \
 189   struct cppstem : base<ev_ ## cstem, cppstem>                                          \
 190   {                                                                                     \
 191     void start ()                                                                       \
 192     {                                                                                   \
 193       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
 194     }                                                                                   \
 195                                                                                         \
 196     void stop ()                                                                        \
 197     {                                                                                   \
 198       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
 199     }                                                                                   \
 200                                                                                         \
 201     cppstem EV_CONSTRUCT                                                                \
 202                                                                                         \
 203     ~cppstem ()                                                                         \
 204     {                                                                                   \
 205       stop ();                                                                          \
 206     }                                                                                   \
 207                                                                                         \
 208     using base<ev_ ## cstem, cppstem>::set;                                             \
 209                                                                                         \
 210   private:                                                                              \
 211                                                                                         \
 212     cppstem (const cppstem &o);                                                         \
 213                                                                                         \
 214     cppstem & operator =(const cppstem &o);                                             \
 215                                                                                         \
 216   public:
 217
 218   #define EV_END_WATCHER(cppstem,cstem)                                                 \
 219   };
 220
 221   EV_BEGIN_WATCHER (io, io)
 222     void set (int fd, int events)
 223     {
 224       int active = is_active ();
 225       if (active) stop ();
 226       ev_io_set (static_cast<ev_io *>(this), fd, events);
 227       if (active) start ();
 228     }
 229
 230     void set (int events)
 231     {
 232       int active = is_active ();
 233       if (active) stop ();
 234       ev_io_set (static_cast<ev_io *>(this), fd, events);
 235       if (active) start ();
 236     }
 237
 238     void start (int fd, int events)
 239     {
 240       set (fd, events);
 241       start ();
 242     }
 243   EV_END_WATCHER (io, io)
 244
 245   EV_BEGIN_WATCHER (timer, timer)
 246     void set (ev_tstamp after, ev_tstamp repeat = 0.)
 247     {
 248       int active = is_active ();
 249       if (active) stop ();
 250       ev_timer_set (static_cast<ev_timer *>(this), after, repeat);
 251       if (active) start ();
 252     }
 253
 254     void start (ev_tstamp after, ev_tstamp repeat = 0.)
 255     {
 256       set (after, repeat);
 257       start ();
 258     }
 259
 260     void again ()
 261     {
 262       ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
 263     }
 264   EV_END_WATCHER (timer, timer)
 265
 266   #if EV_PERIODIC_ENABLE
 267   EV_BEGIN_WATCHER (periodic, periodic)
 268     void set (ev_tstamp at, ev_tstamp interval = 0.)
 269     {
 270       int active = is_active ();
 271       if (active) stop ();
 272       ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);
 273       if (active) start ();
 274     }
 275
 276     void start (ev_tstamp at, ev_tstamp interval = 0.)
 277     {
 278       set (at, interval);
 279       start ();
 280     }
 281
 282     void again ()
 283     {
 284       ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
 285     }
 286   EV_END_WATCHER (periodic, periodic)
 287   #endif
 288
 289   EV_BEGIN_WATCHER (sig, signal)
 290     void set (int signum)
 291     {
 292       int active = is_active ();
 293       if (active) stop ();
 294       ev_signal_set (static_cast<ev_signal *>(this), signum);
 295       if (active) start ();
 296     }
 297
 298     void start (int signum)
 299     {
 300       set (signum);
 301       start ();
 302     }
 303   EV_END_WATCHER (sig, signal)
 304
 305   EV_BEGIN_WATCHER (child, child)
 306     void set (int pid)
 307     {
 308       int active = is_active ();
 309       if (active) stop ();
 310       ev_child_set (static_cast<ev_child *>(this), pid);
 311       if (active) start ();
 312     }
 313
 314     void start (int pid)
 315     {
 316       set (pid);
 317       start ();
 318     }
 319   EV_END_WATCHER (child, child)
 320
 321   #if EV_STAT_ENABLE
 322   EV_BEGIN_WATCHER (stat, stat)
 323     void set (const char *path, ev_tstamp interval = 0.)
 324     {
 325       int active = is_active ();
 326       if (active) stop ();
 327       ev_stat_set (static_cast<ev_stat *>(this), path, interval);
 328       if (active) start ();
 329     }
 330
 331     void start (const char *path, ev_tstamp interval = 0.)
 332     {
 333       stop ();
 334       set (path, interval);
 335       start ();
 336     }
 337
 338     void update ()
 339     {
 340       ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
 341     }
 342   EV_END_WATCHER (stat, stat)
 343   #endif
 344
 345   EV_BEGIN_WATCHER (idle, idle)
 346     void set () { }
 347   EV_END_WATCHER (idle, idle)
 348
 349   EV_BEGIN_WATCHER (prepare, prepare)
 350     void set () { }
 351   EV_END_WATCHER (prepare, prepare)
 352
 353   EV_BEGIN_WATCHER (check, check)
 354     void set () { }
 355   EV_END_WATCHER (check, check)
 356
 357   #if EV_EMBED_ENABLE
 358   EV_BEGIN_WATCHER (embed, embed)
 359     void start (struct ev_loop *embedded_loop)
 360     {
 361       stop ();
 362       ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
 363       start ();
 364     }
 365
 366     void sweep ()
 367     {
 368       ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
 369     }
 370   EV_END_WATCHER (embed, embed)
 371   #endif
 372
 373   #if EV_FORK_ENABLE
 374   EV_BEGIN_WATCHER (fork, fork)
 375     void set () { }
 376   EV_END_WATCHER (fork, fork)
 377   #endif
 378
 379   #undef EV_CONSTRUCT
 380   #undef EV_BEGIN_WATCHER
 381   #undef EV_END_WATCHER
 382 }
 383
 384 #endif
 385