ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/callback.h
(Generate patch)

Comparing gvpe/src/callback.h (file contents):
Revision 1.11 by pcg, Sun Dec 2 00:54:52 2007 UTC vs.
Revision 1.16 by root, Sun Nov 18 00:02:56 2018 UTC

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/* 1/*
6 callback.h -- C++ callback mechanism 2 * callback.h -- C++ callback mechanism
7 Copyright (C) 2003-2007 Marc Lehmann <pcg@goof.com> 3 * Copyright (C) 2003-2018 Marc Lehmann <pcg@goof.com>
8 4 *
9 This file is part of GVPE. 5 * This file is part of GVPE.
10 6 *
11 GVPE is free software; you can redistribute it and/or modify 7 * This program is free software; you can redistribute it and/or modify it
12 it under the terms of the GNU General Public License as published by 8 * under the terms of the GNU General Public License as published by the
13 the Free Software Foundation; either version 2 of the License, or 9 * Free Software Foundation; either version 3 of the License, or (at your
14 (at your option) any later version. 10 * option) any later version.
15 11 *
16 This program is distributed in the hope that it will be useful, 12 * This program is distributed in the hope that it will be useful, but
17 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
19 GNU General Public License for more details. 15 * Public License for more details.
20 16 *
21 You should have received a copy of the GNU General Public License 17 * You should have received a copy of the GNU General Public License along
22 along with gvpe; if not, write to the Free Software 18 * with this program; if not, see <http://www.gnu.org/licenses/>.
23 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 *
20 * Additional permission under GNU GPL version 3 section 7
21 *
22 * If you modify this Program, or any covered work, by linking or
23 * combining it with the OpenSSL project's OpenSSL library (or a modified
24 * version of that library), containing parts covered by the terms of the
25 * OpenSSL or SSLeay licenses, the licensors of this Program grant you
26 * additional permission to convey the resulting work. Corresponding
27 * Source for a non-source form of such a combination shall include the
28 * source code for the parts of OpenSSL used as well as that of the
29 * covered work.
24*/ 30*/
25 31
26#ifndef CALLBACK_H__ 32#ifndef CALLBACK_H__
27#define CALLBACK_H__ 33#define CALLBACK_H__
28 34
29#define CALLBACK_H_VERSION 3 35#define CALLBACK_H_VERSION 4
30 36
31template<class signature> 37template<typename signature>
32struct callback_funtype_trait; 38struct callback;
33 39
34template<int arity, class signature> 40template<class R, class ...Args>
35struct callback_get_impl; 41struct callback<R (Args...)>
42{
43 typedef R (*ptr_type)(void *self, Args...);
36 44
37template<class R> 45 template<class K, R (K::*method)(Args...)>
38class callback0 46 void set (K *object)
39{
40 struct klass; // it is vital that this is never defined
41
42 typedef R (klass::*ptr_type)();
43
44 klass *o;
45 R (klass::*m)();
46
47public:
48 template<class O1, class O2>
49 explicit callback0 (O1 *object, R (O2::*method)())
50 { 47 {
51 o = reinterpret_cast<klass *>(object); 48 self = object;
52 m = reinterpret_cast<R (klass::*)()>(method); 49 func = thunk<K, method>;
53 } 50 }
54 51
55 // this works because a standards-compliant C++ compiler 52 R call (Args... args) const
56 // basically can't help it: it doesn't have the knowledge
57 // required to miscompile (klass is not defined anywhere
58 // and nothing is known about the constructor arguments) :)
59 R call() const
60 { 53 {
61 return (o->*m) (); 54 return func (self, args...);
62 } 55 }
63 56
64 R operator ()() const 57 R operator ()(Args... args) const
65 { 58 {
66 return call (); 59 return call (args...);
67 }
68};
69
70template<class R>
71struct callback_funtype_trait0
72{
73 static const int arity = 0;
74 typedef R type (void);
75 typedef R result_type;
76
77};
78
79template<class R>
80struct callback_funtype_trait<R ()> : callback_funtype_trait0<R>
81{
82};
83
84template<class signature>
85struct callback_get_impl<0, signature>
86{
87 typedef callback_funtype_trait<signature> T;
88 typedef callback0<typename T::result_type> type;
89};
90
91template<class R, class A1>
92class callback1
93{
94 struct klass; // it is vital that this is never defined
95
96 typedef R (klass::*ptr_type)(A1);
97
98 klass *o;
99 R (klass::*m)(A1);
100
101public:
102 template<class O1, class O2>
103 explicit callback1 (O1 *object, R (O2::*method)(A1))
104 {
105 o = reinterpret_cast<klass *>(object);
106 m = reinterpret_cast<R (klass::*)(A1)>(method);
107 } 60 }
108 61
109 // this works because a standards-compliant C++ compiler 62private:
110 // basically can't help it: it doesn't have the knowledge 63
111 // required to miscompile (klass is not defined anywhere 64 void *self;
112 // and nothing is known about the constructor arguments) :) 65 ptr_type func;
113 R call(A1 a1) const 66
67 template<class klass, R (klass::*method)(Args...)>
68 static R thunk (void *self, Args... args)
114 { 69 {
70 klass *obj = static_cast<klass *>(self);
115 return (o->*m) (a1); 71 return (obj->*method) (args...);
116 }
117
118 R operator ()(A1 a1) const
119 {
120 return call (a1);
121 }
122};
123
124template<class R, class A1>
125struct callback_funtype_trait1
126{
127 static const int arity = 1;
128 typedef R type (A1);
129 typedef R result_type;
130 typedef A1 arg1_type;
131};
132
133template<class R, class A1>
134struct callback_funtype_trait<R (A1)> : callback_funtype_trait1<R, A1>
135{
136};
137
138template<class signature>
139struct callback_get_impl<1, signature>
140{
141 typedef callback_funtype_trait<signature> T;
142 typedef callback1<typename T::result_type, typename T::arg1_type> type;
143};
144
145template<class R, class A1, class A2>
146class callback2
147{
148 struct klass; // it is vital that this is never defined
149
150 typedef R (klass::*ptr_type)(A1, A2);
151
152 klass *o;
153 R (klass::*m)(A1, A2);
154
155public:
156 template<class O1, class O2>
157 explicit callback2 (O1 *object, R (O2::*method)(A1, A2))
158 {
159 o = reinterpret_cast<klass *>(object);
160 m = reinterpret_cast<R (klass::*)(A1, A2)>(method);
161 }
162
163 // this works because a standards-compliant C++ compiler
164 // basically can't help it: it doesn't have the knowledge
165 // required to miscompile (klass is not defined anywhere
166 // and nothing is known about the constructor arguments) :)
167 R call(A1 a1, A2 a2) const
168 {
169 return (o->*m) (a1, a2);
170 }
171
172 R operator ()(A1 a1, A2 a2) const
173 {
174 return call (a1, a2);
175 }
176};
177
178template<class R, class A1, class A2>
179struct callback_funtype_trait2
180{
181 static const int arity = 2;
182 typedef R type (A1, A2);
183 typedef R result_type;
184 typedef A1 arg1_type; typedef A2 arg2_type;
185};
186
187template<class R, class A1, class A2>
188struct callback_funtype_trait<R (A1, A2)> : callback_funtype_trait2<R, A1, A2>
189{
190};
191
192template<class signature>
193struct callback_get_impl<2, signature>
194{
195 typedef callback_funtype_trait<signature> T;
196 typedef callback2<typename T::result_type, typename T::arg1_type, typename T::arg2_type> type;
197};
198
199template<class R, class A1, class A2, class A3>
200class callback3
201{
202 struct klass; // it is vital that this is never defined
203
204 typedef R (klass::*ptr_type)(A1, A2, A3);
205
206 klass *o;
207 R (klass::*m)(A1, A2, A3);
208
209public:
210 template<class O1, class O2>
211 explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
212 {
213 o = reinterpret_cast<klass *>(object);
214 m = reinterpret_cast<R (klass::*)(A1, A2, A3)>(method);
215 }
216
217 // this works because a standards-compliant C++ compiler
218 // basically can't help it: it doesn't have the knowledge
219 // required to miscompile (klass is not defined anywhere
220 // and nothing is known about the constructor arguments) :)
221 R call(A1 a1, A2 a2, A3 a3) const
222 {
223 return (o->*m) (a1, a2, a3);
224 }
225
226 R operator ()(A1 a1, A2 a2, A3 a3) const
227 {
228 return call (a1, a2, a3);
229 }
230};
231
232template<class R, class A1, class A2, class A3>
233struct callback_funtype_trait3
234{
235 static const int arity = 3;
236 typedef R type (A1, A2, A3);
237 typedef R result_type;
238 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type;
239};
240
241template<class R, class A1, class A2, class A3>
242struct callback_funtype_trait<R (A1, A2, A3)> : callback_funtype_trait3<R, A1, A2, A3>
243{
244};
245
246template<class signature>
247struct callback_get_impl<3, signature>
248{
249 typedef callback_funtype_trait<signature> T;
250 typedef callback3<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type> type;
251};
252
253template<class R, class A1, class A2, class A3, class A4>
254class callback4
255{
256 struct klass; // it is vital that this is never defined
257
258 typedef R (klass::*ptr_type)(A1, A2, A3, A4);
259
260 klass *o;
261 R (klass::*m)(A1, A2, A3, A4);
262
263public:
264 template<class O1, class O2>
265 explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
266 {
267 o = reinterpret_cast<klass *>(object);
268 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4)>(method);
269 }
270
271 // this works because a standards-compliant C++ compiler
272 // basically can't help it: it doesn't have the knowledge
273 // required to miscompile (klass is not defined anywhere
274 // and nothing is known about the constructor arguments) :)
275 R call(A1 a1, A2 a2, A3 a3, A4 a4) const
276 {
277 return (o->*m) (a1, a2, a3, a4);
278 }
279
280 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
281 {
282 return call (a1, a2, a3, a4);
283 }
284};
285
286template<class R, class A1, class A2, class A3, class A4>
287struct callback_funtype_trait4
288{
289 static const int arity = 4;
290 typedef R type (A1, A2, A3, A4);
291 typedef R result_type;
292 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type;
293};
294
295template<class R, class A1, class A2, class A3, class A4>
296struct callback_funtype_trait<R (A1, A2, A3, A4)> : callback_funtype_trait4<R, A1, A2, A3, A4>
297{
298};
299
300template<class signature>
301struct callback_get_impl<4, signature>
302{
303 typedef callback_funtype_trait<signature> T;
304 typedef callback4<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type> type;
305};
306
307template<class R, class A1, class A2, class A3, class A4, class A5>
308class callback5
309{
310 struct klass; // it is vital that this is never defined
311
312 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5);
313
314 klass *o;
315 R (klass::*m)(A1, A2, A3, A4, A5);
316
317public:
318 template<class O1, class O2>
319 explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
320 {
321 o = reinterpret_cast<klass *>(object);
322 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5)>(method);
323 }
324
325 // this works because a standards-compliant C++ compiler
326 // basically can't help it: it doesn't have the knowledge
327 // required to miscompile (klass is not defined anywhere
328 // and nothing is known about the constructor arguments) :)
329 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
330 {
331 return (o->*m) (a1, a2, a3, a4, a5);
332 }
333
334 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
335 {
336 return call (a1, a2, a3, a4, a5);
337 }
338};
339
340template<class R, class A1, class A2, class A3, class A4, class A5>
341struct callback_funtype_trait5
342{
343 static const int arity = 5;
344 typedef R type (A1, A2, A3, A4, A5);
345 typedef R result_type;
346 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type;
347};
348
349template<class R, class A1, class A2, class A3, class A4, class A5>
350struct callback_funtype_trait<R (A1, A2, A3, A4, A5)> : callback_funtype_trait5<R, A1, A2, A3, A4, A5>
351{
352};
353
354template<class signature>
355struct callback_get_impl<5, signature>
356{
357 typedef callback_funtype_trait<signature> T;
358 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;
359};
360
361template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
362class callback6
363{
364 struct klass; // it is vital that this is never defined
365
366 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6);
367
368 klass *o;
369 R (klass::*m)(A1, A2, A3, A4, A5, A6);
370
371public:
372 template<class O1, class O2>
373 explicit callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
374 {
375 o = reinterpret_cast<klass *>(object);
376 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6)>(method);
377 }
378
379 // this works because a standards-compliant C++ compiler
380 // basically can't help it: it doesn't have the knowledge
381 // required to miscompile (klass is not defined anywhere
382 // and nothing is known about the constructor arguments) :)
383 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
384 {
385 return (o->*m) (a1, a2, a3, a4, a5, a6);
386 }
387
388 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
389 {
390 return call (a1, a2, a3, a4, a5, a6);
391 }
392};
393
394template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
395struct callback_funtype_trait6
396{
397 static const int arity = 6;
398 typedef R type (A1, A2, A3, A4, A5, A6);
399 typedef R result_type;
400 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type;
401};
402
403template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
404struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6)> : callback_funtype_trait6<R, A1, A2, A3, A4, A5, A6>
405{
406};
407
408template<class signature>
409struct callback_get_impl<6, signature>
410{
411 typedef callback_funtype_trait<signature> T;
412 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;
413};
414
415template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
416class callback7
417{
418 struct klass; // it is vital that this is never defined
419
420 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7);
421
422 klass *o;
423 R (klass::*m)(A1, A2, A3, A4, A5, A6, A7);
424
425public:
426 template<class O1, class O2>
427 explicit callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
428 {
429 o = reinterpret_cast<klass *>(object);
430 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
431 }
432
433 // this works because a standards-compliant C++ compiler
434 // basically can't help it: it doesn't have the knowledge
435 // required to miscompile (klass is not defined anywhere
436 // and nothing is known about the constructor arguments) :)
437 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
438 {
439 return (o->*m) (a1, a2, a3, a4, a5, a6, a7);
440 }
441
442 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
443 {
444 return call (a1, a2, a3, a4, a5, a6, a7);
445 }
446};
447
448template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
449struct callback_funtype_trait7
450{
451 static const int arity = 7;
452 typedef R type (A1, A2, A3, A4, A5, A6, A7);
453 typedef R result_type;
454 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;
455};
456
457template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
458struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7)> : callback_funtype_trait7<R, A1, A2, A3, A4, A5, A6, A7>
459{
460};
461
462template<class signature>
463struct callback_get_impl<7, signature>
464{
465 typedef callback_funtype_trait<signature> T;
466 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;
467};
468
469template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
470class callback8
471{
472 struct klass; // it is vital that this is never defined
473
474 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8);
475
476 klass *o;
477 R (klass::*m)(A1, A2, A3, A4, A5, A6, A7, A8);
478
479public:
480 template<class O1, class O2>
481 explicit callback8 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8))
482 {
483 o = reinterpret_cast<klass *>(object);
484 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7, A8)>(method);
485 }
486
487 // this works because a standards-compliant C++ compiler
488 // basically can't help it: it doesn't have the knowledge
489 // required to miscompile (klass is not defined anywhere
490 // and nothing is known about the constructor arguments) :)
491 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
492 {
493 return (o->*m) (a1, a2, a3, a4, a5, a6, a7, a8);
494 }
495
496 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
497 {
498 return call (a1, a2, a3, a4, a5, a6, a7, a8);
499 }
500};
501
502template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
503struct callback_funtype_trait8
504{
505 static const int arity = 8;
506 typedef R type (A1, A2, A3, A4, A5, A6, A7, A8);
507 typedef R result_type;
508 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;
509};
510
511template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
512struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7, A8)> : callback_funtype_trait8<R, A1, A2, A3, A4, A5, A6, A7, A8>
513{
514};
515
516template<class signature>
517struct callback_get_impl<8, signature>
518{
519 typedef callback_funtype_trait<signature> T;
520 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;
521};
522
523template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
524class callback9
525{
526 struct klass; // it is vital that this is never defined
527
528 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
529
530 klass *o;
531 R (klass::*m)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
532
533public:
534 template<class O1, class O2>
535 explicit callback9 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
536 {
537 o = reinterpret_cast<klass *>(object);
538 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>(method);
539 }
540
541 // this works because a standards-compliant C++ compiler
542 // basically can't help it: it doesn't have the knowledge
543 // required to miscompile (klass is not defined anywhere
544 // and nothing is known about the constructor arguments) :)
545 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
546 {
547 return (o->*m) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
548 }
549
550 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
551 {
552 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
553 }
554};
555
556template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
557struct callback_funtype_trait9
558{
559 static const int arity = 9;
560 typedef R type (A1, A2, A3, A4, A5, A6, A7, A8, A9);
561 typedef R result_type;
562 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;
563};
564
565template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
566struct 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>
567{
568};
569
570template<class signature>
571struct callback_get_impl<9, signature>
572{
573 typedef callback_funtype_trait<signature> T;
574 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;
575};
576
577template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
578class callback10
579{
580 struct klass; // it is vital that this is never defined
581
582 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
583
584 klass *o;
585 R (klass::*m)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
586
587public:
588 template<class O1, class O2>
589 explicit callback10 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
590 {
591 o = reinterpret_cast<klass *>(object);
592 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(method);
593 }
594
595 // this works because a standards-compliant C++ compiler
596 // basically can't help it: it doesn't have the knowledge
597 // required to miscompile (klass is not defined anywhere
598 // and nothing is known about the constructor arguments) :)
599 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
600 {
601 return (o->*m) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
602 }
603
604 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
605 {
606 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
607 }
608};
609
610template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
611struct callback_funtype_trait10
612{
613 static const int arity = 10;
614 typedef R type (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
615 typedef R result_type;
616 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;
617};
618
619template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
620struct 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>
621{
622};
623
624template<class signature>
625struct callback_get_impl<10, signature>
626{
627 typedef callback_funtype_trait<signature> T;
628 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;
629};
630
631
632template<class signature>
633struct callback : callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type
634{
635 typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;
636
637 template<class O, class M>
638 explicit callback (O object, M method)
639 : base_type (object, method)
640 {
641 } 72 }
642}; 73};
643 74
644#endif 75#endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines