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.8 by pcg, Tue Dec 27 16:36:16 2005 UTC vs.
Revision 1.10 by pcg, Wed May 31 00:31:47 2006 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-2005 Marc Lehmann <pcg@goof.com> 7 Copyright (C) 2003-2006 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
30
31template<class signature>
32struct callback_funtype_trait;
33
34template<int arity, class signature>
35struct callback_get_impl;
36
29template<class R> 37template<class R>
30class callback0 { 38class callback0
39{
31 struct object { }; 40 struct object { };
41
42 typedef R (object::*ptr_type)();
32 43
33 void *obj; 44 void *obj;
34 R (object::*meth)(); 45 R (object::*meth)();
35 46
36 /* a proxy is a kind of recipe on how to call a specific class method */ 47 /* a proxy is a kind of recipe on how to call a specific class method */
37 struct proxy_base { 48 struct proxy_base {
38 virtual R call (void *obj, R (object::*meth)()) = 0; 49 virtual R call (void *obj, R (object::*meth)()) const = 0;
39 }; 50 };
40 template<class O1, class O2> 51 template<class O1, class O2>
41 struct proxy : proxy_base { 52 struct proxy : proxy_base {
42 virtual R call (void *obj, R (object::*meth)()) 53 virtual R call (void *obj, R (object::*meth)()) const
43 { 54 {
44 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth))) 55 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
45 (); 56 ();
46 } 57 }
47 }; 58 };
48 59
49 proxy_base *prxy; 60 proxy_base *prxy;
50 61
51public: 62public:
52 template<class O1, class O2> 63 template<class O1, class O2>
53 callback0 (O1 *object, R (O2::*method)()) 64 explicit callback0 (O1 *object, R (O2::*method)())
54 { 65 {
55 static proxy<O1,O2> p; 66 static proxy<O1,O2> p;
56 obj = reinterpret_cast<void *>(object); 67 obj = reinterpret_cast<void *>(object);
57 meth = reinterpret_cast<R (object::*)()>(method); 68 meth = reinterpret_cast<R (object::*)()>(method);
58 prxy = &p; 69 prxy = &p;
… …
67 { 78 {
68 return call (); 79 return call ();
69 } 80 }
70}; 81};
71 82
83template<class R>
84struct callback_funtype_trait0
85{
86 static const int arity = 0;
87 typedef R type (void);
88 typedef R result_type;
89
90};
91
92template<class R>
93struct callback_funtype_trait<R ()> : callback_funtype_trait0<R>
94{
95};
96
97template<class signature>
98struct callback_get_impl<0, signature>
99{
100 typedef callback_funtype_trait<signature> T;
101 typedef callback0<typename T::result_type> type;
102};
103
72template<class R, class A1> 104template<class R, class A1>
73class callback1 { 105class callback1
106{
74 struct object { }; 107 struct object { };
108
109 typedef R (object::*ptr_type)(A1);
75 110
76 void *obj; 111 void *obj;
77 R (object::*meth)(A1); 112 R (object::*meth)(A1);
78 113
79 /* a proxy is a kind of recipe on how to call a specific class method */ 114 /* a proxy is a kind of recipe on how to call a specific class method */
80 struct proxy_base { 115 struct proxy_base {
81 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0; 116 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const = 0;
82 }; 117 };
83 template<class O1, class O2> 118 template<class O1, class O2>
84 struct proxy : proxy_base { 119 struct proxy : proxy_base {
85 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) 120 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const
86 { 121 {
87 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth))) 122 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
88 (a1); 123 (a1);
89 } 124 }
90 }; 125 };
91 126
92 proxy_base *prxy; 127 proxy_base *prxy;
93 128
94public: 129public:
95 template<class O1, class O2> 130 template<class O1, class O2>
96 callback1 (O1 *object, R (O2::*method)(A1)) 131 explicit callback1 (O1 *object, R (O2::*method)(A1))
97 { 132 {
98 static proxy<O1,O2> p; 133 static proxy<O1,O2> p;
99 obj = reinterpret_cast<void *>(object); 134 obj = reinterpret_cast<void *>(object);
100 meth = reinterpret_cast<R (object::*)(A1)>(method); 135 meth = reinterpret_cast<R (object::*)(A1)>(method);
101 prxy = &p; 136 prxy = &p;
… …
110 { 145 {
111 return call (a1); 146 return call (a1);
112 } 147 }
113}; 148};
114 149
150template<class R, class A1>
151struct 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
159template<class R, class A1>
160struct callback_funtype_trait<R (A1)> : callback_funtype_trait1<R, A1>
161{
162};
163
164template<class signature>
165struct 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
115template<class R, class A1, class A2> 171template<class R, class A1, class A2>
116class callback2 { 172class callback2
173{
117 struct object { }; 174 struct object { };
175
176 typedef R (object::*ptr_type)(A1, A2);
118 177
119 void *obj; 178 void *obj;
120 R (object::*meth)(A1, A2); 179 R (object::*meth)(A1, A2);
121 180
122 /* a proxy is a kind of recipe on how to call a specific class method */ 181 /* a proxy is a kind of recipe on how to call a specific class method */
123 struct proxy_base { 182 struct proxy_base {
124 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0; 183 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const = 0;
125 }; 184 };
126 template<class O1, class O2> 185 template<class O1, class O2>
127 struct proxy : proxy_base { 186 struct proxy : proxy_base {
128 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) 187 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const
129 { 188 {
130 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth))) 189 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
131 (a1, a2); 190 (a1, a2);
132 } 191 }
133 }; 192 };
134 193
135 proxy_base *prxy; 194 proxy_base *prxy;
136 195
137public: 196public:
138 template<class O1, class O2> 197 template<class O1, class O2>
139 callback2 (O1 *object, R (O2::*method)(A1, A2)) 198 explicit callback2 (O1 *object, R (O2::*method)(A1, A2))
140 { 199 {
141 static proxy<O1,O2> p; 200 static proxy<O1,O2> p;
142 obj = reinterpret_cast<void *>(object); 201 obj = reinterpret_cast<void *>(object);
143 meth = reinterpret_cast<R (object::*)(A1, A2)>(method); 202 meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
144 prxy = &p; 203 prxy = &p;
… …
153 { 212 {
154 return call (a1, a2); 213 return call (a1, a2);
155 } 214 }
156}; 215};
157 216
217template<class R, class A1, class A2>
218struct 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
226template<class R, class A1, class A2>
227struct callback_funtype_trait<R (A1, A2)> : callback_funtype_trait2<R, A1, A2>
228{
229};
230
231template<class signature>
232struct 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
158template<class R, class A1, class A2, class A3> 238template<class R, class A1, class A2, class A3>
159class callback3 { 239class callback3
240{
160 struct object { }; 241 struct object { };
242
243 typedef R (object::*ptr_type)(A1, A2, A3);
161 244
162 void *obj; 245 void *obj;
163 R (object::*meth)(A1, A2, A3); 246 R (object::*meth)(A1, A2, A3);
164 247
165 /* a proxy is a kind of recipe on how to call a specific class method */ 248 /* a proxy is a kind of recipe on how to call a specific class method */
166 struct proxy_base { 249 struct proxy_base {
167 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0; 250 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const = 0;
168 }; 251 };
169 template<class O1, class O2> 252 template<class O1, class O2>
170 struct proxy : proxy_base { 253 struct proxy : proxy_base {
171 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) 254 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const
172 { 255 {
173 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth))) 256 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
174 (a1, a2, a3); 257 (a1, a2, a3);
175 } 258 }
176 }; 259 };
177 260
178 proxy_base *prxy; 261 proxy_base *prxy;
179 262
180public: 263public:
181 template<class O1, class O2> 264 template<class O1, class O2>
182 callback3 (O1 *object, R (O2::*method)(A1, A2, A3)) 265 explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
183 { 266 {
184 static proxy<O1,O2> p; 267 static proxy<O1,O2> p;
185 obj = reinterpret_cast<void *>(object); 268 obj = reinterpret_cast<void *>(object);
186 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method); 269 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
187 prxy = &p; 270 prxy = &p;
… …
196 { 279 {
197 return call (a1, a2, a3); 280 return call (a1, a2, a3);
198 } 281 }
199}; 282};
200 283
284template<class R, class A1, class A2, class A3>
285struct 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
293template<class R, class A1, class A2, class A3>
294struct callback_funtype_trait<R (A1, A2, A3)> : callback_funtype_trait3<R, A1, A2, A3>
295{
296};
297
298template<class signature>
299struct 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
201template<class R, class A1, class A2, class A3, class A4> 305template<class R, class A1, class A2, class A3, class A4>
202class callback4 { 306class callback4
307{
203 struct object { }; 308 struct object { };
309
310 typedef R (object::*ptr_type)(A1, A2, A3, A4);
204 311
205 void *obj; 312 void *obj;
206 R (object::*meth)(A1, A2, A3, A4); 313 R (object::*meth)(A1, A2, A3, A4);
207 314
208 /* a proxy is a kind of recipe on how to call a specific class method */ 315 /* a proxy is a kind of recipe on how to call a specific class method */
209 struct proxy_base { 316 struct proxy_base {
210 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0; 317 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const = 0;
211 }; 318 };
212 template<class O1, class O2> 319 template<class O1, class O2>
213 struct proxy : proxy_base { 320 struct proxy : proxy_base {
214 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) 321 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const
215 { 322 {
216 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth))) 323 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
217 (a1, a2, a3, a4); 324 (a1, a2, a3, a4);
218 } 325 }
219 }; 326 };
220 327
221 proxy_base *prxy; 328 proxy_base *prxy;
222 329
223public: 330public:
224 template<class O1, class O2> 331 template<class O1, class O2>
225 callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4)) 332 explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
226 { 333 {
227 static proxy<O1,O2> p; 334 static proxy<O1,O2> p;
228 obj = reinterpret_cast<void *>(object); 335 obj = reinterpret_cast<void *>(object);
229 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method); 336 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
230 prxy = &p; 337 prxy = &p;
… …
239 { 346 {
240 return call (a1, a2, a3, a4); 347 return call (a1, a2, a3, a4);
241 } 348 }
242}; 349};
243 350
351template<class R, class A1, class A2, class A3, class A4>
352struct 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
360template<class R, class A1, class A2, class A3, class A4>
361struct callback_funtype_trait<R (A1, A2, A3, A4)> : callback_funtype_trait4<R, A1, A2, A3, A4>
362{
363};
364
365template<class signature>
366struct 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
244template<class R, class A1, class A2, class A3, class A4, class A5> 372template<class R, class A1, class A2, class A3, class A4, class A5>
245class callback5 { 373class callback5
374{
246 struct object { }; 375 struct object { };
376
377 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5);
247 378
248 void *obj; 379 void *obj;
249 R (object::*meth)(A1, A2, A3, A4, A5); 380 R (object::*meth)(A1, A2, A3, A4, A5);
250 381
251 /* a proxy is a kind of recipe on how to call a specific class method */ 382 /* a proxy is a kind of recipe on how to call a specific class method */
252 struct proxy_base { 383 struct proxy_base {
253 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0; 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;
254 }; 385 };
255 template<class O1, class O2> 386 template<class O1, class O2>
256 struct proxy : proxy_base { 387 struct proxy : proxy_base {
257 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) 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
258 { 389 {
259 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth))) 390 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
260 (a1, a2, a3, a4, a5); 391 (a1, a2, a3, a4, a5);
261 } 392 }
262 }; 393 };
263 394
264 proxy_base *prxy; 395 proxy_base *prxy;
265 396
266public: 397public:
267 template<class O1, class O2> 398 template<class O1, class O2>
268 callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5)) 399 explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
269 { 400 {
270 static proxy<O1,O2> p; 401 static proxy<O1,O2> p;
271 obj = reinterpret_cast<void *>(object); 402 obj = reinterpret_cast<void *>(object);
272 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method); 403 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
273 prxy = &p; 404 prxy = &p;
… …
282 { 413 {
283 return call (a1, a2, a3, a4, a5); 414 return call (a1, a2, a3, a4, a5);
284 } 415 }
285}; 416};
286 417
418template<class R, class A1, class A2, class A3, class A4, class A5>
419struct 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
427template<class R, class A1, class A2, class A3, class A4, class A5>
428struct callback_funtype_trait<R (A1, A2, A3, A4, A5)> : callback_funtype_trait5<R, A1, A2, A3, A4, A5>
429{
430};
431
432template<class signature>
433struct 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
287template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 439template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
288class callback6 { 440class callback6
441{
289 struct object { }; 442 struct object { };
443
444 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6);
290 445
291 void *obj; 446 void *obj;
292 R (object::*meth)(A1, A2, A3, A4, A5, A6); 447 R (object::*meth)(A1, A2, A3, A4, A5, A6);
293 448
294 /* a proxy is a kind of recipe on how to call a specific class method */ 449 /* a proxy is a kind of recipe on how to call a specific class method */
295 struct proxy_base { 450 struct proxy_base {
296 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) = 0; 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;
297 }; 452 };
298 template<class O1, class O2> 453 template<class O1, class O2>
299 struct proxy : proxy_base { 454 struct proxy : proxy_base {
300 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) 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
301 { 456 {
302 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth))) 457 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
303 (a1, a2, a3, a4, a5, a6); 458 (a1, a2, a3, a4, a5, a6);
304 } 459 }
305 }; 460 };
306 461
307 proxy_base *prxy; 462 proxy_base *prxy;
308 463
309public: 464public:
310 template<class O1, class O2> 465 template<class O1, class O2>
311 callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6)) 466 explicit callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
312 { 467 {
313 static proxy<O1,O2> p; 468 static proxy<O1,O2> p;
314 obj = reinterpret_cast<void *>(object); 469 obj = reinterpret_cast<void *>(object);
315 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method); 470 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
316 prxy = &p; 471 prxy = &p;
… …
325 { 480 {
326 return call (a1, a2, a3, a4, a5, a6); 481 return call (a1, a2, a3, a4, a5, a6);
327 } 482 }
328}; 483};
329 484
485template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
486struct 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
494template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
495struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6)> : callback_funtype_trait6<R, A1, A2, A3, A4, A5, A6>
496{
497};
498
499template<class signature>
500struct 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
330template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 506template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
331class callback7 { 507class callback7
508{
332 struct object { }; 509 struct object { };
510
511 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7);
333 512
334 void *obj; 513 void *obj;
335 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 514 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
336 515
337 /* a proxy is a kind of recipe on how to call a specific class method */ 516 /* a proxy is a kind of recipe on how to call a specific class method */
338 struct proxy_base { 517 struct proxy_base {
339 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) = 0; 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;
340 }; 519 };
341 template<class O1, class O2> 520 template<class O1, class O2>
342 struct proxy : proxy_base { 521 struct proxy : proxy_base {
343 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) 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
344 { 523 {
345 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth))) 524 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
346 (a1, a2, a3, a4, a5, a6, a7); 525 (a1, a2, a3, a4, a5, a6, a7);
347 } 526 }
348 }; 527 };
349 528
350 proxy_base *prxy; 529 proxy_base *prxy;
351 530
352public: 531public:
353 template<class O1, class O2> 532 template<class O1, class O2>
354 callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7)) 533 explicit callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
355 { 534 {
356 static proxy<O1,O2> p; 535 static proxy<O1,O2> p;
357 obj = reinterpret_cast<void *>(object); 536 obj = reinterpret_cast<void *>(object);
358 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method); 537 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
359 prxy = &p; 538 prxy = &p;
… …
368 { 547 {
369 return call (a1, a2, a3, a4, a5, a6, a7); 548 return call (a1, a2, a3, a4, a5, a6, a7);
370 } 549 }
371}; 550};
372 551
552template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
553struct 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
561template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
562struct 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
566template<class signature>
567struct 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
573template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
574class 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
598public:
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
619template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
620struct 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
628template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
629struct 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
633template<class signature>
634struct 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
640template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
641class 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
665public:
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
686template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
687struct 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
695template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
696struct 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
700template<class signature>
701struct 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
707template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
708class 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
732public:
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
753template<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
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
762template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
763struct 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
767template<class signature>
768struct 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
775template<class signature>
776struct 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
373#endif 787#endif

Diff Legend

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