ebb 0.2.1 → 0.3.0

data/lib/ebb.rb

@@ -0,0 +1,311 @@
+# Ruby Binding to the Ebb Web Server
+# Copyright (c) 2008 Ry Dahl. This software is released under the MIT License.
+# See README file for details.
+
+require File.dirname(__FILE__) + '/ebb/version'
+
+module Ebb
+  autoload :FFI, File.dirname(__FILE__) + '/../ext/ebb_ffi'
+  
+  def self.running?
+    FFI::server_open?
+  end
+  
+  def self.stop_server()
+    @running = false
+  end
+  
+  def self.start_server(app, options={})
+    if options.has_key?(:fileno)
+      fd = options[:fileno].to_i
+      FFI::server_listen_on_fd(fd)
+      log.puts "Ebb is listening on file descriptor #{fd}"
+# missing until libebb adds UNIX socket support
+#    elsif options.has_key?(:unix_socket)
+#      socketfile = options[:unix_socket]
+#      FFI::server_listen_on_unix_socket(socketfile)
+#      log.puts "Ebb is listening on unix socket #{socketfile}"
+    else
+      port = (options[:Port] || options[:port] || 4001).to_i
+      FFI::server_listen_on_port(port)
+      log.puts "Ebb is listening at http://0.0.0.0:#{port}/"
+    end
+
+    if options.has_key?(:ssl_cert) and options.has_key?(:ssl_key)
+      unless FFI.respond_to?(:server_set_secure)
+        log.puts "ebb compiled without ssl support. get gnutls" 
+      else
+        cert_file = options[:ssl_cert]
+        key_file = options[:ssl_key]
+        if FileTest.readable?(cert_file) and FileTest.readable?(cert_file)
+          FFI::server_set_secure(cert_file, key_file);
+        else 
+          log.puts "error opening certificate or key file"
+        end
+      end
+    end
+
+    log.puts "Ebb PID #{Process.pid}"
+    
+    @running = true
+    Connection.reset_responses
+    trap('INT')  { stop_server }
+
+    while @running
+      FFI::server_process_connections()
+      while request = FFI::server_waiting_requests.shift
+        if app.respond_to?(:deferred?) and !app.deferred?(request.env)
+          process(app, request)
+        else
+          Thread.new(request) { |req| process(app, req) }
+        end
+      end
+    end
+    FFI::server_unlisten()
+  end
+  
+  def self.process(app, req)
+    res = req.response
+    req.connection.responses << res
+
+    # p req.env
+    status = headers = body = nil
+    catch(:async) do 
+      status, headers, body = app.call(req.env)
+    end
+
+    # James Tucker's async response scheme
+    # check out
+    # http://github.com/raggi/thin/tree/async_for_rack/example/async_app.ru
+    res.call(status, headers, body) if status != 0 
+    # if status == 0 then the application promises to call
+    # env['async.callback'].call(status, headers, body) 
+    # later on...
+
+  end
+
+  class Connection
+    def self.reset_responses
+      @@responses = {} # used for memory management :|
+    end
+
+    def self.responses
+      @@responses
+    end
+
+    def responses
+      @@responses[self]
+    end
+
+    # called from c
+    def append_request(req)
+      @requests.push req
+    end
+
+    def on_open
+      @requests = []
+      @@responses[self] = []
+    end
+
+    def on_close
+      # garbage collection ! 
+      @requests.each { |req| req.connection = nil }
+      responses.each { |res| res.connection = nil }
+      @@responses.delete(self)
+    end
+
+    def writing?
+      ! @being_written.nil?
+    end
+
+    def write
+      return if writing?
+      return unless res = responses.first
+      return if res.output.empty?
+      # NOTE: connection_write does not buffer!
+      chunk = res.output.shift
+      @being_written = chunk # need to store this so ruby doesn't gc it
+      FFI::connection_write(self, chunk) 
+    end
+
+    # called after FFI::connection_write if complete
+    def on_writable
+      @being_written = nil
+      return unless res = responses.first
+      if res.finished?
+        responses.shift
+        if res.last 
+          FFI::connection_schedule_close(self) 
+          return
+        end
+      end 
+      write
+    end
+  end
+    
+  class Response
+    attr_reader :output
+    attr_accessor :last, :connection
+    def initialize(connection, last)
+      @connection = connection
+      @last = last
+      @output = []
+      @finished = false
+      @chunked = false 
+    end
+
+    def call(status, headers, body)
+      @head = "HTTP/1.1 #{status} #{HTTP_STATUS_CODES[status.to_i]}\r\n"
+      headers.each { |field, value| @head << "#{field}: #{value}\r\n" }
+      @head << "\r\n"
+
+      # XXX i would prefer to do
+      # @chunked = true unless body.respond_to?(:length)
+      @chunked = true if headers["Transfer-Encoding"] == "chunked"
+      # I also don't like this
+      @last = true if headers["Connection"] == "close"
+
+      # Note: not setting Content-Length. do it yourself.
+      
+      body.each do |chunk| 
+        if @head.nil?
+          write(chunk) 
+        else
+          write(@head + chunk) 
+          @head = nil
+        end
+        @connection.write
+      end
+
+      body.on_error { close } if body.respond_to?(:on_error)
+
+      if body.respond_to?(:on_eof)
+        body.on_eof { finish }
+      else
+        finish
+      end
+
+      # deferred requests SHOULD NOT respond to close
+      body.close if body.respond_to?(:close)
+    end
+
+    def finished?
+      @output.empty? and @finished
+    end
+
+    def finish
+      @finished = true 
+      if @chunked
+        write("") 
+        @connection.write
+      end
+    end
+    
+    def write(chunk)
+      encoded = @chunked ? "#{chunk.length.to_s(16)}\r\n#{chunk}\r\n" : chunk
+      @output << encoded
+    end
+
+    HTTP_STATUS_CODES = {
+      100  => 'Continue', 
+      101  => 'Switching Protocols', 
+      200  => 'OK', 
+      201  => 'Created', 
+      202  => 'Accepted', 
+      203  => 'Non-Authoritative Information', 
+      204  => 'No Content', 
+      205  => 'Reset Content', 
+      206  => 'Partial Content', 
+      300  => 'Multiple Choices', 
+      301  => 'Moved Permanently', 
+      302  => 'Moved Temporarily', 
+      303  => 'See Other', 
+      304  => 'Not Modified', 
+      305  => 'Use Proxy', 
+      400  => 'Bad Request', 
+      401  => 'Unauthorized', 
+      402  => 'Payment Required', 
+      403  => 'Forbidden', 
+      404  => 'Not Found', 
+      405  => 'Method Not Allowed', 
+      406  => 'Not Acceptable', 
+      407  => 'Proxy Authentication Required', 
+      408  => 'Request Time-out', 
+      409  => 'Conflict', 
+      410  => 'Gone', 
+      411  => 'Length Required', 
+      412  => 'Precondition Failed', 
+      413  => 'Request Entity Too Large', 
+      414  => 'Request-URI Too Large', 
+      415  => 'Unsupported Media Type', 
+      500  => 'Internal Server Error', 
+      501  => 'Not Implemented', 
+      502  => 'Bad Gateway', 
+      503  => 'Service Unavailable', 
+      504  => 'Gateway Time-out', 
+      505  => 'HTTP Version not supported'
+    }.freeze
+  end
+  
+  @@log = STDOUT
+
+  def self.log=(output)
+    @@log = output
+  end
+
+  def self.log
+    @@log
+  end
+  
+  class Request
+    attr_accessor :connection
+    
+    def env
+      @env ||= begin
+        @env_ffi.update(
+          'SERVER_NAME' => '0.0.0.0',
+          'SCRIPT_NAME' => '',
+          'SERVER_SOFTWARE' => Ebb::VERSION_STRING,
+          'SERVER_PROTOCOL' => 'HTTP/1.1',
+          'rack.version' => [0, 1],
+          'rack.errors' => STDERR,
+          'rack.url_scheme' => 'http',
+          'rack.multiprocess' => false,
+          'rack.run_once' => false,
+
+          'rack.input' => self,
+          'async.callback' => response,
+          'CONTENT_LENGTH' => @env_ffi.delete('HTTP_CONTENT_LENGTH'),
+          'CONTENT_TYPE' => @env_ffi.delete('HTTP_CONTENT_TYPE')
+        )
+      end
+    end
+
+    def keep_alive?
+      FFI::request_should_keep_alive?(self)
+    end
+
+    def response
+      @response ||= begin
+        last = !keep_alive? # this is the last response if the request isnt keep-alive
+        Response.new(@connection, last)
+      end
+    end
+
+    def read(want = 1024)
+      FFI::request_read(self, want)
+    end
+  end
+end
+
+
+module Rack
+  module Handler
+    module Ebb
+      def self.run(app, options={})
+        ::Ebb.start_server(app, options)
+      end
+    end
+  end
+end
+

