ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/callback.h
Revision: 1.5
Committed: Sat Nov 17 23:40:00 2018 UTC (5 years, 6 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.4: +1 -1 lines
Log Message: 
copyright update 2018

File Contents

# User Rev Content
1 root 1.1 // 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    
5     /*
6 root 1.4 callback.h -- C++ callback mechanism
7 root 1.5 Copyright (C) 2003-2018 Marc Lehmann <pcg@goof.com>
8 root 1.4
9     This file is part of GVPE.
10    
11     GVPE is free software; you can redistribute it and/or modify
12     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     along with gvpe; if not, write to the Free Software
23     Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24     */
25 root 1.1
26     #ifndef CALLBACK_H__
27     #define CALLBACK_H__
28    
29     #define CALLBACK_H_VERSION 2
30    
31     template<class signature>
32     struct callback_funtype_trait;
33    
34     template<int arity, class signature>
35     struct callback_get_impl;
36    
37     template<class R>
38     class callback0
39     {
40     struct object { };
41    
42     typedef R (object::*ptr_type)();
43    
44     void *obj;
45     R (object::*meth)();
46    
47     /* a proxy is a kind of recipe on how to call a specific class method */
48     struct proxy_base {
49     virtual R call (void *obj, R (object::*meth)()) const = 0;
50     };
51     template<class O1, class O2>
52     struct proxy : proxy_base {
53     virtual R call (void *obj, R (object::*meth)()) const
54     {
55     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
56     ();
57     }
58     };
59    
60     proxy_base *prxy;
61    
62     public:
63     template<class O1, class O2>
64     explicit callback0 (O1 *object, R (O2::*method)())
65     {
66     static proxy<O1,O2> p;
67     obj = reinterpret_cast<void *>(object);
68     meth = reinterpret_cast<R (object::*)()>(method);
69     prxy = &p;
70     }
71    
72     R call() const
73     {
74     return prxy->call (obj, meth);
75     }
76    
77     R operator ()() const
78     {
79     return call ();
80     }
81     };
82    
83     template<class R>
84     struct callback_funtype_trait0
85     {
86     static const int arity = 0;
87     typedef R type (void);
88     typedef R result_type;
89    
90     };
91    
92     template<class R>
93     struct callback_funtype_trait<R ()> : callback_funtype_trait0<R>
94     {
95     };
96    
97     template<class signature>
98     struct callback_get_impl<0, signature>
99     {
100     typedef callback_funtype_trait<signature> T;
101     typedef callback0<typename T::result_type> type;
102     };
103    
104     template<class R, class A1>
105     class callback1
106     {
107     struct object { };
108    
109     typedef R (object::*ptr_type)(A1);
110    
111     void *obj;
112     R (object::*meth)(A1);
113    
114     /* a proxy is a kind of recipe on how to call a specific class method */
115     struct proxy_base {
116     virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const = 0;
117     };
118     template<class O1, class O2>
119     struct proxy : proxy_base {
120     virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const
121     {
122     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
123     (a1);
124     }
125     };
126    
127     proxy_base *prxy;
128    
129     public:
130     template<class O1, class O2>
131     explicit callback1 (O1 *object, R (O2::*method)(A1))
132     {
133     static proxy<O1,O2> p;
134     obj = reinterpret_cast<void *>(object);
135     meth = reinterpret_cast<R (object::*)(A1)>(method);
136     prxy = &p;
137     }
138    
139     R call(A1 a1) const
140     {
141     return prxy->call (obj, meth, a1);
142     }
143    
144     R operator ()(A1 a1) const
145     {
146     return call (a1);
147     }
148     };
149    
150     template<class R, class A1>
151     struct callback_funtype_trait1
152     {
153     static const int arity = 1;
154     typedef R type (A1);
155     typedef R result_type;
156     typedef A1 arg1_type;
157     };
158    
159     template<class R, class A1>
160     struct callback_funtype_trait<R (A1)> : callback_funtype_trait1<R, A1>
161     {
162     };
163    
164     template<class signature>
165     struct callback_get_impl<1, signature>
166     {
167     typedef callback_funtype_trait<signature> T;
168     typedef callback1<typename T::result_type, typename T::arg1_type> type;
169     };
170    
171     template<class R, class A1, class A2>
172     class callback2
173     {
174     struct object { };
175    
176     typedef R (object::*ptr_type)(A1, A2);
177    
178     void *obj;
179     R (object::*meth)(A1, A2);
180    
181     /* a proxy is a kind of recipe on how to call a specific class method */
182     struct proxy_base {
183     virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const = 0;
184     };
185     template<class O1, class O2>
186     struct proxy : proxy_base {
187     virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const
188     {
189     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
190     (a1, a2);
191     }
192     };
193    
194     proxy_base *prxy;
195    
196     public:
197     template<class O1, class O2>
198     explicit callback2 (O1 *object, R (O2::*method)(A1, A2))
199     {
200     static proxy<O1,O2> p;
201     obj = reinterpret_cast<void *>(object);
202     meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
203     prxy = &p;
204     }
205    
206     R call(A1 a1, A2 a2) const
207     {
208     return prxy->call (obj, meth, a1, a2);
209     }
210    
211     R operator ()(A1 a1, A2 a2) const
212     {
213     return call (a1, a2);
214     }
215     };
216    
217     template<class R, class A1, class A2>
218     struct callback_funtype_trait2
219     {
220     static const int arity = 2;
221     typedef R type (A1, A2);
222     typedef R result_type;
223     typedef A1 arg1_type; typedef A2 arg2_type;
224     };
225    
226     template<class R, class A1, class A2>
227     struct callback_funtype_trait<R (A1, A2)> : callback_funtype_trait2<R, A1, A2>
228     {
229     };
230    
231     template<class signature>
232     struct callback_get_impl<2, signature>
233     {
234     typedef callback_funtype_trait<signature> T;
235     typedef callback2<typename T::result_type, typename T::arg1_type, typename T::arg2_type> type;
236     };
237    
238     template<class R, class A1, class A2, class A3>
239     class callback3
240     {
241     struct object { };
242    
243     typedef R (object::*ptr_type)(A1, A2, A3);
244    
245     void *obj;
246     R (object::*meth)(A1, A2, A3);
247    
248     /* a proxy is a kind of recipe on how to call a specific class method */
249     struct proxy_base {
250     virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const = 0;
251     };
252     template<class O1, class O2>
253     struct proxy : proxy_base {
254     virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const
255     {
256     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
257     (a1, a2, a3);
258     }
259     };
260    
261     proxy_base *prxy;
262    
263     public:
264     template<class O1, class O2>
265     explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
266     {
267     static proxy<O1,O2> p;
268     obj = reinterpret_cast<void *>(object);
269     meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
270     prxy = &p;
271     }
272    
273     R call(A1 a1, A2 a2, A3 a3) const
274     {
275     return prxy->call (obj, meth, a1, a2, a3);
276     }
277    
278     R operator ()(A1 a1, A2 a2, A3 a3) const
279     {
280     return call (a1, a2, a3);
281     }
282     };
283    
284     template<class R, class A1, class A2, class A3>
285     struct callback_funtype_trait3
286     {
287     static const int arity = 3;
288     typedef R type (A1, A2, A3);
289     typedef R result_type;
290     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type;
291     };
292    
293     template<class R, class A1, class A2, class A3>
294     struct callback_funtype_trait<R (A1, A2, A3)> : callback_funtype_trait3<R, A1, A2, A3>
295     {
296     };
297    
298     template<class signature>
299     struct callback_get_impl<3, signature>
300     {
301     typedef callback_funtype_trait<signature> T;
302     typedef callback3<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type> type;
303     };
304    
305     template<class R, class A1, class A2, class A3, class A4>
306     class callback4
307     {
308     struct object { };
309    
310     typedef R (object::*ptr_type)(A1, A2, A3, A4);
311    
312     void *obj;
313     R (object::*meth)(A1, A2, A3, A4);
314    
315     /* a proxy is a kind of recipe on how to call a specific class method */
316     struct proxy_base {
317     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const = 0;
318     };
319     template<class O1, class O2>
320     struct proxy : proxy_base {
321     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const
322     {
323     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
324     (a1, a2, a3, a4);
325     }
326     };
327    
328     proxy_base *prxy;
329    
330     public:
331     template<class O1, class O2>
332     explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
333     {
334     static proxy<O1,O2> p;
335     obj = reinterpret_cast<void *>(object);
336     meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
337     prxy = &p;
338     }
339    
340     R call(A1 a1, A2 a2, A3 a3, A4 a4) const
341     {
342     return prxy->call (obj, meth, a1, a2, a3, a4);
343     }
344    
345     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
346     {
347     return call (a1, a2, a3, a4);
348     }
349     };
350    
351     template<class R, class A1, class A2, class A3, class A4>
352     struct callback_funtype_trait4
353     {
354     static const int arity = 4;
355     typedef R type (A1, A2, A3, A4);
356     typedef R result_type;
357     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type;
358     };
359    
360     template<class R, class A1, class A2, class A3, class A4>
361     struct callback_funtype_trait<R (A1, A2, A3, A4)> : callback_funtype_trait4<R, A1, A2, A3, A4>
362     {
363     };
364    
365     template<class signature>
366     struct callback_get_impl<4, signature>
367     {
368     typedef callback_funtype_trait<signature> T;
369     typedef callback4<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type> type;
370     };
371    
372     template<class R, class A1, class A2, class A3, class A4, class A5>
373     class callback5
374     {
375     struct object { };
376    
377     typedef R (object::*ptr_type)(A1, A2, A3, A4, A5);
378    
379     void *obj;
380     R (object::*meth)(A1, A2, A3, A4, A5);
381    
382     /* a proxy is a kind of recipe on how to call a specific class method */
383     struct proxy_base {
384     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const = 0;
385     };
386     template<class O1, class O2>
387     struct proxy : proxy_base {
388     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
389     {
390     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
391     (a1, a2, a3, a4, a5);
392     }
393     };
394    
395     proxy_base *prxy;
396    
397     public:
398     template<class O1, class O2>
399     explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
400     {
401     static proxy<O1,O2> p;
402     obj = reinterpret_cast<void *>(object);
403     meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
404     prxy = &p;
405     }
406    
407     R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
408     {
409     return prxy->call (obj, meth, a1, a2, a3, a4, a5);
410     }
411    
412     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
413     {
414     return call (a1, a2, a3, a4, a5);
415     }
416     };
417    
418     template<class R, class A1, class A2, class A3, class A4, class A5>
419     struct callback_funtype_trait5
420     {
421     static const int arity = 5;
422     typedef R type (A1, A2, A3, A4, A5);
423     typedef R result_type;
424     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type;
425     };
426    
427     template<class R, class A1, class A2, class A3, class A4, class A5>
428     struct callback_funtype_trait<R (A1, A2, A3, A4, A5)> : callback_funtype_trait5<R, A1, A2, A3, A4, A5>
429     {
430     };
431    
432     template<class signature>
433     struct callback_get_impl<5, signature>
434     {
435     typedef callback_funtype_trait<signature> T;
436     typedef callback5<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type> type;
437     };
438    
439     template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
440     class callback6
441     {
442     struct object { };
443    
444     typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6);
445    
446     void *obj;
447     R (object::*meth)(A1, A2, A3, A4, A5, A6);
448    
449     /* a proxy is a kind of recipe on how to call a specific class method */
450     struct proxy_base {
451     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) const = 0;
452     };
453     template<class O1, class O2>
454     struct proxy : proxy_base {
455     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) const
456     {
457     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
458     (a1, a2, a3, a4, a5, a6);
459     }
460     };
461    
462     proxy_base *prxy;
463    
464     public:
465     template<class O1, class O2>
466     explicit callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
467     {
468     static proxy<O1,O2> p;
469     obj = reinterpret_cast<void *>(object);
470     meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
471     prxy = &p;
472     }
473    
474     R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
475     {
476     return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
477     }
478    
479     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
480     {
481     return call (a1, a2, a3, a4, a5, a6);
482     }
483     };
484    
485     template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
486     struct callback_funtype_trait6
487     {
488     static const int arity = 6;
489     typedef R type (A1, A2, A3, A4, A5, A6);
490     typedef R result_type;
491     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type;
492     };
493    
494     template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
495     struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6)> : callback_funtype_trait6<R, A1, A2, A3, A4, A5, A6>
496     {
497     };
498    
499     template<class signature>
500     struct callback_get_impl<6, signature>
501     {
502     typedef callback_funtype_trait<signature> T;
503     typedef callback6<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type> type;
504     };
505    
506     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
507     class callback7
508     {
509     struct object { };
510    
511     typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7);
512    
513     void *obj;
514     R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
515    
516     /* a proxy is a kind of recipe on how to call a specific class method */
517     struct proxy_base {
518     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) const = 0;
519     };
520     template<class O1, class O2>
521     struct proxy : proxy_base {
522     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) const
523     {
524     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
525     (a1, a2, a3, a4, a5, a6, a7);
526     }
527     };
528    
529     proxy_base *prxy;
530    
531     public:
532     template<class O1, class O2>
533     explicit callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
534     {
535     static proxy<O1,O2> p;
536     obj = reinterpret_cast<void *>(object);
537     meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
538     prxy = &p;
539     }
540    
541     R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
542     {
543     return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
544     }
545    
546     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
547     {
548     return call (a1, a2, a3, a4, a5, a6, a7);
549     }
550     };
551    
552     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
553     struct callback_funtype_trait7
554     {
555     static const int arity = 7;
556     typedef R type (A1, A2, A3, A4, A5, A6, A7);
557     typedef R result_type;
558     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type;
559     };
560    
561     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
562     struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7)> : callback_funtype_trait7<R, A1, A2, A3, A4, A5, A6, A7>
563     {
564     };
565    
566     template<class signature>
567     struct callback_get_impl<7, signature>
568     {
569     typedef callback_funtype_trait<signature> T;
570     typedef callback7<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type> type;
571     };
572    
573     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
574     class callback8
575     {
576     struct object { };
577    
578     typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8);
579    
580     void *obj;
581     R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8);
582    
583     /* a proxy is a kind of recipe on how to call a specific class method */
584     struct proxy_base {
585     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const = 0;
586     };
587     template<class O1, class O2>
588     struct proxy : proxy_base {
589     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
590     {
591     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7, A8)>(meth)))
592     (a1, a2, a3, a4, a5, a6, a7, a8);
593     }
594     };
595    
596     proxy_base *prxy;
597    
598     public:
599     template<class O1, class O2>
600     explicit callback8 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8))
601     {
602     static proxy<O1,O2> p;
603     obj = reinterpret_cast<void *>(object);
604     meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8)>(method);
605     prxy = &p;
606     }
607    
608     R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
609     {
610     return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8);
611     }
612    
613     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
614     {
615     return call (a1, a2, a3, a4, a5, a6, a7, a8);
616     }
617     };
618    
619     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
620     struct callback_funtype_trait8
621     {
622     static const int arity = 8;
623     typedef R type (A1, A2, A3, A4, A5, A6, A7, A8);
624     typedef R result_type;
625     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type; typedef A8 arg8_type;
626     };
627    
628     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
629     struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7, A8)> : callback_funtype_trait8<R, A1, A2, A3, A4, A5, A6, A7, A8>
630     {
631     };
632    
633     template<class signature>
634     struct callback_get_impl<8, signature>
635     {
636     typedef callback_funtype_trait<signature> T;
637     typedef callback8<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type, typename T::arg8_type> type;
638     };
639    
640     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
641     class callback9
642     {
643     struct object { };
644    
645     typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
646    
647     void *obj;
648     R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
649    
650     /* a proxy is a kind of recipe on how to call a specific class method */
651     struct proxy_base {
652     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const = 0;
653     };
654     template<class O1, class O2>
655     struct proxy : proxy_base {
656     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
657     {
658     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>(meth)))
659     (a1, a2, a3, a4, a5, a6, a7, a8, a9);
660     }
661     };
662    
663     proxy_base *prxy;
664    
665     public:
666     template<class O1, class O2>
667     explicit callback9 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
668     {
669     static proxy<O1,O2> p;
670     obj = reinterpret_cast<void *>(object);
671     meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>(method);
672     prxy = &p;
673     }
674    
675     R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
676     {
677     return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9);
678     }
679    
680     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
681     {
682     return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
683     }
684     };
685    
686     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
687     struct callback_funtype_trait9
688     {
689     static const int arity = 9;
690     typedef R type (A1, A2, A3, A4, A5, A6, A7, A8, A9);
691     typedef R result_type;
692     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type; typedef A8 arg8_type; typedef A9 arg9_type;
693     };
694    
695     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
696     struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)> : callback_funtype_trait9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>
697     {
698     };
699    
700     template<class signature>
701     struct callback_get_impl<9, signature>
702     {
703     typedef callback_funtype_trait<signature> T;
704     typedef callback9<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type, typename T::arg8_type, typename T::arg9_type> type;
705     };
706    
707     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
708     class callback10
709     {
710     struct object { };
711    
712     typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
713    
714     void *obj;
715     R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
716    
717     /* a proxy is a kind of recipe on how to call a specific class method */
718     struct proxy_base {
719     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const = 0;
720     };
721     template<class O1, class O2>
722     struct proxy : proxy_base {
723     virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
724     {
725     return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(meth)))
726     (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
727     }
728     };
729    
730     proxy_base *prxy;
731    
732     public:
733     template<class O1, class O2>
734     explicit callback10 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
735     {
736     static proxy<O1,O2> p;
737     obj = reinterpret_cast<void *>(object);
738     meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(method);
739     prxy = &p;
740     }
741    
742     R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
743     {
744     return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
745     }
746    
747     R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
748     {
749     return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
750     }
751     };
752    
753     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
754     struct callback_funtype_trait10
755     {
756     static const int arity = 10;
757     typedef R type (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
758     typedef R result_type;
759     typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type; typedef A8 arg8_type; typedef A9 arg9_type; typedef A10 arg10_type;
760     };
761    
762     template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
763     struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : callback_funtype_trait10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>
764     {
765     };
766    
767     template<class signature>
768     struct callback_get_impl<10, signature>
769     {
770     typedef callback_funtype_trait<signature> T;
771     typedef callback10<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type, typename T::arg8_type, typename T::arg9_type, typename T::arg10_type> type;
772     };
773    
774    
775     template<class signature>
776     struct callback : callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type
777     {
778     typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;
779    
780     template<class O, class M>
781     explicit callback (O object, M method)
782     : base_type (object, method)
783     {
784     }
785     };
786    
787     #endif