src/iom.h

   1 /*
   2     iom.h -- generic I/O multiplexor
   3     Copyright (C) 2003, 2004 Marc Lehmann <pcg@goof.com>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19
  20 #ifndef IOM_H__
  21 #define IOM_H__
  22
  23 // required:
  24 // - a vector template like simplevec or stl's vector
  25 // - defines for all watcher types required in your app
  26 // edit iom_conf.h as appropriate.
  27 #include "iom_conf.h"
  28
  29 #include "callback.h"
  30
  31 #ifndef IOM_IO
  32 # define IOM_IO 0
  33 #endif
  34 #ifndef IOM_TIME
  35 # define IOM_TIME 0
  36 #endif
  37 #ifndef IOM_CHECK
  38 # define IOM_CHECK 0
  39 #endif
  40 #ifndef IOM_IDLE
  41 # define IOM_IDLE 0
  42 #endif
  43
  44 typedef double tstamp;
  45 extern tstamp NOW;
  46
  47 struct watcher;
  48 #if IOM_IO
  49 struct io_watcher;
  50 #endif
  51 #if IOM_TIME
  52 struct time_watcher;
  53 #endif
  54 #if IOM_CHECK
  55 struct check_watcher;
  56 #endif
  57 #if IOM_IDLE
  58 struct idle_watcher;
  59 #endif
  60
  61 template<class watcher>
  62 struct io_manager_vec : protected vector<watcher *> {
  63   friend class io_manager;
  64 protected:
  65 #if IOM_CHECK
  66   bool activity;
  67 #endif
  68
  69   void erase_unordered (unsigned int pos)
  70   {
  71     watcher *w = (*this)[size () - 1];
  72     pop_back ();
  73
  74     if (size ())
  75       if ((*this)[pos] = w)
  76         w->active = pos + 1;
  77   }
  78 };
  79
  80 class io_manager {
  81 #if IOM_IO
  82   io_manager_vec<io_watcher>    iow;
  83 #endif
  84 #if IOM_CHECK
  85   io_manager_vec<check_watcher> cw;
  86 #endif
  87 #if IOM_TIME
  88   io_manager_vec<time_watcher>  tw;
  89 #endif
  90 #if IOM_IDLE
  91   io_manager_vec<idle_watcher>  iw;
  92 #endif
  93
  94   template<class watcher>
  95   void reg (watcher *w, io_manager_vec<watcher> &queue);
  96
  97   template<class watcher>
  98   void unreg (watcher *w, io_manager_vec<watcher> &queue);
  99
 100 public:
 101   // register a watcher
 102 #if IOM_IO
 103   void reg (io_watcher    *w); void unreg (io_watcher    *w);
 104 #endif
 105 #if IOM_TIME
 106   void reg (time_watcher  *w); void unreg (time_watcher  *w);
 107 #endif
 108 #if IOM_CHECK
 109   void reg (check_watcher *w); void unreg (check_watcher *w);
 110 #endif
 111 #if IOM_IDLE
 112   void reg (idle_watcher  *w); void unreg (idle_watcher  *w);
 113 #endif
 114
 115   void loop ();
 116
 117   io_manager ();
 118   ~io_manager ();
 119 };
 120
 121 extern io_manager iom; // a singleton, together with it's construction/destruction problems.
 122
 123 struct watcher {
 124   int active; /* 0 == inactive, else index into respective vector */
 125
 126   watcher() : active(0) { }
 127 };
 128
 129 #if IOM_IO
 130 enum { EVENT_READ = 1, EVENT_WRITE = 2 };
 131
 132 struct io_watcher : watcher, callback2<void, io_watcher &, short> {
 133   int fd;
 134   short events;
 135
 136   void set (int fd_, short events_) { fd = fd_; events = events_; }
 137
 138   void set (short events_) { set (fd, events_); }
 139   void start () { iom.reg (this); }
 140   void start (int fd_, short events_) { set (fd_, events_); iom.reg (this); }
 141   void stop () { iom.unreg (this); }
 142
 143   template<class O1, class O2>
 144   io_watcher (O1 *object, void (O2::*method)(io_watcher &, short))
 145   : callback2<void, io_watcher &, short>(object,method)
 146   { }
 147   ~io_watcher () { stop (); }
 148 };
 149 #endif
 150
 151 #if IOM_TIME
 152 struct time_watcher : watcher, callback1<void, time_watcher &> {
 153   tstamp at;
 154
 155   void trigger ();
 156
 157   void set (tstamp when) { at = when; }
 158   void operator ()() { trigger (); }
 159   void start () { iom.reg (this); }
 160   void start (tstamp when) { set (when); iom.reg (this); }
 161   void stop () { iom.unreg (this); }
 162
 163   template<class O1, class O2>
 164   time_watcher (O1 *object, void (O2::*method)(time_watcher &))
 165   : callback1<void, time_watcher &>(object,method), at(0)
 166   { }
 167   ~time_watcher () { stop (); }
 168 };
 169 #endif
 170
 171 #if IOM_CHECK
 172 // run before checking for new events
 173 struct check_watcher : watcher, callback1<void, check_watcher &> {
 174   void start () { iom.reg (this); }
 175   void stop () { iom.unreg (this); }
 176
 177   template<class O1, class O2>
 178   check_watcher (O1 *object, void (O2::*method)(check_watcher &))
 179   : callback1<void, check_watcher &>(object,method)
 180   { }
 181   ~check_watcher () { stop (); }
 182 };
 183 #endif
 184
 185 #if IOM_IDLE
 186 // run after checking for any i/o, but before waiting
 187 struct idle_watcher : watcher, callback1<void, idle_watcher &> {
 188   void start () { iom.reg (this); }
 189   void stop () { iom.unreg (this); }
 190
 191   template<class O1, class O2>
 192   idle_watcher (O1 *object, void (O2::*method)(idle_watcher &))
 193     : callback1<void, idle_watcher &>(object,method)
 194     { }
 195   ~idle_watcher () { stop (); }
 196 };
 197 #endif
 198
 199 #endif
 200