--- gvpe/src/iom.h	2003/03/21 20:33:36	1.1
+++ gvpe/src/iom.h	2006/01/19 20:16:06	1.31
@@ -1,7 +1,10 @@
 /*
-    iom.h -- I/O multiplexor
+    iom.h -- generic I/O multiplexer
+    Copyright (C) 2003-2006 Marc Lehmann <gvpe@schmorp.de>
  
-    This program is free software; you can redistribute it and/or modify
+    This file is part of GVPE.
+
+    GVPE is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
@@ -12,117 +15,212 @@
     GNU General Public License for more details.
  
     You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+    along with gvpe; if not, write to the Free Software
+    Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef VPE_IOM_H__
-#define VPE_IOM_H__
-
-#include <vector>
+#ifndef IOM_H__
+#define IOM_H__
 
-#include <sys/poll.h>
+// required:
+// - a vector template like simplevec or stl's vector
+// - defines for all watcher types required in your app
+// edit iom_conf.h as appropriate.
+#include "iom_conf.h"
+
+#if IOM_CHILD
+# undef IOM_SIG
+# define IOM_SIG 1
+#endif
 
-#include "slog.h"
+#include "callback.h"
 
-typedef double timestamp;
+typedef double tstamp;
+extern tstamp NOW;
 
-extern timestamp NOW;
+// TSTAMP_MAX must still fit into a positive struct timeval
+#define TSTAMP_MAX (double)(1UL<<31)
 
-template<class R, class A> class callback;
+struct watcher;
+#if IOM_IO
 struct io_watcher;
+#endif
+#if IOM_TIME
 struct time_watcher;
+#endif
+#if IOM_CHECK
+struct check_watcher;
+#endif
+#if IOM_IDLE
+struct idle_watcher;
+#endif
+#if IOM_SIG
+struct sig_watcher;
+#endif
+#if IOM_CHILD
+struct child_watcher;
+#endif
+
+template<class watcher>
+struct io_manager_vec : vector<watcher *> {
+  void erase_unordered (unsigned int pos)
+  {
+    watcher *w = (*this)[this->size () - 1];
+    this->pop_back ();
+
+    if (!this->empty ())
+      if (((*this)[pos] = w)) // '=' is correct!
+        w->active = pos + 1;
+  }
+};
 
+// only used as a namespace, and for initialisation purposes
 class io_manager {
-  vector<pollfd> pfs;
-  vector<io_watcher *> iow;
-  vector<time_watcher *> tw; // actually a heap
+  template<class watcher>
+  static void reg (watcher &w, io_manager_vec<watcher> &queue);
+
+  template<class watcher>
+  static void unreg (watcher &w, io_manager_vec<watcher> &queue);
+
 public:
+#if IOM_TIME
+  // fetch time only
+  static tstamp now ();
+
+  // set NOW
+  static void set_now ();
+#endif
 
   // register a watcher
-  void reg (int fd, short events, io_watcher *w);
-  void unreg (io_watcher *w);
-  void reg (time_watcher *w);
-  void unreg (time_watcher *w);
+#if IOM_IO
+  static void reg (io_watcher    &w); static void unreg (io_watcher    &w);
+#endif
+#if IOM_TIME
+  static void reg (time_watcher  &w); static void unreg (time_watcher  &w);
+#endif
+#if IOM_CHECK
+  static void reg (check_watcher &w); static void unreg (check_watcher &w);
+#endif
+#if IOM_IDLE
+  static void reg (idle_watcher  &w); static void unreg (idle_watcher  &w);
+#endif
+#if IOM_SIG
+  static void reg (sig_watcher   &w); static void unreg (sig_watcher   &w);
+#endif
+#if IOM_CHILD
+  static void reg (child_watcher &w); static void unreg (child_watcher &w);
+#endif
   
-  void loop ();
+  static void loop ();
+};
 
-  io_manager ();
-  ~io_manager ();
+struct watcher {
+  int active; /* 0 == inactive, else index into respective vector */
+
+  bool is_active () { return active; }
+
+  watcher () : active (0) { }
 };
 
-extern io_manager iom;
+#if IOM_IO
+enum { EVENT_UNDEF = -1, EVENT_NONE = 0, EVENT_READ = 1, EVENT_WRITE = 2 };
 
