b77cd62e1368c90702fab074c0419de54afebcb0
[dana/urxvt.git] / 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. 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 #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