ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/callback.h
Revision: 1.13
Committed: Tue Dec 4 17:17:19 2007 UTC (16 years, 5 months ago) by pcg
Content type: text/plain
Branch: MAIN
Changes since 1.12: +0 -2 lines
Log Message: 
switch to new callback system

File Contents

# User Rev Content
1 pcg 1.7 // THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
2     // THIS IS A GENERATED FILE: callback.pl is part of the GVPE
3     // THIS IS A GENERATED FILE: distribution.
4 pcg 1.2
5 pcg 1.1 /*
6     callback.h -- C++ callback mechanism
7 pcg 1.11 Copyright (C) 2003-2007 Marc Lehmann <pcg@goof.com>
8 pcg 1.1
9 pcg 1.5 This file is part of GVPE.
10    
11     GVPE is free software; you can redistribute it and/or modify
12 pcg 1.1 it under the terms of the GNU General Public License as published by
13     the Free Software Foundation; either version 2 of the License, or
14     (at your option) any later version.
15    
16     This program is distributed in the hope that it will be useful,
17     but WITHOUT ANY WARRANTY; without even the implied warranty of
18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19     GNU General Public License for more details.
20    
21     You should have received a copy of the GNU General Public License
22 pcg 1.5 along with gvpe; if not, write to the Free Software
23 pcg 1.6 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 pcg 1.1 */
25    
26 pcg 1.4 #ifndef CALLBACK_H__
27     #define CALLBACK_H__
28 pcg 1.1
29 pcg 1.11 #define CALLBACK_H_VERSION 3
30 pcg 1.10
31 pcg 1.12 template<typename signature>
32     struct callback;
33 pcg 1.10
34 pcg 1.2 template<class R>
35 pcg 1.12 struct callback<R ()>
36 pcg 1.10 {
37 pcg 1.12 typedef R (*ptr_type)(void *self);
38 pcg 1.2
39 pcg 1.12 private:
40 pcg 1.10
41 pcg 1.12 void *self;
42     ptr_type func;
43    
44     protected:
45    
46     template<typename method>
47     struct thunktype;
48    
49     template<class klass>
50     struct thunktype<R (klass::*)>
51     {
52     typedef klass K;
53     };
54    
55     template<class klass, R (klass::*method)()>
56     static R thunk (void *self)
57     {
58     klass *obj = static_cast<klass *>(self);
59     return (obj->*method) ();
60     }
61 pcg 1.2
62     public:
63 pcg 1.12 template<class K, R (K::*method)()>
64     void set (K *object)
65 pcg 1.11 {
66 pcg 1.12 self = object;
67     func = thunk<K, method>;
68 pcg 1.11 }
69    
70 pcg 1.12 R call () const
71 pcg 1.11 {
72 pcg 1.12 return func (self);
73 pcg 1.11 }
74 pcg 1.2
75     R operator ()() const
76 pcg 1.11 {
77     return call ();
78     }
79 pcg 1.2 };
80    
81 pcg 1.12 template<class R, class A1>
82     struct callback<R (A1)>
83 pcg 1.10 {
84 pcg 1.12 typedef R (*ptr_type)(void *self, A1);
85    
86     private:
87    
88     void *self;
89     ptr_type func;
90 pcg 1.10
91 pcg 1.12 protected:
92 pcg 1.10
93 pcg 1.12 template<typename method>
94     struct thunktype;
95 pcg 1.1
96 pcg 1.12 template<class klass>
97     struct thunktype<R (klass::*)>
98     {
99     typedef klass K;
100     };
101 pcg 1.1
102 pcg 1.12 template<class klass, R (klass::*method)(A1)>
103     static R thunk (void *self, A1 a1)
104     {
105     klass *obj = static_cast<klass *>(self);
106     return (obj->*method) (a1);
107     }
108 pcg 1.1
109     public:
110 pcg 1.12 template<class K, R (K::*method)(A1)>
111     void set (K *object)
112 pcg 1.11 {
113 pcg 1.12 self = object;
114     func = thunk<K, method>;
115 pcg 1.11 }
116    
117 pcg 1.12 R call (A1 a1) const
118 pcg 1.11 {
119 pcg 1.12 return func (self, a1);
120 pcg 1.11 }
121 pcg 1.1
122 pcg 1.2 R operator ()(A1 a1) const
123 pcg 1.11 {
124     return call (a1);
125     }
126 pcg 1.2 };
127    
128 pcg 1.12 template<class R, class A1, class A2>
129     struct callback<R (A1, A2)>
130 pcg 1.10 {
131 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2);
132    
133     private:
134    
135     void *self;
136     ptr_type func;
137 pcg 1.10
138 pcg 1.12 protected:
139 pcg 1.10
140 pcg 1.12 template<typename method>
141     struct thunktype;
142 pcg 1.10
143 pcg 1.12 template<class klass>
144     struct thunktype<R (klass::*)>
145     {
146     typedef klass K;
147     };
148 pcg 1.2
149 pcg 1.12 template<class klass, R (klass::*method)(A1, A2)>
150     static R thunk (void *self, A1 a1, A2 a2)
151     {
152     klass *obj = static_cast<klass *>(self);
153     return (obj->*method) (a1, a2);
154     }
155 pcg 1.2
156     public:
157 pcg 1.12 template<class K, R (K::*method)(A1, A2)>
158     void set (K *object)
159 pcg 1.11 {
160 pcg 1.12 self = object;
161     func = thunk<K, method>;
162 pcg 1.11 }
163    
164 pcg 1.12 R call (A1 a1, A2 a2) const
165 pcg 1.11 {
166 pcg 1.12 return func (self, a1, a2);
167 pcg 1.11 }
168 pcg 1.2
169     R operator ()(A1 a1, A2 a2) const
170 pcg 1.11 {
171     return call (a1, a2);
172     }
173 pcg 1.2 };
174    
175 pcg 1.12 template<class R, class A1, class A2, class A3>
176     struct callback<R (A1, A2, A3)>
177 pcg 1.10 {
178 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3);
179    
180     private:
181    
182     void *self;
183     ptr_type func;
184 pcg 1.10
185 pcg 1.12 protected:
186 pcg 1.10
187 pcg 1.12 template<typename method>
188     struct thunktype;
189 pcg 1.2
190 pcg 1.12 template<class klass>
191     struct thunktype<R (klass::*)>
192     {
193     typedef klass K;
194     };
195 pcg 1.10
196 pcg 1.12 template<class klass, R (klass::*method)(A1, A2, A3)>
197     static R thunk (void *self, A1 a1, A2 a2, A3 a3)
198     {
199     klass *obj = static_cast<klass *>(self);
200     return (obj->*method) (a1, a2, a3);
201     }
202 pcg 1.2
203     public:
204 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3)>
205     void set (K *object)
206 pcg 1.11 {
207 pcg 1.12 self = object;
208     func = thunk<K, method>;
209 pcg 1.11 }
210    
211 pcg 1.12 R call (A1 a1, A2 a2, A3 a3) const
212 pcg 1.11 {
213 pcg 1.12 return func (self, a1, a2, a3);
214 pcg 1.11 }
215 pcg 1.2
216     R operator ()(A1 a1, A2 a2, A3 a3) const
217 pcg 1.11 {
218     return call (a1, a2, a3);
219     }
220 pcg 1.2 };
221    
222 pcg 1.12 template<class R, class A1, class A2, class A3, class A4>
223     struct callback<R (A1, A2, A3, A4)>
224 pcg 1.10 {
225 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3, A4);
226    
227     private:
228 pcg 1.10
229 pcg 1.12 void *self;
230     ptr_type func;
231 pcg 1.10
232 pcg 1.12 protected:
233 pcg 1.10
234 pcg 1.12 template<typename method>
235     struct thunktype;
236 pcg 1.2
237 pcg 1.12 template<class klass>
238     struct thunktype<R (klass::*)>
239     {
240     typedef klass K;
241     };
242    
243     template<class klass, R (klass::*method)(A1, A2, A3, A4)>
244     static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)
245     {
246     klass *obj = static_cast<klass *>(self);
247     return (obj->*method) (a1, a2, a3, a4);
248     }
249 pcg 1.2
250     public:
251 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3, A4)>
252     void set (K *object)
253 pcg 1.11 {
254 pcg 1.12 self = object;
255     func = thunk<K, method>;
256 pcg 1.11 }
257    
258 pcg 1.12 R call (A1 a1, A2 a2, A3 a3, A4 a4) const
259 pcg 1.11 {
260 pcg 1.12 return func (self, a1, a2, a3, a4);
261 pcg 1.11 }
262 pcg 1.2
263     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
264 pcg 1.11 {
265     return call (a1, a2, a3, a4);
266     }
267 pcg 1.2 };
268    
269 pcg 1.12 template<class R, class A1, class A2, class A3, class A4, class A5>
270     struct callback<R (A1, A2, A3, A4, A5)>
271 pcg 1.10 {
272 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5);
273    
274     private:
275    
276     void *self;
277     ptr_type func;
278 pcg 1.10
279 pcg 1.12 protected:
280 pcg 1.10
281 pcg 1.12 template<typename method>
282     struct thunktype;
283 pcg 1.2
284 pcg 1.12 template<class klass>
285     struct thunktype<R (klass::*)>
286     {
287     typedef klass K;
288     };
289 pcg 1.2
290 pcg 1.12 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>
291     static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
292     {
293     klass *obj = static_cast<klass *>(self);
294     return (obj->*method) (a1, a2, a3, a4, a5);
295     }
296 pcg 1.2
297     public:
298 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
299     void set (K *object)
300 pcg 1.11 {
301 pcg 1.12 self = object;
302     func = thunk<K, method>;
303 pcg 1.11 }
304    
305 pcg 1.12 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
306 pcg 1.11 {
307 pcg 1.12 return func (self, a1, a2, a3, a4, a5);
308 pcg 1.11 }
309 pcg 1.2
310     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
311 pcg 1.11 {
312     return call (a1, a2, a3, a4, a5);
313     }
314 pcg 1.2 };
315    
316 pcg 1.12 template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
317     struct callback<R (A1, A2, A3, A4, A5, A6)>
318 pcg 1.10 {
319 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6);
320    
321     private:
322    
323     void *self;
324     ptr_type func;
325 pcg 1.10
326 pcg 1.12 protected:
327 pcg 1.10
328 pcg 1.12 template<typename method>
329     struct thunktype;
330 pcg 1.10
331 pcg 1.12 template<class klass>
332     struct thunktype<R (klass::*)>
333     {
334     typedef klass K;
335     };
336 pcg 1.2
337 pcg 1.12 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>
338     static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
339     {
340     klass *obj = static_cast<klass *>(self);
341     return (obj->*method) (a1, a2, a3, a4, a5, a6);
342     }
343 pcg 1.2
344     public:
345 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
346     void set (K *object)
347 pcg 1.11 {
348 pcg 1.12 self = object;
349     func = thunk<K, method>;
350 pcg 1.11 }
351    
352 pcg 1.12 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
353 pcg 1.11 {
354 pcg 1.12 return func (self, a1, a2, a3, a4, a5, a6);
355 pcg 1.11 }
356 pcg 1.2
357     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
358 pcg 1.11 {
359     return call (a1, a2, a3, a4, a5, a6);
360     }
361 pcg 1.2 };
362    
363 pcg 1.12 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
364     struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
365 pcg 1.10 {
366 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7);
367    
368     private:
369 pcg 1.10
370 pcg 1.12 void *self;
371     ptr_type func;
372 pcg 1.10
373 pcg 1.12 protected:
374 pcg 1.2
375 pcg 1.12 template<typename method>
376     struct thunktype;
377 pcg 1.10
378 pcg 1.12 template<class klass>
379     struct thunktype<R (klass::*)>
380     {
381     typedef klass K;
382     };
383    
384     template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>
385     static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
386     {
387     klass *obj = static_cast<klass *>(self);
388     return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);
389     }
390 pcg 1.2
391     public:
392 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
393     void set (K *object)
394 pcg 1.11 {
395 pcg 1.12 self = object;
396     func = thunk<K, method>;
397 pcg 1.11 }
398    
399 pcg 1.12 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
400 pcg 1.11 {
401 pcg 1.12 return func (self, a1, a2, a3, a4, a5, a6, a7);
402 pcg 1.11 }
403 pcg 1.2
404     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
405 pcg 1.11 {
406     return call (a1, a2, a3, a4, a5, a6, a7);
407     }
408 pcg 1.1 };
409    
410 pcg 1.12 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
411     struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>
412 pcg 1.10 {
413 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8);
414    
415     private:
416    
417     void *self;
418     ptr_type func;
419 pcg 1.10
420 pcg 1.12 protected:
421 pcg 1.10
422 pcg 1.12 template<typename method>
423     struct thunktype;
424 pcg 1.10
425 pcg 1.12 template<class klass>
426     struct thunktype<R (klass::*)>
427     {
428     typedef klass K;
429     };
430 pcg 1.10
431 pcg 1.12 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
432     static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
433     {
434     klass *obj = static_cast<klass *>(self);
435     return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);
436     }
437 pcg 1.10
438     public:
439 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
440     void set (K *object)
441 pcg 1.11 {
442 pcg 1.12 self = object;
443     func = thunk<K, method>;
444 pcg 1.11 }
445    
446 pcg 1.12 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
447 pcg 1.11 {
448 pcg 1.12 return func (self, a1, a2, a3, a4, a5, a6, a7, a8);
449 pcg 1.11 }
450 pcg 1.10
451     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
452 pcg 1.11 {
453     return call (a1, a2, a3, a4, a5, a6, a7, a8);
454     }
455 pcg 1.10 };
456    
457 pcg 1.12 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
458     struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
459 pcg 1.10 {
460 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9);
461    
462     private:
463    
464     void *self;
465     ptr_type func;
466 pcg 1.10
467 pcg 1.12 protected:
468 pcg 1.10
469 pcg 1.12 template<typename method>
470     struct thunktype;
471 pcg 1.10
472 pcg 1.12 template<class klass>
473     struct thunktype<R (klass::*)>
474     {
475     typedef klass K;
476     };
477 pcg 1.10
478 pcg 1.12 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
479     static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
480     {
481     klass *obj = static_cast<klass *>(self);
482     return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
483     }
484 pcg 1.10
485     public:
486 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
487     void set (K *object)
488 pcg 1.11 {
489 pcg 1.12 self = object;
490     func = thunk<K, method>;
491 pcg 1.11 }
492    
493 pcg 1.12 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
494 pcg 1.11 {
495 pcg 1.12 return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9);
496 pcg 1.11 }
497 pcg 1.10
498     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
499 pcg 1.11 {
500     return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
501     }
502 pcg 1.10 };
503    
504 pcg 1.12 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
505     struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
506 pcg 1.10 {
507 pcg 1.12 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
508    
509     private:
510    
511     void *self;
512     ptr_type func;
513 pcg 1.10
514 pcg 1.12 protected:
515 pcg 1.10
516 pcg 1.12 template<typename method>
517     struct thunktype;
518 pcg 1.10
519 pcg 1.12 template<class klass>
520     struct thunktype<R (klass::*)>
521     {
522     typedef klass K;
523     };
524 pcg 1.10
525 pcg 1.12 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
526     static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
527     {
528     klass *obj = static_cast<klass *>(self);
529     return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
530     }
531 pcg 1.10
532     public:
533 pcg 1.12 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
534     void set (K *object)
535 pcg 1.11 {
536 pcg 1.12 self = object;
537     func = thunk<K, method>;
538 pcg 1.11 }
539    
540 pcg 1.12 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
541 pcg 1.11 {
542 pcg 1.12 return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
543 pcg 1.11 }
544 pcg 1.10
545     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
546 pcg 1.11 {
547     return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
548     }
549 pcg 1.10 };
550    
551    
552 pcg 1.1 #endif