--- libev/ev++.h 2008/01/18 18:13:40 1.25 +++ libev/ev++.h 2008/01/18 18:15:35 1.30 @@ -46,6 +46,18 @@ # include "ev.h" #endif +#ifndef EV_CXX_EXCEPTIONS +#define EV_CXX_EXCEPTIONS 1 +#endif + +#undef EV_THROW +#if EV_CXX_EXCEPTIONS +# include +# define EV_THROW(exception) throw (exception) +#else +# define EV_THROW(exception) +#endif + namespace ev { typedef ev_tstamp tstamp; @@ -93,24 +105,347 @@ ALL = EVUNLOOP_ALL }; +#if EV_CXX_EXCEPTIONS + struct bad_loop: std::runtime_error + { + bad_loop() + : std::runtime_error("loop can't be initialized") {} + }; +#endif + +#ifdef EV_AX +# undef EV_AX +#endif + +#ifdef EV_AX_ +# undef EV_AX_ +#endif + +#if EV_MULTIPLICITY +# define EV_AX raw_loop +# define EV_AX_ raw_loop, +#else +# define EV_AX +# define EV_AX_ +#endif + + struct loop_ref + { + + loop_ref (EV_P) +#if EV_MULTIPLICITY + EV_THROW (bad_loop) : EV_AX (EV_A) +#endif + { +#if EV_MULTIPLICIY && EV_CXX_EXCEPTIONS + if (!EV_A) + throw bad_loop (); +#endif + } + + bool operator== (const loop_ref &other) const EV_THROW () + { +#if EV_MULTIPLICITY + return this->EV_AX == other.EV_AX; +#else + return true; +#endif + } + + bool operator!= (const loop_ref &other) const EV_THROW () + { +#if EV_MULTIPLICITY + return ! (*this == other); +#else + return false; +#endif + } + +#if EV_MULTIPLICITY + bool operator== (struct ev_loop *other) const EV_THROW () + { + return this->EV_AX == other; + } + + bool operator!= (struct ev_loop *other) const EV_THROW () + { + return ! (*this == other); + } + + bool operator== (const struct ev_loop *other) const EV_THROW () + { + return this->EV_AX == other; + } + + bool operator!= (const struct ev_loop *other) const EV_THROW () + { + return (*this == other); + } + + operator struct ev_loop * () const EV_THROW () + { + return EV_AX; + } + + operator const struct ev_loop * () const EV_THROW () + { + return EV_AX; + } + + bool is_default () const EV_THROW () + { + return EV_AX == ev_default_loop (0); + } +#endif + + void loop (int flags = 0) + { + ev_loop (EV_AX_ flags); + } + + void unloop (how_t how = ONE) EV_THROW () + { + ev_unloop (EV_AX_ how); + } + + void post_fork () EV_THROW () + { +#if EV_MULTIPLICITY + ev_loop_fork (EV_AX); +#else + ev_default_fork (); +#endif + } + + unsigned int count () const EV_THROW () + { + return ev_loop_count (EV_AX); + } + + unsigned int backend () const EV_THROW () + { + return ev_backend (EV_AX); + } + + tstamp now () const EV_THROW () + { + return ev_now (EV_AX); + } + + void ref () EV_THROW () + { + ev_ref (EV_AX); + } + + void unref () EV_THROW () + { + ev_unref (EV_AX); + } + + void set_io_collect_interval (tstamp interval) EV_THROW () + { + ev_set_io_collect_interval (EV_AX_ interval); + } + + void set_timeout_collect_interval (tstamp interval) EV_THROW () + { + ev_set_timeout_collect_interval (EV_AX_ interval); + } + + // function callback + void once (int fd, int events, tstamp timeout, void (*cb)(int, void *), void* arg = 0) EV_THROW () + { + ev_once (EV_AX_ fd, events, timeout, cb, arg); + } + + // method callback + template + void once (int fd, int events, tstamp timeout, K *object) EV_THROW () + { + once (fd, events, timeout, method_thunk, object); + } + + template + static void method_thunk (int revents, void* arg) + { + K *obj = static_cast(arg); + (obj->*method) (revents); + } + + // const method callback + template + void once (int fd, int events, tstamp timeout, const K *object) EV_THROW () + { + once (fd, events, timeout, const_method_thunk, object); + } + + template + static void const_method_thunk (int revents, void* arg) + { + K *obj = static_cast(arg); + (obj->*method) (revents); + } + + // simple method callback + template + void once (int fd, int events, tstamp timeout, K *object) EV_THROW () + { + once (fd, events, timeout, method_noargs_thunk, object); + } + + template + static void method_noargs_thunk (int revents, void* arg) + { + K *obj = static_cast(arg); + (obj->*method) (); + } + + // simpler function callback + template + void once (int fd, int events, tstamp timeout) EV_THROW () + { + once (fd, events, timeout, simpler_func_thunk); + } + + template + static void simpler_func_thunk (int revents, void* arg) + { + (*cb) (revents); + } + + // simplest function callback + template + void once (int fd, int events, tstamp timeout) EV_THROW () + { + once (fd, events, timeout, simplest_func_thunk); + } + + template + static void simplest_func_thunk (int revents, void* arg) + { + (*cb) (); + } + + void feed_fd_event (int fd, int revents) EV_THROW () + { + ev_feed_fd_event (EV_AX_ fd, revents); + } + + void feed_signal_event (int signum) EV_THROW () + { + ev_feed_signal_event (EV_AX_ signum); + } + +#if EV_MULTIPLICITY + struct ev_loop* EV_AX; +#endif + + }; + +#if EV_MULTIPLICITY + struct dynamic_loop: loop_ref + { + + dynamic_loop (unsigned int flags = AUTO) EV_THROW (bad_loop) + : loop_ref (ev_loop_new (flags)) + { + } + + ~dynamic_loop () EV_THROW () + { + ev_loop_destroy (EV_AX); + EV_AX = 0; + } + + private: + + dynamic_loop (const dynamic_loop &); + + dynamic_loop & operator= (const dynamic_loop &); + + }; +#endif + + struct default_loop: loop_ref + { + + default_loop (unsigned int flags = AUTO) EV_THROW (bad_loop) +#if EV_MULTIPLICITY + : loop_ref (ev_default_loop (flags)) + { + } +#else + { + #if EV_CXX_EXCEPTIONS + int r = + #endif + ev_default_loop (flags); + #if EV_CXX_EXCEPTIONS + if (!r) + throw bad_loop (); + #endif + } +#endif + + ~default_loop () EV_THROW () + { + ev_default_destroy (); +#if EV_MULTIPLICITY + EV_AX = 0; +#endif + } + + private: + + default_loop (const default_loop &); + + default_loop & operator= (const default_loop &); + + }; + + inline loop_ref get_default_loop () EV_THROW () + { +#if EV_MULTIPLICITY + return ev_default_loop (0); +#else + return loop_ref (); +#endif + } + +#undef EV_AX +#undef EV_AX_ + +#undef EV_PX +#undef EV_PX_ +#if EV_MULTIPLICITY +# define EV_PX loop_ref EV_A +# define EV_PX_ loop_ref EV_A_ +#else +# define EV_PX +# define EV_PX_ +#endif + template struct base : ev_watcher { #if EV_MULTIPLICITY - EV_P; + EV_PX; - void set (EV_P) + void set (EV_PX) EV_THROW () { this->EV_A = EV_A; } #endif - base () + base (EV_PX) EV_THROW () + #if EV_MULTIPLICITY + : EV_A (EV_A) + #endif { ev_init (this, 0); } - void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) + void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) EV_THROW () { this->data = data; ev_set_cb (static_cast(this), cb); @@ -118,7 +453,7 @@ // method callback template - void set (K *object) + void set (K *object) EV_THROW () { set_ (object, method_thunk); } @@ -132,7 +467,7 @@ // const method callback template - void set (const K *object) + void set (const K *object) EV_THROW () { set_ (object, const_method_thunk); } @@ -146,7 +481,7 @@ // function callback template - void set (void *data = 0) + void set (void *data = 0) EV_THROW () { set_ (data, function_thunk); } @@ -159,7 +494,7 @@ // simple callback template - void set (K *object) + void set (K *object) EV_THROW () { set_ (object, method_noargs_thunk); } @@ -177,32 +512,76 @@ (static_cast(this), events); } - bool is_active () const + bool is_active () const EV_THROW () { return ev_is_active (static_cast(this)); } - bool is_pending () const + bool is_pending () const EV_THROW () { return ev_is_pending (static_cast(this)); } + + void feed_event (int revents) EV_THROW () + { + ev_feed_event (EV_A_ static_cast(this), revents); + } }; + inline tstamp now () EV_THROW () + { + return ev_time (); + } - inline ev_tstamp now (EV_P) + inline void delay (tstamp interval) EV_THROW () { - return ev_now (EV_A); + ev_sleep (interval); + } + + inline int version_major () EV_THROW () + { + return ev_version_major (); + } + + inline int version_minor () EV_THROW () + { + return ev_version_minor (); + } + + inline unsigned int supported_backends () EV_THROW () + { + return ev_supported_backends (); + } + + inline unsigned int recommended_backends () EV_THROW () + { + return ev_recommended_backends (); + } + + inline unsigned int embeddable_backends () EV_THROW () + { + return ev_embeddable_backends (); + } + + inline void set_allocator (void *(*cb)(void *ptr, long size)) EV_THROW () + { + ev_set_allocator (cb); + } + + inline void set_syserr_cb (void (*cb)(const char *msg)) EV_THROW () + { + ev_set_syserr_cb (cb); } #if EV_MULTIPLICITY - #define EV_CONSTRUCT \ - (EV_P = EV_DEFAULT) \ + #define EV_CONSTRUCT(cppstem,cstem) \ + (EV_PX = get_default_loop ()) EV_THROW () \ + : base (EV_A) \ { \ - set (EV_A); \ } #else - #define EV_CONSTRUCT \ - () \ + #define EV_CONSTRUCT(cppstem,cstem) \ + () EV_THROW () \ { \ } #endif @@ -213,19 +592,19 @@ \ struct cppstem : base \ { \ - void start () \ + void start () EV_THROW () \ { \ ev_ ## cstem ## _start (EV_A_ static_cast(this)); \ } \ \ - void stop () \ + void stop () EV_THROW () \ { \ ev_ ## cstem ## _stop (EV_A_ static_cast(this)); \ } \ \ - cppstem EV_CONSTRUCT \ + cppstem EV_CONSTRUCT(cppstem,cstem) \ \ - ~cppstem () \ + ~cppstem () EV_THROW () \ { \ stop (); \ } \ @@ -244,7 +623,7 @@ }; EV_BEGIN_WATCHER (io, io) - void set (int fd, int events) + void set (int fd, int events) EV_THROW () { int active = is_active (); if (active) stop (); @@ -252,7 +631,7 @@ if (active) start (); } - void set (int events) + void set (int events) EV_THROW () { int active = is_active (); if (active) stop (); @@ -260,7 +639,7 @@ if (active) start (); } - void start (int fd, int events) + void start (int fd, int events) EV_THROW () { set (fd, events); start (); @@ -268,7 +647,7 @@ EV_END_WATCHER (io, io) EV_BEGIN_WATCHER (timer, timer) - void set (ev_tstamp after, ev_tstamp repeat = 0.) + void set (ev_tstamp after, ev_tstamp repeat = 0.) EV_THROW () { int active = is_active (); if (active) stop (); @@ -276,13 +655,13 @@ if (active) start (); } - void start (ev_tstamp after, ev_tstamp repeat = 0.) + void start (ev_tstamp after, ev_tstamp repeat = 0.) EV_THROW () { set (after, repeat); start (); } - void again () + void again () EV_THROW () { ev_timer_again (EV_A_ static_cast(this)); } @@ -290,7 +669,7 @@ #if EV_PERIODIC_ENABLE EV_BEGIN_WATCHER (periodic, periodic) - void set (ev_tstamp at, ev_tstamp interval = 0.) + void set (ev_tstamp at, ev_tstamp interval = 0.) EV_THROW () { int active = is_active (); if (active) stop (); @@ -298,13 +677,13 @@ if (active) start (); } - void start (ev_tstamp at, ev_tstamp interval = 0.) + void start (ev_tstamp at, ev_tstamp interval = 0.) EV_THROW () { set (at, interval); start (); } - void again () + void again () EV_THROW () { ev_periodic_again (EV_A_ static_cast(this)); } @@ -312,7 +691,7 @@ #endif EV_BEGIN_WATCHER (sig, signal) - void set (int signum) + void set (int signum) EV_THROW () { int active = is_active (); if (active) stop (); @@ -320,7 +699,7 @@ if (active) start (); } - void start (int signum) + void start (int signum) EV_THROW () { set (signum); start (); @@ -328,7 +707,7 @@ EV_END_WATCHER (sig, signal) EV_BEGIN_WATCHER (child, child) - void set (int pid) + void set (int pid) EV_THROW () { int active = is_active (); if (active) stop (); @@ -336,7 +715,7 @@ if (active) start (); } - void start (int pid) + void start (int pid) EV_THROW () { set (pid); start (); @@ -345,7 +724,7 @@ #if EV_STAT_ENABLE EV_BEGIN_WATCHER (stat, stat) - void set (const char *path, ev_tstamp interval = 0.) + void set (const char *path, ev_tstamp interval = 0.) EV_THROW () { int active = is_active (); if (active) stop (); @@ -353,14 +732,14 @@ if (active) start (); } - void start (const char *path, ev_tstamp interval = 0.) + void start (const char *path, ev_tstamp interval = 0.) EV_THROW () { stop (); set (path, interval); start (); } - void update () + void update () EV_THROW () { ev_stat_stat (EV_A_ static_cast(this)); } @@ -368,20 +747,20 @@ #endif EV_BEGIN_WATCHER (idle, idle) - void set () { } + void set () EV_THROW () { } EV_END_WATCHER (idle, idle) EV_BEGIN_WATCHER (prepare, prepare) - void set () { } + void set () EV_THROW () { } EV_END_WATCHER (prepare, prepare) EV_BEGIN_WATCHER (check, check) - void set () { } + void set () EV_THROW () { } EV_END_WATCHER (check, check) #if EV_EMBED_ENABLE EV_BEGIN_WATCHER (embed, embed) - void start (struct ev_loop *embedded_loop) + void start (struct ev_loop *embedded_loop) EV_THROW () { stop (); ev_embed_set (static_cast(this), embedded_loop); @@ -397,14 +776,19 @@ #if EV_FORK_ENABLE EV_BEGIN_WATCHER (fork, fork) - void set () { } + void set () EV_THROW () { } EV_END_WATCHER (fork, fork) #endif + #undef EV_PX + #undef EV_PX_ #undef EV_CONSTRUCT #undef EV_BEGIN_WATCHER #undef EV_END_WATCHER + } +#undef EV_THROW + #endif