--- libev/ev++.h 2007/11/27 22:31:52 1.11 +++ libev/ev++.h 2008/01/18 18:13:40 1.25 @@ -1,35 +1,54 @@ +/* + * libev simple C++ wrapper classes + * + * Copyright (c) 2007 Marc Alexander Lehmann + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modifica- + * tion, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER- + * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO + * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE- + * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH- + * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License ("GPL") version 2 or any later version, + * in which case the provisions of the GPL are applicable instead of + * the above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use your + * version of this file under the BSD license, indicate your decision + * by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file under + * either the BSD or the GPL. + */ + #ifndef EVPP_H__ #define EVPP_H__ -#include "ev.h" +#ifdef EV_H +# include EV_H +#else +# include "ev.h" +#endif namespace ev { - template - class callback - { - struct klass; // it is vital that this is never defined - - klass *o; - void (klass::*m)(watcher &, int); - - public: - template - explicit callback (O1 *object, void (O2::*method)(watcher &, int)) - { - o = reinterpret_cast(object); - m = reinterpret_cast(method); - } - - // 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) - { - (o->*m) (*w, revents); - } - }; + typedef ev_tstamp tstamp; enum { UNDEF = EV_UNDEF, @@ -49,7 +68,126 @@ ERROR = EV_ERROR, }; - typedef ev_tstamp tstamp; + enum + { + AUTO = EVFLAG_AUTO, + NOENV = EVFLAG_NOENV, + FORKCHECK = EVFLAG_FORKCHECK, + SELECT = EVBACKEND_SELECT, + POLL = EVBACKEND_POLL, + EPOLL = EVBACKEND_EPOLL, + KQUEUE = EVBACKEND_KQUEUE, + DEVPOLL = EVBACKEND_DEVPOLL, + PORT = EVBACKEND_PORT + }; + + enum + { + NONBLOCK = EVLOOP_NONBLOCK, + ONESHOT = EVLOOP_ONESHOT + }; + + enum how_t + { + ONE = EVUNLOOP_ONE, + ALL = EVUNLOOP_ALL + }; + + template + struct base : ev_watcher + { + #if EV_MULTIPLICITY + EV_P; + + void set (EV_P) + { + this->EV_A = EV_A; + } + #endif + + base () + { + ev_init (this, 0); + } + + void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) + { + this->data = data; + ev_set_cb (static_cast(this), cb); + } + + // method callback + template + void set (K *object) + { + 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); + } + + // 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)); + } + }; + inline ev_tstamp now (EV_P) { @@ -57,49 +195,24 @@ } #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) \ \ - struct cppstem : ev_ ## cstem, callback \ + struct cppstem : base \ { \ - EV_CONSTRUCT (cppstem) \ - { \ - ev_init (static_cast(this), thunk); \ - } \ - \ - 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)); \ @@ -110,28 +223,20 @@ ev_ ## cstem ## _stop (EV_A_ static_cast(this)); \ } \ \ - void operator ()(int events = EV_UNDEF) \ - { \ - return call (this, events); \ - } \ + cppstem EV_CONSTRUCT \ \ ~cppstem () \ { \ stop (); \ } \ \ - private: \ + using base::set; \ \ - cppstem (const cppstem &o) \ - : callback (this, (void (cppstem::*)(cppstem &, int))0) \ - { /* disabled */ } \ + private: \ \ - void operator =(const cppstem &o) { /* disabled */ } \ + cppstem (const cppstem &o); \ \ - static void thunk (EV_P_ struct ev_ ## cstem *w, int revents) \ - { \ - (*static_cast(w))(revents); \ - } \ + cppstem & operator =(const cppstem &o); \ \ public: @@ -250,6 +355,7 @@ void start (const char *path, ev_tstamp interval = 0.) { + stop (); set (path, interval); start (); } @@ -275,17 +381,10 @@ #if EV_EMBED_ENABLE EV_BEGIN_WATCHER (embed, embed) - void set (struct ev_loop *loop) - { - int active = is_active (); - if (active) stop (); - ev_embed_set (static_cast(this), loop); - if (active) start (); - } - void start (struct ev_loop *embedded_loop) { - set (embedded_loop); + stop (); + ev_embed_set (static_cast(this), embedded_loop); start (); }