make excptions mandatory but stdexcept.h not, make \!EV_MULTIPLICITY compile

[software/libev.git] / ev++.h

diff --git a/ev++.h b/ev++.h
index 0f51bd5fce2950b807a94a65b25fda12fddb7934..8b1f93605045d27df39542f03ecd6caad4aea6ee 100644 (file)
--- a/ev++.h
+++ b/ev++.h
@@ -1,48 +1,62 @@
+/*
+ * libev simple C++ wrapper classes
+ *
+ * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
+ * 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__
 
 #ifndef EVPP_H__
 #define EVPP_H__
 

-#include "ev.h"
-
-namespace ev {
+#ifdef EV_H
+# include EV_H
+#else
+# include "ev.h"
+#endif

 
 

-  template<class watcher>
-  class callback
-  {
-    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<class O1, class O2>
-    struct proxy : proxy_base {
-      virtual void call (void *obj, void (object::*meth)(watcher &, int), watcher &w, int e) const
-      {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<void (O2::*)(watcher &, int)>(meth)))
-          (w, e);
-      }
-    };
+#ifndef EV_USE_STDEXCEPT
+# define EV_USE_STDEXCEPT 1
+#endif

 
 

-    proxy_base *prxy;
+#if EV_USE_STDEXCEPT
+# include <stdexcept>
+#endif

 
 

-  public:
-    template<class O1, class O2>
-    explicit callback (O1 *object, void (O2::*method)(watcher &, int))
-    {
-      static proxy<O1,O2> p;
-      obj  = reinterpret_cast<void *>(object);
-      meth = reinterpret_cast<void (object::*)(watcher &, int)>(method);
-      prxy = &p;
-    }
+namespace ev {

 
 

-    void call (watcher *w, int e) const
-    {
-      return prxy->call (obj, meth, *w, e);
-    }
-  };
+  typedef ev_tstamp tstamp;

 
   enum {
     UNDEF    = EV_UNDEF,
 
   enum {
     UNDEF    = EV_UNDEF,


@@ -52,96 +66,544 @@ namespace ev {
     TIMEOUT  = EV_TIMEOUT,
     PERIODIC = EV_PERIODIC,
     SIGNAL   = EV_SIGNAL,
     TIMEOUT  = EV_TIMEOUT,
     PERIODIC = EV_PERIODIC,
     SIGNAL   = EV_SIGNAL,

+    CHILD    = EV_CHILD,
+    STAT     = EV_STAT,

     IDLE     = EV_IDLE,
     CHECK    = EV_CHECK,
     PREPARE  = EV_PREPARE,
     IDLE     = EV_IDLE,
     CHECK    = EV_CHECK,
     PREPARE  = EV_PREPARE,

-    CHILD    = EV_CHILD,
+    FORK     = EV_FORK,
+    EMBED    = EV_EMBED,

     ERROR    = EV_ERROR,
   };
 
     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
+  };
+
+  struct bad_loop
+#if EV_USE_STDEXCEPT
+  : std::runtime_error
+#endif
+  {
+#if EV_USE_STDEXCEPT
+    bad_loop ()
+    : std::runtime_error ("libev event loop cannot be initialized, bad value of LIBEV_FLAGS?")
+    {
+    }
+#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) throw (bad_loop)
+#if EV_MULTIPLICITY
+    : EV_AX (EV_A)
+#endif
+    {
+#if EV_MULTIPLICITY
+      if (!EV_AX)
+        throw bad_loop ();
+#endif
+    }
+
+    bool operator == (const loop_ref &other) const throw ()
+    {
+#if EV_MULTIPLICITY
+      return EV_AX == other.EV_AX;
+#else
+      return true;
+#endif
+    }
+
+    bool operator != (const loop_ref &other) const throw ()
+    {
+#if EV_MULTIPLICITY
+      return ! (*this == other);
+#else
+      return false;
+#endif
+    }
+
+#if EV_MULTIPLICITY
+    bool operator== (struct ev_loop *other) const throw ()
+    {
+      return this->EV_AX == other;
+    }
+
+    bool operator!= (struct ev_loop *other) const throw ()
+    {
+      return ! (*this == other);
+    }
+
+    bool operator== (const struct ev_loop *other) const throw ()
+    {
+      return this->EV_AX == other;
+    }
+
+    bool operator!= (const struct ev_loop *other) const throw ()
+    {
+      return (*this == other);
+    }
+
+    operator struct ev_loop * () const throw ()
+    {
+      return EV_AX;
+    }
+
+    operator const struct ev_loop * () const throw ()
+    {
+      return EV_AX;
+    }
+
+    bool is_default () const throw ()
+    {
+      return EV_AX == ev_default_loop (0);
+    }
+#endif

 
 

-  inline ev_tstamp now (EV_P)
+    void loop (int flags = 0)
+    {
+      ev_loop (EV_AX_ flags);
+    }
+
+    void unloop (how_t how = ONE) throw ()
+    {
+      ev_unloop (EV_AX_ how);
+    }
+
+    void post_fork () throw ()
+    {
+#if EV_MULTIPLICITY
+      ev_loop_fork (EV_AX);
+#else
+      ev_default_fork ();
+#endif
+    }
+
+    unsigned int count () const throw ()
+    {
+      return ev_loop_count (EV_AX);
+    }
+
+    unsigned int backend () const throw ()
+    {
+      return ev_backend (EV_AX);
+    }
+
+    tstamp now () const throw ()
+    {
+      return ev_now (EV_AX);
+    }
+
+    void ref () throw ()
+    {
+      ev_ref (EV_AX);
+    }
+
+    void unref () throw ()
+    {
+      ev_unref (EV_AX);
+    }
+
+    void set_io_collect_interval (tstamp interval) throw ()
+    {
+      ev_set_io_collect_interval (EV_AX_ interval);
+    }
+
+    void set_timeout_collect_interval (tstamp interval) 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) throw ()
+    {
+      ev_once (EV_AX_ fd, events, timeout, cb, arg);
+    }
+
+    // method callback
+    template<class K, void (K::*method)(int)>
+    void once (int fd, int events, tstamp timeout, K *object) throw ()
+    {
+      once (fd, events, timeout, method_thunk<K, method>, object);
+    }
+
+    template<class K, void (K::*method)(int)>
+    static void method_thunk (int revents, void* arg)
+    {
+      K *obj = static_cast<K *>(arg);
+      (obj->*method) (revents);
+    }
+
+    // const method callback
+    template<class K, void (K::*method)(int) const>
+    void once (int fd, int events, tstamp timeout, const K *object) throw ()
+    {
+      once (fd, events, timeout, const_method_thunk<K, method>, object);
+    }
+
+    template<class K, void (K::*method)(int) const>
+    static void const_method_thunk (int revents, void* arg)
+    {
+      K *obj = static_cast<K *>(arg);
+      (obj->*method) (revents);
+    }
+
+    // simple method callback
+    template<class K, void (K::*method)()>
+    void once (int fd, int events, tstamp timeout, K *object) throw ()
+    {
+      once (fd, events, timeout, method_noargs_thunk<K, method>, object);
+    }
+
+    template<class K, void (K::*method)()>
+    static void method_noargs_thunk (int revents, void* arg)
+    {
+      K *obj = static_cast<K *>(arg);
+      (obj->*method) ();
+    }
+
+    // simpler function callback
+    template<void (*cb)(int)>
+    void once (int fd, int events, tstamp timeout) throw ()
+    {
+      once (fd, events, timeout, simpler_func_thunk<cb>);
+    }
+
+    template<void (*cb)(int)>
+    static void simpler_func_thunk (int revents, void* arg)
+    {
+      (*cb) (revents);
+    }
+
+    // simplest function callback
+    template<void (*cb)()>
+    void once (int fd, int events, tstamp timeout) throw ()
+    {
+      once (fd, events, timeout, simplest_func_thunk<cb>);
+    }
+
+    template<void (*cb)()>
+    static void simplest_func_thunk (int revents, void* arg)
+    {
+      (*cb) ();
+    }
+
+    void feed_fd_event (int fd, int revents) throw ()
+    {
+      ev_feed_fd_event (EV_AX_ fd, revents);
+    }
+
+    void feed_signal_event (int signum) 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

   {
   {

-    return ev_now (EV_A);
+
+    dynamic_loop (unsigned int flags = AUTO) EV_THROW (bad_loop)
+      : loop_ref (ev_loop_new (flags))
+    {
+    }
+
+    ~dynamic_loop () 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) throw (bad_loop)
+#if EV_MULTIPLICITY
+    : loop_ref (ev_default_loop (flags))
+#endif
+    {
+#ifndef EV_MULTIPLICITY
+    if (!ev_default_loop (flags))
+      throw bad_loop ();
+#endif
+    }
+
+    ~default_loop () throw ()
+    {
+      ev_default_destroy ();
+    }
+
+  private:
+    default_loop (const default_loop &);
+    default_loop &operator = (const default_loop &);
+  };
+
+  inline loop_ref get_default_loop () throw ()
+  {
+#if EV_MULTIPLICITY
+    return ev_default_loop (0);
+#else
+    return loop_ref ();
+#endif

   }
 
   }
 

-  #if EV_MULTIPLICITY
+#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

 
 

-    #define EV_CONSTRUCT(cppstem)                                                      \
-      EV_P;                                                                             \
-                                                                                        \
-      void set (EV_P)                                                                   \
-      {                                                                                 \
-        this->EV_A = EV_A;                                                              \
-      }                                                                                 \
-                                                                                        \
-      template<class O1, class O2>                                                      \
-      explicit cppstem (O1 *object, void (O2::*method)(cppstem &, int), EV_P = ev_default_loop (0)) \
-      : callback<cppstem> (object, method), EV_A (EV_A)
+  template<class ev_watcher, class watcher>
+  struct base : ev_watcher
+  {
+    #if EV_MULTIPLICITY
+      EV_PX;

 
 

-  #else
+      void set (EV_PX) throw ()
+      {
+        this->EV_A = EV_A;
+      }
+    #endif
+
+    base (EV_PX) 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)) throw ()
+    {
+      this->data = data;
+      ev_set_cb (static_cast<ev_watcher *>(this), cb);
+    }
+
+    // method callback
+    template<class K, void (K::*method)(watcher &w, int)>
+    void set (K *object) throw ()
+    {
+      set_ (object, method_thunk<K, method>);
+    }
+
+    template<class K, void (K::*method)(watcher &w, int)>
+    static void method_thunk (EV_P_ ev_watcher *w, int revents)
+    {
+      K *obj = static_cast<K *>(w->data);
+      (obj->*method) (*static_cast<watcher *>(w), revents);
+    }
+
+    // const method callback
+    template<class K, void (K::*method)(watcher &w, int) const>
+    void set (const K *object) throw ()
+    {
+      set_ (object, const_method_thunk<K, method>);
+    }
+
+    template<class K, void (K::*method)(watcher &w, int) const>
+    static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
+    {
+      K *obj = static_cast<K *>(w->data);
+      (static_cast<K *>(w->data)->*method) (*static_cast<watcher *>(w), revents);
+    }
+
+    // function callback
+    template<void (*function)(watcher &w, int)>
+    void set (void *data = 0) throw ()
+    {
+      set_ (data, function_thunk<function>);
+    }
+
+    template<void (*function)(watcher &w, int)>
+    static void function_thunk (EV_P_ ev_watcher *w, int revents)
+    {
+      function (*static_cast<watcher *>(w), revents);
+    }

 
 

-    #define EV_CONSTRUCT(cppstem)                                                      \
-      template<class O1, class O2>                                                     \
-      explicit cppstem (O1 *object, void (O2::*method)(cppstem &, int))                 \
-      : callback<cppstem> (object, method)
+    // simple callback
+    template<class K, void (K::*method)()>
+    void set (K *object) throw ()
+    {
+      set_ (object, method_noargs_thunk<K, method>);
+    }

 
 

+    template<class K, void (K::*method)()>
+    static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
+    {
+      K *obj = static_cast<K *>(w->data);
+      (obj->*method) ();
+    }
+
+    void operator ()(int events = EV_UNDEF)
+    {
+      return ev_cb (static_cast<ev_watcher *>(this))
+        (static_cast<ev_watcher *>(this), events);
+    }
+
+    bool is_active () const throw ()
+    {
+      return ev_is_active (static_cast<const ev_watcher *>(this));
+    }
+
+    bool is_pending () const throw ()
+    {
+      return ev_is_pending (static_cast<const ev_watcher *>(this));
+    }
+
+    void feed_event (int revents) throw ()
+    {
+      ev_feed_event (EV_A_ static_cast<const ev_watcher *>(this), revents);
+    }
+  };
+
+  inline tstamp now () throw ()
+  {
+    return ev_time ();
+  }
+
+  inline void delay (tstamp interval) throw ()
+  {
+    ev_sleep (interval);
+  }
+
+  inline int version_major () throw ()
+  {
+    return ev_version_major ();
+  }
+
+  inline int version_minor () throw ()
+  {
+    return ev_version_minor ();
+  }
+
+  inline unsigned int supported_backends () throw ()
+  {
+    return ev_supported_backends ();
+  }
+
+  inline unsigned int recommended_backends () throw ()
+  {
+    return ev_recommended_backends ();
+  }
+
+  inline unsigned int embeddable_backends () throw ()
+  {
+    return ev_embeddable_backends ();
+  }
+
+  inline void set_allocator (void *(*cb)(void *ptr, long size)) throw ()
+  {
+    ev_set_allocator (cb);
+  }
+
+  inline void set_syserr_cb (void (*cb)(const char *msg)) throw ()
+  {
+    ev_set_syserr_cb (cb);
+  }
+
+  #if EV_MULTIPLICITY
+    #define EV_CONSTRUCT(cppstem,cstem)                                                        \
+      (EV_PX = get_default_loop ()) throw ()                                         \
+        : base<ev_ ## cstem, cppstem> (EV_A)                                            \
+      {                                                                                 \
+      }
+  #else
+    #define EV_CONSTRUCT(cppstem,cstem)                                                 \
+      () throw ()                                                                    \
+      {                                                                                 \
+      }

   #endif
 
   /* using a template here would require quite a bit more lines,
    * so a macro solution was chosen */
   #define EV_BEGIN_WATCHER(cppstem,cstem)                                              \
                                                                                         \
   #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<cppstem>                                      \
