8b9beeebce12cf4d3dd7678dfe058353516750a4
[dana/urxvt.git] / src / callback.h
1 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
2 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
3 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
4 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
5 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
6 // THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
7
8 /*
9     callback.h -- C++ callback mechanism
10     Copyright (C) 2003 Marc Lehmann <pcg@goof.com>
11  
12     This program is free software; you can redistribute it and/or modify
13     it under the terms of the GNU General Public License as published by
14     the Free Software Foundation; either version 2 of the License, or
15     (at your option) any later version.
16  
17     This program is distributed in the hope that it will be useful,
18     but WITHOUT ANY WARRANTY; without even the implied warranty of
19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20     GNU General Public License for more details.
21  
22     You should have received a copy of the GNU General Public License
23     along with this program; if not, write to the Free Software
24     Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25 */
26
27 #ifndef CALLBACK_H__
28 #define CALLBACK_H__
29
30 template<class R>
31 class callback0 {
32   struct object { };
33
34   void *obj;
35   R (object::*meth) ();
36
37   /* a proxy is a kind of recipe on how to call a specific class method */
38   struct proxy_base {
39     virtual R call (void *obj, R (object::*meth) ()) = 0;
40   };
41   template<class O1, class O2>
42   struct proxy : proxy_base {
43     virtual R call (void *obj, R (object::*meth) ())
44       {
45         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) ()> (meth)))
46           ();
47       }
48   };
49
50   proxy_base *prxy;
51
52 public:
53   template<class O1, class O2>
54   callback0 (O1 *object, R (O2::*method) ())
55     {
56       static proxy<O1,O2> p;
57       obj  = reinterpret_cast<void *> (object);
58       meth = reinterpret_cast<R (object::*) ()> (method);
59       prxy = &p;
60     }
61
62   R call () const
63     {
64       return prxy->call (obj, meth);
65     }
66
67   R operator () () const
68     {
69       return call ();
70     }
71 };
72
73 template<class R, class A1>
74 class callback1 {
75   struct object { };
76
77   void *obj;
78   R (object::*meth) (A1);
79
80   /* a proxy is a kind of recipe on how to call a specific class method */
81   struct proxy_base {
82     virtual R call (void *obj, R (object::*meth) (A1), A1 a1) = 0;
83   };
84   template<class O1, class O2>
85   struct proxy : proxy_base {
86     virtual R call (void *obj, R (object::*meth) (A1), A1 a1)
87       {
88         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1)> (meth)))
89           (a1);
90       }
91   };
92
93   proxy_base *prxy;
94
95 public:
96   template<class O1, class O2>
97   callback1 (O1 *object, R (O2::*method) (A1))
98     {
99       static proxy<O1,O2> p;
100       obj  = reinterpret_cast<void *> (object);
101       meth = reinterpret_cast<R (object::*) (A1)> (method);
102       prxy = &p;
103     }
104
105   R call (A1 a1) const
106     {
107       return prxy->call (obj, meth, a1);
108     }
109
110   R operator () (A1 a1) const
111     {
112       return call (a1);
113     }
114 };
115
116 template<class R, class A1, class A2>
117 class callback2 {
118   struct object { };
119
120   void *obj;
121   R (object::*meth) (A1, A2);
122
123   /* a proxy is a kind of recipe on how to call a specific class method */
124   struct proxy_base {
125     virtual R call (void *obj, R (object::*meth) (A1, A2), A1 a1, A2 a2) = 0;
126   };
127   template<class O1, class O2>
128   struct proxy : proxy_base {
129     virtual R call (void *obj, R (object::*meth) (A1, A2), A1 a1, A2 a2)
130       {
131         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2)> (meth)))
132           (a1, a2);
133       }
134   };
135
136   proxy_base *prxy;
137
138 public:
139   template<class O1, class O2>
140   callback2 (O1 *object, R (O2::*method) (A1, A2))
141     {
142       static proxy<O1,O2> p;
143       obj  = reinterpret_cast<void *> (object);
144       meth = reinterpret_cast<R (object::*) (A1, A2)> (method);
145       prxy = &p;
146     }
147
148   R call (A1 a1, A2 a2) const
149     {
150       return prxy->call (obj, meth, a1, a2);
151     }
152
153   R operator () (A1 a1, A2 a2) const
154     {
155       return call (a1, a2);
156     }
157 };
158
159 template<class R, class A1, class A2, class A3>
160 class callback3 {
161   struct object { };
162
163   void *obj;
164   R (object::*meth) (A1, A2, A3);
165
166   /* a proxy is a kind of recipe on how to call a specific class method */
167   struct proxy_base {
168     virtual R call (void *obj, R (object::*meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
169   };
170   template<class O1, class O2>
171   struct proxy : proxy_base {
172     virtual R call (void *obj, R (object::*meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3)
173       {
174         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3)> (meth)))
175           (a1, a2, a3);
176       }
177   };
178
179   proxy_base *prxy;
180
181 public:
182   template<class O1, class O2>
183   callback3 (O1 *object, R (O2::*method) (A1, A2, A3))
184     {
185       static proxy<O1,O2> p;
186       obj  = reinterpret_cast<void *> (object);
187       meth = reinterpret_cast<R (object::*) (A1, A2, A3)> (method);
188       prxy = &p;
189     }
190
191   R call (A1 a1, A2 a2, A3 a3) const
192     {
193       return prxy->call (obj, meth, a1, a2, a3);
194     }
195
196   R operator () (A1 a1, A2 a2, A3 a3) const
197     {
198       return call (a1, a2, a3);
199     }
200 };
201
202 template<class R, class A1, class A2, class A3, class A4>
203 class callback4 {
204   struct object { };
205
206   void *obj;
207   R (object::*meth) (A1, A2, A3, A4);
208
209   /* a proxy is a kind of recipe on how to call a specific class method */
210   struct proxy_base {
211     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
212   };
213   template<class O1, class O2>
214   struct proxy : proxy_base {
215     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
216       {
217         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4)> (meth)))
218           (a1, a2, a3, a4);
219       }
220   };
221
222   proxy_base *prxy;
223
224 public:
225   template<class O1, class O2>
226   callback4 (O1 *object, R (O2::*method) (A1, A2, A3, A4))
227     {
228       static proxy<O1,O2> p;
229       obj  = reinterpret_cast<void *> (object);
230       meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4)> (method);
231       prxy = &p;
232     }
233
234   R call (A1 a1, A2 a2, A3 a3, A4 a4) const
235     {
236       return prxy->call (obj, meth, a1, a2, a3, a4);
237     }
238
239   R operator () (A1 a1, A2 a2, A3 a3, A4 a4) const
240     {
241       return call (a1, a2, a3, a4);
242     }
243 };
244
245 template<class R, class A1, class A2, class A3, class A4, class A5>
246 class callback5 {
247   struct object { };
248
249   void *obj;
250   R (object::*meth) (A1, A2, A3, A4, A5);
251
252   /* a proxy is a kind of recipe on how to call a specific class method */
253   struct proxy_base {
254     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
255   };
256   template<class O1, class O2>
257   struct proxy : proxy_base {
258     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
259       {
260         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5)> (meth)))
261           (a1, a2, a3, a4, a5);
262       }
263   };
264
265   proxy_base *prxy;
266
267 public:
268   template<class O1, class O2>
269   callback5 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5))
270     {
271       static proxy<O1,O2> p;
272       obj  = reinterpret_cast<void *> (object);
273       meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5)> (method);
274       prxy = &p;
275     }
276
277   R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
278     {
279       return prxy->call (obj, meth, a1, a2, a3, a4, a5);
280     }
281
282   R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
283     {
284       return call (a1, a2, a3, a4, a5);
285     }
286 };
287
288 template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
289 class callback6 {
290   struct object { };
291
292   void *obj;
293   R (object::*meth) (A1, A2, A3, A4, A5, A6);
294
295   /* a proxy is a kind of recipe on how to call a specific class method */
296   struct proxy_base {
297     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
298   };
299   template<class O1, class O2>
300   struct proxy : proxy_base {
301     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
302       {
303         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6)> (meth)))
304           (a1, a2, a3, a4, a5, a6);
305       }
306   };
307
308   proxy_base *prxy;
309
310 public:
311   template<class O1, class O2>
312   callback6 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5, A6))
313     {
314       static proxy<O1,O2> p;
315       obj  = reinterpret_cast<void *> (object);
316       meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6)> (method);
317       prxy = &p;
318     }
319
320   R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
321     {
322       return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
323     }
324
325   R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
326     {
327       return call (a1, a2, a3, a4, a5, a6);
328     }
329 };
330
331 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
332 class callback7 {
333   struct object { };
334
335   void *obj;
336   R (object::*meth) (A1, A2, A3, A4, A5, A6, A7);
337
338   /* a proxy is a kind of recipe on how to call a specific class method */
339   struct proxy_base {
340     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
341   };
342   template<class O1, class O2>
343   struct proxy : proxy_base {
344     virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
345       {
346         ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6, A7)> (meth)))
347           (a1, a2, a3, a4, a5, a6, a7);
348       }
349   };
350
351   proxy_base *prxy;
352
353 public:
354   template<class O1, class O2>
355   callback7 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5, A6, A7))
356     {
357       static proxy<O1,O2> p;
358       obj  = reinterpret_cast<void *> (object);
359       meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6, A7)> (method);
360       prxy = &p;
361     }
362
363   R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
364     {
365       return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
366     }
367
368   R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
369     {
370       return call (a1, a2, a3, a4, a5, a6, a7);
371     }
372 };
373
374 #endif