X-Git-Url: https://git.llucax.com/software/libev.git/blobdiff_plain/81cf5185ab497ccd9b0655d5b1fbe4db569e5228..6fb30a67f78730c733f64429f327e360ea2acaf3:/ev%20%20.h/software/libev.git/blobdiff_plain/81cf5185ab497ccd9b0655d5b1fbe4db569e5228..6fb30a67f78730c733f64429f327e360ea2acaf3:/ev++.h?ds=inline diff --git a/ev++.h b/ev++.h index cff3c6a..ac63970 100644 --- a/ev++.h +++ b/ev++.h @@ -1,50 +1,104 @@ #ifndef EVPP_H__ #define EVPP_H__ -/* work in progress, don't use unless you know what you are doing */ +#include "ev.h" namespace ev { - template - class callback + template + struct base : ev_watcher { - struct object { }; - - void *obj; - void (object::*meth)(watcher &, int); - - /* a proxy is a kind of recipe on how to call a specific class method */ - struct proxy_base { - virtual void call (void *obj, void (object::*meth)(watcher &, int), watcher &w, int) const = 0; - }; - template - struct proxy : proxy_base { - virtual void call (void *obj, void (object::*meth)(watcher &, int), watcher &w, int e) const + #if EV_MULTIPLICITY + EV_P; + + void set (EV_P) { - ((reinterpret_cast(obj)) ->* (reinterpret_cast(meth))) - (w, e); + this->EV_A = EV_A; } - }; + #endif - proxy_base *prxy; + base () + { + ev_init (this, 0); + } - public: - template - explicit callback (O1 *object, void (O2::*method)(watcher &, int)) + void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) { - static proxy p; - obj = reinterpret_cast(object); - meth = reinterpret_cast(method); - prxy = &p; + this->data = data; + ev_set_cb (static_cast(this), cb); } - void call (watcher *w, int e) const + // method callback + template + void set (K *object) { - return prxy->call (obj, meth, *w, e); + set_ (object, method_thunk); + } + + template + static void method_thunk (EV_P_ ev_watcher *w, int revents) + { + K *obj = static_cast(w->data); + (obj->*method) (*static_cast(w), revents); } - }; - #include "ev.h" + // const method callback + template + void set (const K *object) + { + set_ (object, const_method_thunk); + } + + template + static void const_method_thunk (EV_P_ ev_watcher *w, int revents) + { + K *obj = static_cast(w->data); + (static_cast(w->data)->*method) (*static_cast(w), revents); + } + + // function callback + template + void set (void *data = 0) + { + set_ (data, function_thunk); + } + + template + static void function_thunk (EV_P_ ev_watcher *w, int revents) + { + function (*static_cast(w), revents); + } + + // simple callback + template + void set (K *object) + { + set_ (object, method_noargs_thunk); + } + + template + static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents) + { + K *obj = static_cast(w->data); + (obj->*method) (); + } + + void operator ()(int events = EV_UNDEF) + { + return ev_cb (static_cast(this)) + (static_cast(this), events); + } + + bool is_active () const + { + return ev_is_active (static_cast(this)); + } + + bool is_pending () const + { + return ev_is_pending (static_cast(this)); + } + }; enum { UNDEF = EV_UNDEF, @@ -54,10 +108,13 @@ namespace ev { TIMEOUT = EV_TIMEOUT, PERIODIC = EV_PERIODIC, SIGNAL = EV_SIGNAL, + CHILD = EV_CHILD, + STAT = EV_STAT, IDLE = EV_IDLE, CHECK = EV_CHECK, PREPARE = EV_PREPARE, - CHILD = EV_CHILD, + FORK = EV_FORK, + EMBED = EV_EMBED, ERROR = EV_ERROR, }; @@ -69,51 +126,24 @@ namespace ev { } #if EV_MULTIPLICITY - - #define EV_CONSTRUCT(cppstem) \ - EV_P; \ - \ - void set (EV_P) \ + #define EV_CONSTRUCT \ + (EV_P = EV_DEFAULT) \ { \ - this->EV_A = EV_A; \ - } \ - \ - template \ - explicit cppstem (O1 *object, void (O2::*method)(cppstem &, int), EV_P = ev_default_loop (0)) \ - : callback (object, method), EV_A (EV_A) - + set (EV_A); \ + } #else - - #define EV_CONSTRUCT(cppstem) \ - template \ - explicit cppstem (O1 *object, void (O2::*method)(cppstem &, int)) \ - : callback (object, method) - + #define EV_CONSTRUCT \ + () \ + { \ + } #endif /* using a template here would require quite a bit more lines, * so a macro solution was chosen */ #define EV_BEGIN_WATCHER(cppstem,cstem) \ \ - static void cb_ ## cppstem (EV_P_ struct ev_ ## cstem *w, int revents); \ - \ - struct cppstem : ev_ ## cstem, callback \ + struct cppstem : base \ { \ - EV_CONSTRUCT (cppstem) \ - { \ - ev_init (static_cast(this), cb_ ## cppstem); \ - } \ - \ - bool is_active () const \ - { \ - return ev_is_active (static_cast(this)); \ - } \ - \ - bool is_pending () const \ - { \ - return ev_is_pending (static_cast(this)); \ - } \ - \ void start () \ { \ ev_ ## cstem ## _start (EV_A_ static_cast(this)); \ @@ -124,32 +154,26 @@ namespace ev { ev_ ## cstem ## _stop (EV_A_ static_cast(this)); \ } \ \ - void operator ()(int events = EV_UNDEF) \ - { \ - return call (this, events); \ - } \ + cppstem EV_CONSTRUCT \ \ ~cppstem () \ { \ stop (); \ } \ \ + using base::set; \ + \ private: \ \ cppstem (const cppstem &o) \ - : callback (this, (void (cppstem::*)(cppstem &, int))0) \ { /* disabled */ } \ + \ void operator =(const cppstem &o) { /* disabled */ } \ \ public: #define EV_END_WATCHER(cppstem,cstem) \ - }; \ - \ - static void cb_ ## cppstem (EV_P_ struct ev_ ## cstem *w, int revents) \ - { \ - (*static_cast(w))(revents); \ - } + }; EV_BEGIN_WATCHER (io, io) void set (int fd, int events) @@ -196,7 +220,7 @@ namespace ev { } EV_END_WATCHER (timer, timer) - #if EV_PERIODICS + #if EV_PERIODIC_ENABLE EV_BEGIN_WATCHER (periodic, periodic) void set (ev_tstamp at, ev_tstamp interval = 0.) { @@ -219,15 +243,6 @@ namespace ev { EV_END_WATCHER (periodic, periodic) #endif - EV_BEGIN_WATCHER (idle, idle) - EV_END_WATCHER (idle, idle) - - EV_BEGIN_WATCHER (prepare, prepare) - EV_END_WATCHER (prepare, prepare) - - EV_BEGIN_WATCHER (check, check) - EV_END_WATCHER (check, check) - EV_BEGIN_WATCHER (sig, signal) void set (int signum) { @@ -260,8 +275,67 @@ namespace ev { } EV_END_WATCHER (child, child) + #if EV_STAT_ENABLE + EV_BEGIN_WATCHER (stat, stat) + void set (const char *path, ev_tstamp interval = 0.) + { + int active = is_active (); + if (active) stop (); + ev_stat_set (static_cast(this), path, interval); + if (active) start (); + } + + void start (const char *path, ev_tstamp interval = 0.) + { + stop (); + set (path, interval); + start (); + } + + void update () + { + ev_stat_stat (EV_A_ static_cast(this)); + } + EV_END_WATCHER (stat, stat) + #endif + + EV_BEGIN_WATCHER (idle, idle) + void set () { } + EV_END_WATCHER (idle, idle) + + EV_BEGIN_WATCHER (prepare, prepare) + void set () { } + EV_END_WATCHER (prepare, prepare) + + EV_BEGIN_WATCHER (check, check) + void set () { } + EV_END_WATCHER (check, check) + + #if EV_EMBED_ENABLE + EV_BEGIN_WATCHER (embed, embed) + void start (struct ev_loop *embedded_loop) + { + stop (); + ev_embed_set (static_cast(this), embedded_loop); + start (); + } + + void sweep () + { + ev_embed_sweep (EV_A_ static_cast(this)); + } + EV_END_WATCHER (embed, embed) + #endif + + #if EV_FORK_ENABLE + EV_BEGIN_WATCHER (fork, fork) + void set () { } + EV_END_WATCHER (fork, fork) + #endif + #undef EV_CONSTRUCT #undef EV_BEGIN_WATCHER + #undef EV_END_WATCHER } #endif