+  struct cppstem : base<ev_ ## cstem, cppstem>                                          \

   {                                                                                     \
   {                                                                                     \

-    EV_CONSTRUCT (cppstem)                                                              \
-    {                                                                                   \
-      ev_init (static_cast<ev_ ## cstem *>(this), thunk);                               \
-    }                                                                                   \
-                                                                                        \
-    bool is_active () const                                                             \
-    {                                                                                   \
-      return ev_is_active (static_cast<const ev_ ## cstem *>(this));                    \
-    }                                                                                   \
-                                                                                        \
-    bool is_pending () const                                                            \
-    {                                                                                   \
-      return ev_is_pending (static_cast<const ev_ ## cstem *>(this));                   \
-    }                                                                                   \
-                                                                                        \
-    void start ()                                                                       \
+    void start () throw ()                                                           \

     {                                                                                   \
       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
     }                                                                                   \
                                                                                         \
     {                                                                                   \
       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
     }                                                                                   \
                                                                                         \

-    void stop ()                                                                        \
+    void stop () throw ()                                                            \

     {                                                                                   \
       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
     }                                                                                   \
                                                                                         \
     {                                                                                   \
       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
     }                                                                                   \
                                                                                         \

-    void operator ()(int events = EV_UNDEF)                                             \
-    {                                                                                   \
-      return call (this, events);                                                       \
-    }                                                                                   \
+    cppstem EV_CONSTRUCT(cppstem,cstem)                                                 \

                                                                                         \
                                                                                         \

-    ~cppstem ()                                                                         \
+    ~cppstem () throw ()                                                             \

     {                                                                                   \
       stop ();                                                                          \
     }                                                                                   \
                                                                                         \
     {                                                                                   \
       stop ();                                                                          \
     }                                                                                   \
                                                                                         \

-  private:                                                                              \
+    using base<ev_ ## cstem, cppstem>::set;                                             \

                                                                                         \
                                                                                         \

-    cppstem (const cppstem &o)                                                         \
-    : callback<cppstem> (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<cppstem *>(w))(revents);                                            \
-    }                                                                                   \
+    cppstem & operator =(const cppstem &o);                                             \

                                                                                         \
   public:
 
                                                                                         \
   public:
 


@@ -149,7 +611,7 @@ namespace ev {
   };
 
   EV_BEGIN_WATCHER (io, io)
   };
 
   EV_BEGIN_WATCHER (io, io)

-    void set (int fd, int events)
+    void set (int fd, int events) throw ()

     {
       int active = is_active ();
       if (active) stop ();
     {
       int active = is_active ();
       if (active) stop ();


@@ -157,7 +619,7 @@ namespace ev {
       if (active) start ();
     }
 
       if (active) start ();
     }
 

-    void set (int events)
+    void set (int events) throw ()

     {
       int active = is_active ();
       if (active) stop ();
     {
       int active = is_active ();
       if (active) stop ();


@@ -165,7 +627,7 @@ namespace ev {
       if (active) start ();
     }
 
       if (active) start ();
     }
 

-    void start (int fd, int events)
+    void start (int fd, int events) throw ()

     {
       set (fd, events);
       start ();
     {
       set (fd, events);
       start ();


@@ -173,7 +635,7 @@ namespace ev {
   EV_END_WATCHER (io, io)
 
   EV_BEGIN_WATCHER (timer, timer)
   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.) throw ()

     {
       int active = is_active ();
       if (active) stop ();
     {
       int active = is_active ();
       if (active) stop ();


@@ -181,21 +643,21 @@ namespace ev {
       if (active) start ();
     }
 
       if (active) start ();
     }
 

-    void start (ev_tstamp after, ev_tstamp repeat = 0.)
+    void start (ev_tstamp after, ev_tstamp repeat = 0.) throw ()

     {
       set (after, repeat);
       start ();
     }
 
     {
       set (after, repeat);
       start ();
     }
 

-    void again ()
+    void again () throw ()

     {
       ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
     }
   EV_END_WATCHER (timer, timer)
 
     {
       ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
     }
   EV_END_WATCHER (timer, timer)
 

-  #if EV_PERIODICS
+  #if EV_PERIODIC_ENABLE

   EV_BEGIN_WATCHER (periodic, periodic)
   EV_BEGIN_WATCHER (periodic, periodic)

-    void set (ev_tstamp at, ev_tstamp interval = 0.)
+    void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()

     {
       int active = is_active ();
       if (active) stop ();
     {
       int active = is_active ();
       if (active) stop ();


@@ -203,33 +665,21 @@ namespace ev {
       if (active) start ();
     }
 
       if (active) start ();
     }
 

-    void start (ev_tstamp at, ev_tstamp interval = 0.)
+    void start (ev_tstamp at, ev_tstamp interval = 0.) throw ()

     {
       set (at, interval);
       start ();
     }
 
     {
       set (at, interval);
       start ();
     }
 

-    void again ()
+    void again () throw ()

     {
       ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
     }
   EV_END_WATCHER (periodic, periodic)
   #endif
 
     {
       ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
     }
   EV_END_WATCHER (periodic, periodic)
   #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)
-

   EV_BEGIN_WATCHER (sig, signal)
   EV_BEGIN_WATCHER (sig, signal)

-    void set (int signum)
+    void set (int signum) throw ()

     {
       int active = is_active ();
       if (active) stop ();
     {
       int active = is_active ();
       if (active) stop ();


@@ -237,7 +687,7 @@ namespace ev {
       if (active) start ();
     }
 
       if (active) start ();
     }
 

-    void start (int signum)
+    void start (int signum) throw ()

     {
       set (signum);
       start ();
     {
       set (signum);
       start ();


@@ -245,7 +695,7 @@ namespace ev {
   EV_END_WATCHER (sig, signal)
 
   EV_BEGIN_WATCHER (child, child)
   EV_END_WATCHER (sig, signal)
 
   EV_BEGIN_WATCHER (child, child)

-    void set (int pid)
+    void set (int pid) throw ()

     {
       int active = is_active ();
       if (active) stop ();
     {
       int active = is_active ();
       if (active) stop ();


@@ -253,27 +703,55 @@ namespace ev {
       if (active) start ();
     }
 
       if (active) start ();
     }
 

-    void start (int pid)
+    void start (int pid) throw ()

     {
       set (pid);
       start ();
     }
   EV_END_WATCHER (child, child)
 
     {
       set (pid);
       start ();
     }
   EV_END_WATCHER (child, child)
 

-  #if EV_MULTIPLICITY
-
-  EV_BEGIN_WATCHER (embed, embed)
-    void set (struct ev_loop *loop)
+  #if EV_STAT_ENABLE
+  EV_BEGIN_WATCHER (stat, stat)
+    void set (const char *path, ev_tstamp interval = 0.) throw ()

     {
       int active = is_active ();
       if (active) stop ();
     {
       int active = is_active ();
       if (active) stop ();

-      ev_embed_set (static_cast<ev_embed *>(this), loop);
+      ev_stat_set (static_cast<ev_stat *>(this), path, interval);

       if (active) start ();
     }
 
       if (active) start ();
     }
 

-    void start (struct ev_loop *embedded_loop)
+    void start (const char *path, ev_tstamp interval = 0.) throw ()
+    {
+      stop ();
+      set (path, interval);
+      start ();
+    }
+
+    void update () throw ()

     {
     {

-      set (embedded_loop);
+      ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
+    }
+  EV_END_WATCHER (stat, stat)
+  #endif
+
+  EV_BEGIN_WATCHER (idle, idle)
+    void set () throw () { }
+  EV_END_WATCHER (idle, idle)
+
+  EV_BEGIN_WATCHER (prepare, prepare)
+    void set () throw () { }
+  EV_END_WATCHER (prepare, prepare)
+
+  EV_BEGIN_WATCHER (check, check)
+    void set () throw () { }
+  EV_END_WATCHER (check, check)
+
+  #if EV_EMBED_ENABLE
+  EV_BEGIN_WATCHER (embed, embed)
+    void start (struct ev_loop *embedded_loop) throw ()
+    {
+      stop ();
+      ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);

       start ();
     }
 
       start ();
     }
 


@@ -282,13 +760,23 @@ namespace ev {
       ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
     }
   EV_END_WATCHER (embed, embed)
       ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
     }
   EV_END_WATCHER (embed, embed)

+  #endif

 
 

+  #if EV_FORK_ENABLE
+  EV_BEGIN_WATCHER (fork, fork)
+    void set () throw () { }
+  EV_END_WATCHER (fork, fork)

   #endif
 
   #endif
 

+  #undef EV_PX
+  #undef EV_PX_

   #undef EV_CONSTRUCT
   #undef EV_BEGIN_WATCHER
   #undef EV_END_WATCHER
   #undef EV_CONSTRUCT
   #undef EV_BEGIN_WATCHER
   #undef EV_END_WATCHER

+

 }
 
 }
 

+#undef EV_THROW
+

 #endif
 
 #endif