--- gvpe/src/iom.h	2003/03/21 20:33:36	1.1
+++ gvpe/src/iom.h	2003/10/14 17:24:19	1.13
@@ -21,15 +21,17 @@
 
 #include <vector>
 
-#include <sys/poll.h>
+#include <cassert>
 
+#include "poll.h"
+
+#include "callback.h"
 #include "slog.h"
 
-typedef double timestamp;
+typedef double tstamp;
 
-extern timestamp NOW;
+extern tstamp NOW;
 
-template<class R, class A> class callback;
 struct io_watcher;
 struct time_watcher;
 
@@ -37,10 +39,14 @@
   vector<pollfd> pfs;
   vector<io_watcher *> iow;
   vector<time_watcher *> tw; // actually a heap
+
+  void idle_cb (time_watcher &w); time_watcher *idle;
 public:
 
+  void reschedule_time_watchers ();
+
   // register a watcher
-  void reg (int fd, short events, io_watcher *w);
+  void reg (io_watcher *w);
   void unreg (io_watcher *w);
   void reg (time_watcher *w);
   void unreg (time_watcher *w);
@@ -51,77 +57,83 @@
   ~io_manager ();
 };
 
-extern io_manager iom;
+extern io_manager iom; // a singleton, together with it's construction/destruction problems.
+
+struct io_watcher : callback2<void, io_watcher &, short> {
+  bool registered; // already registered?
+  int fd;
+  short events;
 
-template<class R, class A>
-class callback {
-  struct object { };
-
-  void *obj;
-  R (object::*meth)(A arg);
-
-  // 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);
-      }
-  };
+  io_watcher (O1 *object, void (O2::*method)(io_watcher &, short))
+    : callback2<void, io_watcher &, short>(object,method)
+    , registered(false)
+    { }
 
-  proxy_base *prxy;
+  ~io_watcher ();
 
-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;
-    }
+  void set(int fd_, short events_);
 
-  R call(A arg)
+  void set(short events_)
     {
-      return prxy->call (obj, meth, arg);
+      set (fd, events_);
     }
-};
 
-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)
+  void start (int fd_, short events_)
     {
-      iom.reg (fd, events, this);
+      set (fd_, events_);
+      iom.reg (this);
     }
 
-  ~io_watcher ()
+  void stop ()
     {
       iom.unreg (this);
     }
 };
 
-struct time_watcher : callback<void, timestamp &> {
-  timestamp at;
+#define TSTAMP_CANCEL -1.
 
-  void set (timestamp when);
+struct time_watcher : callback1<void, time_watcher &> {
+  bool registered; // already registered?
+  tstamp at;
 
   template<class O1, class O2>
-  time_watcher (timestamp when, O1 *object, void (O2::*method)(timestamp &))
-    : callback<void, timestamp &>(object,method)
-    , at(when)
+  time_watcher (O1 *object, void (O2::*method)(time_watcher &))
+    : callback1<void, time_watcher &>(object,method)
+    , registered(false)
+    { }
+
+  ~time_watcher ();
+
+  void set (tstamp when);
+  void trigger ();
+
+  void operator ()()
+    {
+      trigger ();
+    }
+
+  void start ()
+    {
+      iom.reg (this);
+    }
+
+  void start (tstamp when)
     {
+      set (when);
       iom.reg (this);
     }
 
-  ~time_watcher ()
+  void stop ()
     {
       iom.unreg (this);
     }
+
+  void reset (tstamp when = TSTAMP_CANCEL)
+    {
+      stop ();
+      at = when;
+    }
 };
 
 #endif