X-Git-Url: https://git.llucax.com/software/libev.git/blobdiff_plain/d1d02ca0040b567cfc3081701b52b0361412a444..f6cc1f750a321b2c6e30637963d3e624c7a8e5ae:/ev%20%20.h/software/libev.git/blobdiff_plain/d1d02ca0040b567cfc3081701b52b0361412a444..f6cc1f750a321b2c6e30637963d3e624c7a8e5ae:/ev++.h diff --git a/ev++.h b/ev++.h index 95d0a76..c51e161 100644 --- a/ev++.h +++ b/ev++.h @@ -1,50 +1,53 @@ #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 { - struct object { }; + struct klass; // it is vital that this is never defined - 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 - { - ((reinterpret_cast(obj)) ->* (reinterpret_cast(meth))) - (w, e); - } - }; - - proxy_base *prxy; + klass *o; + void (klass::*m)(watcher &, int); public: template explicit callback (O1 *object, void (O2::*method)(watcher &, int)) { - static proxy p; - obj = reinterpret_cast(object); - meth = reinterpret_cast(method); - prxy = &p; + o = reinterpret_cast(object); + m = reinterpret_cast(method); } - void call (watcher *w, int e) const + // this works because a standards-compliant C++ compiler + // basically can't help it: it doesn't have the knowledge + // required to miscompile (klass is not defined anywhere + // and nothing is known about the constructor arguments) :) + void call (watcher *w, int revents) { - return prxy->call (obj, meth, *w, e); + (o->*m) (*w, revents); } }; - #include "ev.h" + enum { + UNDEF = EV_UNDEF, + NONE = EV_NONE, + READ = EV_READ, + WRITE = EV_WRITE, + TIMEOUT = EV_TIMEOUT, + PERIODIC = EV_PERIODIC, + SIGNAL = EV_SIGNAL, + CHILD = EV_CHILD, + STAT = EV_STAT, + IDLE = EV_IDLE, + CHECK = EV_CHECK, + PREPARE = EV_PREPARE, + FORK = EV_FORK, + EMBED = EV_EMBED, + ERROR = EV_ERROR, + }; typedef ev_tstamp tstamp; @@ -78,15 +81,13 @@ namespace ev { /* using a template here would require quite a bit more lines, * so a macro solution was chosen */ - #define EV_DECLARE_WATCHER(cppstem,cstem) \ - \ - extern "C" void cb_ ## cppstem (struct ev_ ## cstem *w, int revents); \ + #define EV_BEGIN_WATCHER(cppstem,cstem) \ \ struct cppstem : ev_ ## cstem, callback \ { \ EV_CONSTRUCT (cppstem) \ { \ - ev_init (static_cast(this), cb_ ## cppstem); \ + ev_init (static_cast(this), thunk); \ } \ \ bool is_active () const \ @@ -114,16 +115,30 @@ namespace ev { return call (this, events); \ } \ \ + ~cppstem () \ + { \ + stop (); \ + } \ + \ private: \ \ cppstem (const cppstem &o) \ : callback (this, (void (cppstem::*)(cppstem &, int))0) \ { /* disabled */ } \ + \ void operator =(const cppstem &o) { /* disabled */ } \ \ + static void thunk (EV_P_ struct ev_ ## cstem *w, int revents) \ + { \ + (*static_cast(w))(revents); \ + } \ + \ public: - EV_DECLARE_WATCHER (io, io) + #define EV_END_WATCHER(cppstem,cstem) \ + }; + + EV_BEGIN_WATCHER (io, io) void set (int fd, int events) { int active = is_active (); @@ -145,9 +160,9 @@ namespace ev { set (fd, events); start (); } - }; + EV_END_WATCHER (io, io) - EV_DECLARE_WATCHER (timer, timer) + EV_BEGIN_WATCHER (timer, timer) void set (ev_tstamp after, ev_tstamp repeat = 0.) { int active = is_active (); @@ -166,9 +181,10 @@ namespace ev { { ev_timer_again (EV_A_ static_cast(this)); } - }; + EV_END_WATCHER (timer, timer) - EV_DECLARE_WATCHER (periodic, periodic) + #if EV_PERIODIC_ENABLE + EV_BEGIN_WATCHER (periodic, periodic) void set (ev_tstamp at, ev_tstamp interval = 0.) { int active = is_active (); @@ -187,18 +203,10 @@ namespace ev { { ev_periodic_again (EV_A_ static_cast(this)); } - }; - - EV_DECLARE_WATCHER (idle, idle) - }; - - EV_DECLARE_WATCHER (prepare, prepare) - }; - - EV_DECLARE_WATCHER (check, check) - }; + EV_END_WATCHER (periodic, periodic) + #endif - EV_DECLARE_WATCHER (sig, signal) + EV_BEGIN_WATCHER (sig, signal) void set (int signum) { int active = is_active (); @@ -212,9 +220,9 @@ namespace ev { set (signum); start (); } - }; + EV_END_WATCHER (sig, signal) - EV_DECLARE_WATCHER (child, child) + EV_BEGIN_WATCHER (child, child) void set (int pid) { int active = is_active (); @@ -228,10 +236,69 @@ namespace ev { set (pid); start (); } - }; + 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_DECLARE_WATCHER + #undef EV_BEGIN_WATCHER + #undef EV_END_WATCHER } #endif