src/iom.h

   1 /*
   2     iom.h -- generic I/O multiplexer
   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. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  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 #ifndef IOM_SIG
  44 # define IOM_SIG 0
  45 #endif
  46
  47 typedef double tstamp;
  48 extern tstamp NOW;
  49
  50 struct watcher;
  51 #if IOM_IO
  52 struct io_watcher;
  53 #endif
  54 #if IOM_TIME
  55 struct time_watcher;
  56 #endif
  57 #if IOM_CHECK
  58 struct check_watcher;
  59 #endif
  60 #if IOM_IDLE
  61 struct idle_watcher;
  62 #endif
  63 #if IOM_SIG
  64 struct sig_watcher;
  65 #endif
  66
  67 template<class watcher>
  68 struct io_manager_vec : vector<watcher *> {
  69   void erase_unordered (unsigned int pos)
  70   {
  71     watcher *w = (*this)[this->size () - 1];
  72     this->pop_back ();
  73
  74     if (!this->empty ())
  75       if (((*this)[pos] = w)) // '=' is correct!
  76         w->active = pos + 1;
  77   }
  78 };
  79
  80 // only used as a namespace, and for initialisation purposes
  81 class io_manager {
  82   template<class watcher>
  83   static void reg (watcher &w, io_manager_vec<watcher> &queue);
  84
  85   template<class watcher>
  86   static void unreg (watcher &w, io_manager_vec<watcher> &queue);
  87
  88 public:
  89 #if IOM_TIME
  90   // fetch time only
  91   static tstamp now ();
  92
  93   // set NOW
  94   static void set_now ();
  95 #endif
  96
  97   // register a watcher
  98 #if IOM_IO
  99   static void reg (io_watcher    &w); static void unreg (io_watcher    &w);
 100 #endif
 101 #if IOM_TIME
 102   static void reg (time_watcher  &w); static void unreg (time_watcher  &w);
 103 #endif
 104 #if IOM_CHECK
 105   static void reg (check_watcher &w); static void unreg (check_watcher &w);
 106 #endif
 107 #if IOM_IDLE
 108   static void reg (idle_watcher  &w); static void unreg (idle_watcher  &w);
 109 #endif
 110 #if IOM_SIG
 111   static void reg (sig_watcher   &w); static void unreg (sig_watcher   &w);
 112 #endif
 113
 114   static void loop ();
 115 };
 116
 117 struct watcher {
 118   int active; /* 0 == inactive, else index into respective vector */
 119
 120   watcher () : active (0) { }
 121 };
 122
 123 #if IOM_IO
 124 enum { EVENT_READ = 1, EVENT_WRITE = 2 };
 125
 126 struct io_watcher : watcher, callback2<void, io_watcher &, short> {
 127   int fd;
 128   short events;
 129
 130   void set (int fd_, short events_) { fd = fd_; events = events_; }
 131
 132   void set (short events_) { set (fd, events_); }
 133   void start () { io_manager::reg (*this); }
 134   void start (int fd_, short events_) { set (fd_, events_); io_manager::reg (*this); }
 135   void stop () { io_manager::unreg (*this); }
 136
 137   template<class O1, class O2>
 138   io_watcher (O1 *object, void (O2::*method) (io_watcher &, short))
 139   : callback2<void, io_watcher &, short> (object,method)
 140   { }
 141   ~io_watcher () { stop (); }
 142 };
 143 #endif
 144
 145 #if IOM_TIME
 146 struct time_watcher : watcher, callback1<void, time_watcher &> {
 147   tstamp at;
 148
 149   void trigger ();
 150
 151   void set (tstamp when) { at = when; }
 152   void operator () () { trigger (); }
 153   void start () { io_manager::reg (*this); }
 154   void start (tstamp when) { set (when); io_manager::reg (*this); }
 155   void stop () { io_manager::unreg (*this); }
 156
 157   template<class O1, class O2>
 158   time_watcher (O1 *object, void (O2::*method) (time_watcher &))
 159   : callback1<void, time_watcher &> (object,method), at (0)
 160   { }
 161   ~time_watcher () { stop (); }
 162 };
 163 #endif
 164
 165 #if IOM_CHECK
 166 // run before checking for new events
 167 struct check_watcher : watcher, callback1<void, check_watcher &> {
 168   void start () { io_manager::reg (*this); }
 169   void stop () { io_manager::unreg (*this); }
 170
 171   template<class O1, class O2>
 172   check_watcher (O1 *object, void (O2::*method) (check_watcher &))
 173   : callback1<void, check_watcher &> (object,method)
 174   { }
 175   ~check_watcher () { stop (); }
 176 };
 177 #endif
 178
 179 #if IOM_IDLE
 180 // run after checking for any i/o, but before waiting
 181 struct idle_watcher : watcher, callback1<void, idle_watcher &> {
 182   void start () { io_manager::reg (*this); }
 183   void stop () { io_manager::unreg (*this); }
 184
 185   template<class O1, class O2>
 186   idle_watcher (O1 *object, void (O2::*method) (idle_watcher &))
 187     : callback1<void, idle_watcher &> (object,method)
 188     { }
 189   ~idle_watcher () { stop (); }
 190 };
 191 #endif
 192
 193 #if IOM_SIG
 194 struct sig_watcher : watcher, callback1<void, sig_watcher &> {
 195   int signum;
 196
 197   void start (int signum);
 198   void stop () { io_manager::unreg (*this); }
 199
 200   template<class O1, class O2>
 201   sig_watcher (O1 *object, void (O2::*method) (sig_watcher &))
 202   : callback1<void, sig_watcher &> (object,method), signum (-1)
 203   { }
 204   ~sig_watcher () { stop (); }
 205 };
 206 #endif
 207
 208 #endif
 209