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   template<class ev_watcher, class watcher>
  52   struct base : ev_watcher
  53   {
  54     #if EV_MULTIPLICITY
  55       EV_P;
  56
  57       void set (EV_P)
  58       {
  59         this->EV_A = EV_A;
  60       }
  61     #endif
  62
  63     base ()
  64     {
  65       ev_init (this, 0);
  66     }
  67
  68     void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents))
  69     {
  70       this->data = data;
  71       ev_set_cb (static_cast<ev_watcher *>(this), cb);
  72     }
  73
  74     // method callback
  75     template<class K, void (K::*method)(watcher &w, int)>
  76     void set (K *object)
  77     {
  78       set_ (object, method_thunk<K, method>);
  79     }
  80
  81     template<class K, void (K::*method)(watcher &w, int)>
  82     static void method_thunk (EV_P_ ev_watcher *w, int revents)
  83     {
  84       K *obj = static_cast<K *>(w->data);
  85       (obj->*method) (*static_cast<watcher *>(w), revents);
  86     }
  87
  88     // const method callback
  89     template<class K, void (K::*method)(watcher &w, int) const>
  90     void set (const K *object)
  91     {
  92       set_ (object, const_method_thunk<K, method>);
  93     }
  94
  95     template<class K, void (K::*method)(watcher &w, int) const>
  96     static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
  97     {
  98       K *obj = static_cast<K *>(w->data);
  99       (static_cast<K *>(w->data)->*method) (*static_cast<watcher *>(w), revents);
 100     }
 101
 102     // function callback
 103     template<void (*function)(watcher &w, int)>
 104     void set (void *data = 0)
 105     {
 106       set_ (data, function_thunk<function>);
 107     }
 108
 109     template<void (*function)(watcher &w, int)>
 110     static void function_thunk (EV_P_ ev_watcher *w, int revents)
 111     {
 112       function (*static_cast<watcher *>(w), revents);
 113     }
 114
 115     // simple callback
 116     template<class K, void (K::*method)()>
 117     void set (K *object)
 118     {
 119       set_ (object, method_noargs_thunk<K, method>);
 120     }
 121
 122     template<class K, void (K::*method)()>
 123     static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
 124     {
 125       K *obj = static_cast<K *>(w->data);
 126       (obj->*method) ();
 127     }
 128
 129     void operator ()(int events = EV_UNDEF)
 130     {
 131       return ev_cb (static_cast<ev_watcher *>(this))
 132         (static_cast<ev_watcher *>(this), events);
 133     }
 134
 135     bool is_active () const
 136     {
 137       return ev_is_active (static_cast<const ev_watcher *>(this));
 138     }
 139
 140     bool is_pending () const
 141     {
 142       return ev_is_pending (static_cast<const ev_watcher *>(this));
 143     }
 144   };
 145
 146   enum {
 147     UNDEF    = EV_UNDEF,
 148     NONE     = EV_NONE,
 149     READ     = EV_READ,
 150     WRITE    = EV_WRITE,
 151     TIMEOUT  = EV_TIMEOUT,
 152     PERIODIC = EV_PERIODIC,
 153     SIGNAL   = EV_SIGNAL,
 154     CHILD    = EV_CHILD,
 155     STAT     = EV_STAT,
 156     IDLE     = EV_IDLE,
 157     CHECK    = EV_CHECK,
 158     PREPARE  = EV_PREPARE,
 159     FORK     = EV_FORK,
 160     EMBED    = EV_EMBED,
 161     ERROR    = EV_ERROR,
 162   };
 163
 164   typedef ev_tstamp tstamp;
 165
 166   inline ev_tstamp now (EV_P)
 167   {
 168     return ev_now (EV_A);
 169   }
 170
 171   #if EV_MULTIPLICITY
 172     #define EV_CONSTRUCT                                                                \
 173       (EV_P = EV_DEFAULT)                                                               \
 174       {                                                                                 \
 175         set (EV_A);                                                                     \
 176       }
 177   #else
 178     #define EV_CONSTRUCT                                                                \
 179       ()                                                                                \
 180       {                                                                                 \
 181       }
 182   #endif
 183
 184   /* using a template here would require quite a bit more lines,
 185    * so a macro solution was chosen */
 186   #define EV_BEGIN_WATCHER(cppstem,cstem)                                               \
 187                                                                                         \
 188   struct cppstem : base<ev_ ## cstem, cppstem>                                          \
 189   {                                                                                     \
 190     void start ()                                                                       \
 191     {                                                                                   \
 192       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
 193     }                                                                                   \
 194                                                                                         \
 195     void stop ()                                                                        \
 196     {                                                                                   \
 197       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
 198     }                                                                                   \
 199                                                                                         \
 200     cppstem EV_CONSTRUCT                                                                \
 201                                                                                         \
 202     ~cppstem ()                                                                         \
 203     {                                                                                   \
 204       stop ();                                                                          \
 205     }                                                                                   \
 206                                                                                         \
 207     using base<ev_ ## cstem, cppstem>::set;                                             \
 208                                                                                         \
 209   private:                                                                              \
 210                                                                                         \
 211     cppstem (const cppstem &o)                                                          \
 212     { /* disabled */ }                                                                  \
 213                                                                                         \
 214     void operator =(const cppstem &o) { /* disabled */ }                                \
 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