-template<class R, class A>
-class callback {
-  struct object { };
+struct io_watcher : watcher, callback2<void, io_watcher &, short> {
+  int fd;
+  short events;
+
+  void set (int fd_, short events_) { fd = fd_; events = events_; }
+
+  void set (short events_) { set (fd, events_); }
+  void start () { io_manager::reg (*this); }
+  void start (int fd_, short events_) { set (fd_, events_); io_manager::reg (*this); }
+  void stop () { io_manager::unreg (*this); }
 
-  void *obj;
-  R (object::*meth)(A arg);
+  template<class O1, class O2>
+  io_watcher (O1 *object, void (O2::*method) (io_watcher &, short))
+  : callback2<void, io_watcher &, short> (object, method)
+  { }
+  ~io_watcher () { stop (); }
+};
+#endif
+
+#if IOM_TIME
+struct time_watcher : watcher, callback1<void, time_watcher &> {
+  tstamp at;
+
+  void trigger ();
+
+  void set (tstamp when) { at = when; }
+  void operator () () { trigger (); }
+  void start () { io_manager::reg (*this); }
+  void start (tstamp when) { set (when); io_manager::reg (*this); }
+  void stop () { io_manager::unreg (*this); }
 
-  // a proxy is a kind of recipe on how to call a specific class method
-  struct proxy_base {
-    virtual R call (void *obj, void (object::*meth)(A), A arg) = 0;
-  };
   template<class O1, class O2>
-  struct proxy : proxy_base {
-    virtual R call (void *obj, void (object::*meth)(A), A arg)
-      {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<void (O2::*)(A)>(meth)))
-          (arg);
-      }
-  };
+  time_watcher (O1 *object, void (O2::*method) (time_watcher &))
+  : callback1<void, time_watcher &> (object, method), at (0)
+  { }
+  ~time_watcher () { stop (); }
+};
+#endif
 
-  proxy_base *prxy;
+#if IOM_CHECK
+// run before checking for new events
+struct check_watcher : watcher, callback1<void, check_watcher &> {
+  void start () { io_manager::reg (*this); }
+  void stop () { io_manager::unreg (*this); }
+
+  template<class O1, class O2>
+  check_watcher (O1 *object, void (O2::*method) (check_watcher &))
+  : callback1<void, check_watcher &> (object, method)
+  { }
+  ~check_watcher () { stop (); }
+};
+#endif
+
+#if IOM_IDLE
+// run after checking for any i/o, but before waiting
+struct idle_watcher : watcher, callback1<void, idle_watcher &> {
+  void start () { io_manager::reg (*this); }
+  void stop () { io_manager::unreg (*this); }
+
+  template<class O1, class O2>
+  idle_watcher (O1 *object, void (O2::*method) (idle_watcher &))
+    : callback1<void, idle_watcher &> (object, method)
+    { }
+  ~idle_watcher () { stop (); }
+};
+#endif
+
+#if IOM_SIG
+struct sig_watcher : watcher, callback1<void, sig_watcher &> {
+  int signum;
+
+  void start (int signum);
+  void stop () { io_manager::unreg (*this); }
+
+  template<class O1, class O2>
+  sig_watcher (O1 *object, void (O2::*method) (sig_watcher &))
+  : callback1<void, sig_watcher &> (object, method), signum (0)
+  { }
+  ~sig_watcher () { stop (); }
+};
+#endif
+
+#if IOM_CHILD
+struct child_watcher : watcher, callback2<void, child_watcher &, int> {
+  int /*pid_t*/ pid;
+
+  void start (int pid) { this->pid = pid; io_manager::reg (*this); }
+  void stop () { io_manager::unreg (*this); }
 
-public:
   template<class O1, class O2>
-  callback (O1 *object, void (O2::*method)(A))
-    {
-      static proxy<O1,O2> p;
-      obj  = reinterpret_cast<void *>(object);
-      meth = reinterpret_cast<void (object::*)(A)>(method);
-      prxy = &p;
-    }
-
-  R call(A arg)
-    {
-      return prxy->call (obj, meth, arg);
-    }
-};
-
-struct io_watcher : callback<void, short> {
-  template<class O1, class O2>
-  io_watcher (int fd, short events, O1 *object, void (O2::*method)(short revents))
-    : callback<void, short>(object,method)
-    {
-      iom.reg (fd, events, this);
-    }
-
-  ~io_watcher ()
-    {
-      iom.unreg (this);
-    }
-};
-
-struct time_watcher : callback<void, timestamp &> {
-  timestamp at;
-
-  void set (timestamp when);
-
-  template<class O1, class O2>
-  time_watcher (timestamp when, O1 *object, void (O2::*method)(timestamp &))
-    : callback<void, timestamp &>(object,method)
-    , at(when)
-    {
-      iom.reg (this);
-    }
-
-  ~time_watcher ()
-    {
-      iom.unreg (this);
-    }
+  child_watcher (O1 *object, void (O2::*method) (child_watcher &, int status))
+  : callback2<void, child_watcher &, int> (object, method), pid (0)
+  { }
+  ~child_watcher () { stop (); }
 };
+#endif
 
 #endif