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

Comparing rxvt-unicode/src/callback.h (file contents):
Revision 1.8 by root, Wed May 31 00:32:56 2006 UTC vs.
Revision 1.9 by root, Sun Dec 2 01:07:29 2007 UTC

… …
2// THIS IS A GENERATED FILE: callback.pl is part of the GVPE 2// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
3// THIS IS A GENERATED FILE: distribution. 3// THIS IS A GENERATED FILE: distribution.
4 4
5/* 5/*
6 callback.h -- C++ callback mechanism 6 callback.h -- C++ callback mechanism
7 Copyright (C) 2003-2006 Marc Lehmann <pcg@goof.com> 7 Copyright (C) 2003-2007 Marc Lehmann <pcg@goof.com>
8 8
9 This file is part of GVPE. 9 This file is part of GVPE.
10 10
11 GVPE is free software; you can redistribute it and/or modify 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 12 it under the terms of the GNU General Public License as published by
… …
24*/ 24*/
25 25
26#ifndef CALLBACK_H__ 26#ifndef CALLBACK_H__
27#define CALLBACK_H__ 27#define CALLBACK_H__
28 28
29#define CALLBACK_H_VERSION 2 29#define CALLBACK_H_VERSION 3
30 30
31template<class signature> 31template<class signature>
32struct callback_funtype_trait; 32struct callback_funtype_trait;
33 33
34template<int arity, class signature> 34template<int arity, class signature>
35struct callback_get_impl; 35struct callback_get_impl;
36 36
37template<class R> 37template<class R>
38class callback0 38class callback0
39{ 39{
40 struct object { }; 40 struct klass; // it is vital that this is never defined
41 41
42 typedef R (object::*ptr_type)(); 42 typedef R (klass::*ptr_type)();
43 43
44 void *obj; 44 klass *o;
45 R (object::*meth)(); 45 R (klass::*m)();
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 46
62public: 47public:
63 template<class O1, class O2> 48 template<class O1, class O2>
64 explicit callback0 (O1 *object, R (O2::*method)()) 49 explicit callback0 (O1 *object, R (O2::*method)())
65 { 50 {
66 static proxy<O1,O2> p;
67 obj = reinterpret_cast<void *>(object); 51 o = reinterpret_cast<klass *>(object);
68 meth = reinterpret_cast<R (object::*)()>(method); 52 m = reinterpret_cast<R (klass::*)()>(method);
69 prxy = &p;
70 } 53 }
71 54
55 // this works because a standards-compliant C++ compiler
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) :)
72 R call() const 59 R call() const
73 { 60 {
74 return prxy->call (obj, meth); 61 return (o->*m) ();
75 } 62 }
76 63
77 R operator ()() const 64 R operator ()() const
78 { 65 {
79 return call (); 66 return call ();
80 } 67 }
81}; 68};
82 69
83template<class R> 70template<class R>
84struct callback_funtype_trait0 71struct callback_funtype_trait0
85{ 72{
… …
102}; 89};
103 90
104template<class R, class A1> 91template<class R, class A1>
105class callback1 92class callback1
106{ 93{
107 struct object { }; 94 struct klass; // it is vital that this is never defined
108 95
109 typedef R (object::*ptr_type)(A1); 96 typedef R (klass::*ptr_type)(A1);
110 97
111 void *obj; 98 klass *o;
112 R (object::*meth)(A1); 99 R (klass::*m)(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 100
129public: 101public:
130 template<class O1, class O2> 102 template<class O1, class O2>
131 explicit callback1 (O1 *object, R (O2::*method)(A1)) 103 explicit callback1 (O1 *object, R (O2::*method)(A1))
132 { 104 {
133 static proxy<O1,O2> p;
134 obj = reinterpret_cast<void *>(object); 105 o = reinterpret_cast<klass *>(object);
135 meth = reinterpret_cast<R (object::*)(A1)>(method); 106 m = reinterpret_cast<R (klass::*)(A1)>(method);
136 prxy = &p;
137 } 107 }
138 108
109 // this works because a standards-compliant C++ compiler
110 // basically can't help it: it doesn't have the knowledge
111 // required to miscompile (klass is not defined anywhere
112 // and nothing is known about the constructor arguments) :)
139 R call(A1 a1) const 113 R call(A1 a1) const
140 { 114 {
141 return prxy->call (obj, meth, a1); 115 return (o->*m) (a1);
142 } 116 }
143 117
144 R operator ()(A1 a1) const 118 R operator ()(A1 a1) const
145 { 119 {
146 return call (a1); 120 return call (a1);
147 } 121 }
148}; 122};
149 123
150template<class R, class A1> 124template<class R, class A1>
151struct callback_funtype_trait1 125struct callback_funtype_trait1
152{ 126{
… …
169}; 143};
170 144
171template<class R, class A1, class A2> 145template<class R, class A1, class A2>
172class callback2 146class callback2
173{ 147{
174 struct object { }; 148 struct klass; // it is vital that this is never defined
175 149
176 typedef R (object::*ptr_type)(A1, A2); 150 typedef R (klass::*ptr_type)(A1, A2);
177 151
178 void *obj; 152 klass *o;
179 R (object::*meth)(A1, A2); 153 R (klass::*m)(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 154
196public: 155public:
197 template<class O1, class O2> 156 template<class O1, class O2>
198 explicit callback2 (O1 *object, R (O2::*method)(A1, A2)) 157 explicit callback2 (O1 *object, R (O2::*method)(A1, A2))
199 { 158 {
200 static proxy<O1,O2> p;
201 obj = reinterpret_cast<void *>(object); 159 o = reinterpret_cast<klass *>(object);
202 meth = reinterpret_cast<R (object::*)(A1, A2)>(method); 160 m = reinterpret_cast<R (klass::*)(A1, A2)>(method);
203 prxy = &p;
204 } 161 }
205 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) :)
206 R call(A1 a1, A2 a2) const 167 R call(A1 a1, A2 a2) const
207 { 168 {
208 return prxy->call (obj, meth, a1, a2); 169 return (o->*m) (a1, a2);
209 } 170 }
210 171
211 R operator ()(A1 a1, A2 a2) const 172 R operator ()(A1 a1, A2 a2) const
212 { 173 {
213 return call (a1, a2); 174 return call (a1, a2);
214 } 175 }
215}; 176};
216 177
217template<class R, class A1, class A2> 178template<class R, class A1, class A2>
218struct callback_funtype_trait2 179struct callback_funtype_trait2
219{ 180{
… …
236}; 197};
237 198
238template<class R, class A1, class A2, class A3> 199template<class R, class A1, class A2, class A3>
239class callback3 200class callback3
240{ 201{
241 struct object { }; 202 struct klass; // it is vital that this is never defined
242 203
243 typedef R (object::*ptr_type)(A1, A2, A3); 204 typedef R (klass::*ptr_type)(A1, A2, A3);
244 205
245 void *obj; 206 klass *o;
246 R (object::*meth)(A1, A2, A3); 207 R (klass::*m)(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 208
263public: 209public:
264 template<class O1, class O2> 210 template<class O1, class O2>
265 explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3)) 211 explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
266 { 212 {
267 static proxy<O1,O2> p;
268 obj = reinterpret_cast<void *>(object); 213 o = reinterpret_cast<klass *>(object);
269 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method); 214 m = reinterpret_cast<R (klass::*)(A1, A2, A3)>(method);
270 prxy = &p;
271 } 215 }
272 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) :)
273 R call(A1 a1, A2 a2, A3 a3) const 221 R call(A1 a1, A2 a2, A3 a3) const
274 { 222 {
275 return prxy->call (obj, meth, a1, a2, a3); 223 return (o->*m) (a1, a2, a3);
276 } 224 }
277 225
278 R operator ()(A1 a1, A2 a2, A3 a3) const 226 R operator ()(A1 a1, A2 a2, A3 a3) const
279 { 227 {
280 return call (a1, a2, a3); 228 return call (a1, a2, a3);
281 } 229 }
282}; 230};
283 231
284template<class R, class A1, class A2, class A3> 232template<class R, class A1, class A2, class A3>
285struct callback_funtype_trait3 233struct callback_funtype_trait3
286{ 234{
… …
303}; 251};
304 252
305template<class R, class A1, class A2, class A3, class A4> 253template<class R, class A1, class A2, class A3, class A4>
306class callback4 254class callback4
307{ 255{
308 struct object { }; 256 struct klass; // it is vital that this is never defined
309 257
310 typedef R (object::*ptr_type)(A1, A2, A3, A4); 258 typedef R (klass::*ptr_type)(A1, A2, A3, A4);
311 259
312 void *obj; 260 klass *o;
313 R (object::*meth)(A1, A2, A3, A4); 261 R (klass::*m)(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 262
330public: 263public:
331 template<class O1, class O2> 264 template<class O1, class O2>
332 explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4)) 265 explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
333 { 266 {
334 static proxy<O1,O2> p;
335 obj = reinterpret_cast<void *>(object); 267 o = reinterpret_cast<klass *>(object);
336 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method); 268 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4)>(method);
337 prxy = &p;
338 } 269 }
339 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) :)
340 R call(A1 a1, A2 a2, A3 a3, A4 a4) const 275 R call(A1 a1, A2 a2, A3 a3, A4 a4) const
341 { 276 {
342 return prxy->call (obj, meth, a1, a2, a3, a4); 277 return (o->*m) (a1, a2, a3, a4);
343 } 278 }
344 279
345 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const 280 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
346 { 281 {
347 return call (a1, a2, a3, a4); 282 return call (a1, a2, a3, a4);
348 } 283 }
349}; 284};
350 285
351template<class R, class A1, class A2, class A3, class A4> 286template<class R, class A1, class A2, class A3, class A4>
352struct callback_funtype_trait4 287struct callback_funtype_trait4
353{ 288{
… …
370}; 305};
371 306
372template<class R, class A1, class A2, class A3, class A4, class A5> 307template<class R, class A1, class A2, class A3, class A4, class A5>
373class callback5 308class callback5
374{ 309{
375 struct object { }; 310 struct klass; // it is vital that this is never defined
376 311
377 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5); 312 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5);
378 313
379 void *obj; 314 klass *o;
380 R (object::*meth)(A1, A2, A3, A4, A5); 315 R (klass::*m)(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 316
397public: 317public:
398 template<class O1, class O2> 318 template<class O1, class O2>
399 explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5)) 319 explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
400 { 320 {
401 static proxy<O1,O2> p;
402 obj = reinterpret_cast<void *>(object); 321 o = reinterpret_cast<klass *>(object);
403 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method); 322 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5)>(method);
404 prxy = &p;
405 } 323 }
406 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) :)
407 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 329 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
408 { 330 {
409 return prxy->call (obj, meth, a1, a2, a3, a4, a5); 331 return (o->*m) (a1, a2, a3, a4, a5);
410 } 332 }
411 333
412 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 334 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
413 { 335 {
414 return call (a1, a2, a3, a4, a5); 336 return call (a1, a2, a3, a4, a5);
415 } 337 }
416}; 338};
417 339
418template<class R, class A1, class A2, class A3, class A4, class A5> 340template<class R, class A1, class A2, class A3, class A4, class A5>
419struct callback_funtype_trait5 341struct callback_funtype_trait5
420{ 342{
… …
437}; 359};
438 360
439template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 361template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
440class callback6 362class callback6
441{ 363{
442 struct object { }; 364 struct klass; // it is vital that this is never defined
443 365
444 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6); 366 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6);
445 367
446 void *obj; 368 klass *o;
447 R (object::*meth)(A1, A2, A3, A4, A5, A6); 369 R (klass::*m)(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 370
464public: 371public:
465 template<class O1, class O2> 372 template<class O1, class O2>
466 explicit callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6)) 373 explicit callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
467 { 374 {
468 static proxy<O1,O2> p;
469 obj = reinterpret_cast<void *>(object); 375 o = reinterpret_cast<klass *>(object);
470 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method); 376 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6)>(method);
471 prxy = &p;
472 } 377 }
473 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) :)
474 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 383 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
475 { 384 {
476 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6); 385 return (o->*m) (a1, a2, a3, a4, a5, a6);
477 } 386 }
478 387
479 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 388 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
480 { 389 {
481 return call (a1, a2, a3, a4, a5, a6); 390 return call (a1, a2, a3, a4, a5, a6);
482 } 391 }
483}; 392};
484 393
485template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 394template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
486struct callback_funtype_trait6 395struct callback_funtype_trait6
487{ 396{
… …
504}; 413};
505 414
506template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 415template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
507class callback7 416class callback7
508{ 417{
509 struct object { }; 418 struct klass; // it is vital that this is never defined
510 419
511 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7); 420 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7);
512 421
513 void *obj; 422 klass *o;
514 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 423 R (klass::*m)(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 424
531public: 425public:
532 template<class O1, class O2> 426 template<class O1, class O2>
533 explicit callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7)) 427 explicit callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
534 { 428 {
535 static proxy<O1,O2> p;
536 obj = reinterpret_cast<void *>(object); 429 o = reinterpret_cast<klass *>(object);
537 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method); 430 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
538 prxy = &p;
539 } 431 }
540 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) :)
541 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 437 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
542 { 438 {
543 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7); 439 return (o->*m) (a1, a2, a3, a4, a5, a6, a7);
544 } 440 }
545 441
546 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 442 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
547 { 443 {
548 return call (a1, a2, a3, a4, a5, a6, a7); 444 return call (a1, a2, a3, a4, a5, a6, a7);
549 } 445 }
550}; 446};
551 447
552template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 448template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
553struct callback_funtype_trait7 449struct callback_funtype_trait7
554{ 450{
… …
571}; 467};
572 468
573template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 469template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
574class callback8 470class callback8
575{ 471{
576 struct object { }; 472 struct klass; // it is vital that this is never defined
577 473
578 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8); 474 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8);
579 475
580 void *obj; 476 klass *o;
581 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8); 477 R (klass::*m)(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 478
598public: 479public:
599 template<class O1, class O2> 480 template<class O1, class O2>
600 explicit callback8 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8)) 481 explicit callback8 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8))
601 { 482 {
602 static proxy<O1,O2> p;
603 obj = reinterpret_cast<void *>(object); 483 o = reinterpret_cast<klass *>(object);
604 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8)>(method); 484 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7, A8)>(method);
605 prxy = &p;
606 } 485 }
607 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) :)
608 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const 491 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
609 { 492 {
610 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8); 493 return (o->*m) (a1, a2, a3, a4, a5, a6, a7, a8);
611 } 494 }
612 495
613 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const 496 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
614 { 497 {
615 return call (a1, a2, a3, a4, a5, a6, a7, a8); 498 return call (a1, a2, a3, a4, a5, a6, a7, a8);
616 } 499 }
617}; 500};
618 501
619template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 502template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
620struct callback_funtype_trait8 503struct callback_funtype_trait8
621{ 504{
… …
638}; 521};
639 522
640template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 523template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
641class callback9 524class callback9
642{ 525{
643 struct object { }; 526 struct klass; // it is vital that this is never defined
644 527
645 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9); 528 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
646 529
647 void *obj; 530 klass *o;
648 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9); 531 R (klass::*m)(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 532
665public: 533public:
666 template<class O1, class O2> 534 template<class O1, class O2>
667 explicit callback9 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) 535 explicit callback9 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
668 { 536 {
669 static proxy<O1,O2> p;
670 obj = reinterpret_cast<void *>(object); 537 o = reinterpret_cast<klass *>(object);
671 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>(method); 538 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>(method);
672 prxy = &p;
673 } 539 }
674 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) :)
675 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const 545 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
676 { 546 {
677 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9); 547 return (o->*m) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
678 } 548 }
679 549
680 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const 550 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
681 { 551 {
682 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9); 552 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
683 } 553 }
684}; 554};
685 555
686template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 556template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
687struct callback_funtype_trait9 557struct callback_funtype_trait9
688{ 558{
… …
705}; 575};
706 576
707template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> 577template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
708class callback10 578class callback10
709{ 579{
710 struct object { }; 580 struct klass; // it is vital that this is never defined
711 581
712 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); 582 typedef R (klass::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
713 583
714 void *obj; 584 klass *o;
715 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); 585 R (klass::*m)(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 586
732public: 587public:
733 template<class O1, class O2> 588 template<class O1, class O2>
734 explicit callback10 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) 589 explicit callback10 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
735 { 590 {
736 static proxy<O1,O2> p;
737 obj = reinterpret_cast<void *>(object); 591 o = reinterpret_cast<klass *>(object);
738 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(method); 592 m = reinterpret_cast<R (klass::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(method);
739 prxy = &p;
740 } 593 }
741 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) :)
742 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const 599 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
743 { 600 {
744 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); 601 return (o->*m) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
745 } 602 }
746 603
747 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const 604 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
748 { 605 {
749 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); 606 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
750 } 607 }
751}; 608};
752 609
753template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> 610template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
754struct callback_funtype_trait10 611struct callback_funtype_trait10
755{ 612{
… …
777{ 634{
778 typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type; 635 typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;
779 636
780 template<class O, class M> 637 template<class O, class M>
781 explicit callback (O object, M method) 638 explicit callback (O object, M method)
782 : base_type (object, method) 639 : base_type (object, method)
783 { 640 {
784 } 641 }
785}; 642};
786 643
787#endif 644#endif

Diff Legend

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