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 |
callback.h -- C++ callback mechanism |
7 |
Copyright (C) 2003-2006 Marc Lehmann <pcg@goof.com> |
8 |
|
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 |
|
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 |