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   void erase_unordered (unsigned int pos)
  66   {
  67     watcher *w = (*this)[size () - 1];
  68     pop_back ();
  69
  70     if (size ())
  71       if ((*this)[pos] = w)
  72         w->active = pos + 1;
  73   }
  74 };
  75
  76 class io_manager {
  77 #if IOM_IO
  78   io_manager_vec<io_watcher>    iow;
  79 #endif
  80 #if IOM_CHECK
  81   io_manager_vec<check_watcher> cw;
  82 #endif
  83 #if IOM_TIME
  84   io_manager_vec<time_watcher>  tw;
  85 #endif
  86 #if IOM_IDLE
  87   io_manager_vec<idle_watcher>  iw;
  88 #endif
  89
  90   template<class watcher>
  91   void reg (watcher *w, io_manager_vec<watcher> &queue);
  92
  93   template<class watcher>
  94   void unreg (watcher *w, io_manager_vec<watcher> &queue);
  95
  96 public:
  97   // register a watcher
  98 #if IOM_IO
  99   void reg (io_watcher    *w); void unreg (io_watcher    *w);
 100 #endif
 101 #if IOM_TIME
 102   void reg (time_watcher  *w); void unreg (time_watcher  *w);
 103 #endif
 104 #if IOM_CHECK
 105   void reg (check_watcher *w); void unreg (check_watcher *w);
 106 #endif
 107 #if IOM_IDLE
 108   void reg (idle_watcher  *w); void unreg (idle_watcher  *w);
 109 #endif
 110
 111   void loop ();
 112
 113   io_manager ();
 114   ~io_manager ();
 115 };
 116
 117 extern io_manager iom; // a singleton, together with it's construction/destruction problems.
 118
 119 struct watcher {
 120   int active; /* 0 == inactive, else index into respective vector */
 121
 122   watcher() : active(0) { }
 123 };
 124
 125 #if IOM_IO
 126 enum { EVENT_READ = 1, EVENT_WRITE = 2 };
 127
 128 struct io_watcher : watcher, callback2<void, io_watcher &, short> {
 129   int fd;
 130   short events;
 131
 132   void set (int fd_, short events_) { fd = fd_; events = events_; }
 133
 134   void set (short events_) { set (fd, events_); }
 135   void start () { iom.reg (this); }
 136   void start (int fd_, short events_) { set (fd_, events_); iom.reg (this); }
 137   void stop () { iom.unreg (this); }
 138
 139   template<class O1, class O2>
 140   io_watcher (O1 *object, void (O2::*method)(io_watcher &, short))
 141   : callback2<void, io_watcher &, short>(object,method)
 142   { }
 143   ~io_watcher () { stop (); }
 144 };
 145 #endif
 146
 147 #if IOM_TIME
 148 struct time_watcher : watcher, callback1<void, time_watcher &> {
 149   tstamp at;
 150
 151   void trigger ();
 152
 153   void set (tstamp when) { at = when; }
 154   void operator ()() { trigger (); }
 155   void start () { iom.reg (this); }
 156   void start (tstamp when) { set (when); iom.reg (this); }
 157   void stop () { iom.unreg (this); }
 158
 159   template<class O1, class O2>
 160   time_watcher (O1 *object, void (O2::*method)(time_watcher &))
 161   : callback1<void, time_watcher &>(object,method)
 162   { }
 163   ~time_watcher () { stop (); }
 164 };
 165 #endif
 166
 167 #if IOM_CHECK
 168 // run before checking for new events
 169 struct check_watcher : watcher, callback1<void, check_watcher &> {
 170   void start () { iom.reg (this); }
 171   void stop () { iom.unreg (this); }
 172
 173   template<class O1, class O2>
 174   check_watcher (O1 *object, void (O2::*method)(check_watcher &))
 175   : callback1<void, check_watcher &>(object,method)
 176   { }
 177   ~check_watcher () { stop (); }
 178 };
 179 #endif
 180
 181 #if IOM_IDLE
 182 // run after checking for any i/o, but before waiting
 183 struct idle_watcher : watcher, callback1<void, idle_watcher &> {
 184   void start () { iom.reg (this); }
 185   void stop () { iom.unreg (this); }
 186
 187   template<class O1, class O2>
 188   idle_watcher (O1 *object, void (O2::*method)(idle_watcher &))
 189     : callback1<void, idle_watcher &>(object,method)
 190     { }
 191   ~idle_watcher () { stop (); }
 192 };
 193 #endif
 194
 195 #endif
 196