data/lib/ebb/version.rb

@@ -0,0 +1,4 @@
+module Ebb
+  VERSION = "0.3.0"
+  VERSION_STRING = "Ebb #{VERSION}"
+end

data/libev/ev++.h

@@ -0,0 +1,803 @@
+/*
+ * libev simple C++ wrapper classes
+ *
+ * Copyright (c) 2007,2008 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__
+
+#ifdef EV_H
+# include EV_H
+#else
+# include "ev.h"
+#endif
+
+#ifndef EV_USE_STDEXCEPT
+# define EV_USE_STDEXCEPT 1
+#endif
+
+#if EV_USE_STDEXCEPT
+# include <stdexcept>
+#endif
+
+namespace ev {
+
+  typedef ev_tstamp tstamp;
+
+  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,
+    ASYNC    = EV_ASYNC,
+    EMBED    = EV_EMBED,
+    ERROR    = EV_ERROR,
+  };
+
+  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 ()
+#if EV_MULTIPLICITY
+    : EV_AX (EV_A)
+#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
+
+    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
+  {
+
+    dynamic_loop (unsigned int flags = AUTO) throw (bad_loop)
+    : loop_ref (ev_loop_new (flags))
+    {
+      if (!EV_AX)
+        throw bad_loop ();
+    }
+
+    ~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
+    {
+      if (
+#if EV_MULTIPLICITY
+          !EV_AX
+#else
+          !ev_default_loop (flags)
+#endif
+      )
+        throw bad_loop ();
+    }
+
+    ~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
+  }
+
+#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<class ev_watcher, class watcher>
+  struct base : ev_watcher
+  {
+    #if EV_MULTIPLICITY
+      EV_PX;
+
+      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);
+    }
+
+    // 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)	                                        \
+                                                                                        \
+  struct cppstem : base<ev_ ## cstem, cppstem>                                          \
+  {                                                                                     \
+    void start () throw ()                                                              \
+    {                                                                                   \
+      ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
+    }                                                                                   \
+                                                                                        \
+    void stop () throw ()                                                               \
+    {                                                                                   \
+      ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
+    }                                                                                   \
+                                                                                        \
+    cppstem EV_CONSTRUCT(cppstem,cstem)                                                 \
+                                                                                        \
+    ~cppstem () throw ()                                                                \
+    {                                                                                   \
+      stop ();                                                                          \
+    }                                                                                   \
+                                                                                        \
+    using base<ev_ ## cstem, cppstem>::set;                                             \
+                                                                                        \
+  private:                                                                              \
+                                                                                        \
+    cppstem (const cppstem &o);                                                         \
+                                                                                        \
+    cppstem &operator =(const cppstem &o);                                              \
+                                                                                        \
+  public:
+
+  #define EV_END_WATCHER(cppstem,cstem)	                                                \
+  };
+
+  EV_BEGIN_WATCHER (io, io)
+    void set (int fd, int events) throw ()
+    {
+      int active = is_active ();
+      if (active) stop ();
+      ev_io_set (static_cast<ev_io *>(this), fd, events);
+      if (active) start ();
+    }
+
+    void set (int events) throw ()
+    {
+      int active = is_active ();
+      if (active) stop ();
+      ev_io_set (static_cast<ev_io *>(this), fd, events);
+      if (active) start ();
+    }
+
+    void start (int fd, int events) throw ()
+    {
+      set (fd, events);
+      start ();
+    }
+  EV_END_WATCHER (io, io)
+
+  EV_BEGIN_WATCHER (timer, timer)
+    void set (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
+    {
+      int active = is_active ();
+      if (active) stop ();
+      ev_timer_set (static_cast<ev_timer *>(this), after, repeat);
+      if (active) start ();
+    }
+
+    void start (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
+    {
+      set (after, repeat);
+      start ();
+    }
+
+    void again () throw ()
+    {
+      ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
+    }
+  EV_END_WATCHER (timer, timer)
+
+  #if EV_PERIODIC_ENABLE
+  EV_BEGIN_WATCHER (periodic, periodic)
+    void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()
+    {
+      int active = is_active ();
+      if (active) stop ();
+      ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);
+      if (active) start ();
+    }
+
+    void start (ev_tstamp at, ev_tstamp interval = 0.) throw ()
+    {
+      set (at, interval);
+      start ();
+    }
+
+    void again () throw ()
+    {
+      ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
+    }
+  EV_END_WATCHER (periodic, periodic)
+  #endif
+
+  EV_BEGIN_WATCHER (sig, signal)
+    void set (int signum) throw ()
+    {
+      int active = is_active ();
+      if (active) stop ();
+      ev_signal_set (static_cast<ev_signal *>(this), signum);
+      if (active) start ();
+    }
+
+    void start (int signum) throw ()
+    {
+      set (signum);
+      start ();
+    }
+  EV_END_WATCHER (sig, signal)
+
+  EV_BEGIN_WATCHER (child, child)
+    void set (int pid, int trace = 0) throw ()
+    {
+      int active = is_active ();
+      if (active) stop ();
+      ev_child_set (static_cast<ev_child *>(this), pid, trace);
+      if (active) start ();
+    }
+
+    void start (int pid, int trace = 0) throw ()
+    {
+      set (pid, trace);
+      start ();
+    }
+  EV_END_WATCHER (child, child)
+
+  #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 ();
+      ev_stat_set (static_cast<ev_stat *>(this), path, interval);
+      if (active) start ();
+    }
+
+    void start (const char *path, ev_tstamp interval = 0.) throw ()
+    {
+      stop ();
+      set (path, interval);
+      start ();
+    }
+
+    void update () throw ()
+    {
+      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 set (struct ev_loop *embedded_loop) throw ()
+    {
+      int active = is_active ();
+      if (active) stop ();
+      ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
+      if (active) start ();
+    }
+
+    void start (struct ev_loop *embedded_loop) throw ()
+    {
+      set (embedded_loop);
+      start ();
+    }
+
+    void sweep ()
+    {
+      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
+
+  #if EV_ASYNC_ENABLE
+  EV_BEGIN_WATCHER (async, async)
+    void set () throw () { }
+
+    void send () throw ()
+    {
+      ev_async_send (EV_A_ static_cast<ev_async *>(this));
+    }
+
+    bool async_pending () throw ()
+    {
+      return ev_async_pending (static_cast<ev_async *>(this));
+    }
+  EV_END_WATCHER (async, async)
+  #endif
+
+  #undef EV_PX
+  #undef EV_PX_
+  #undef EV_CONSTRUCT
+  #undef EV_BEGIN_WATCHER
+  #undef EV_END_WATCHER
+}
+
+#endif
+