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.6 by pcg, Tue Apr 26 00:55:55 2005 UTC vs.
Revision 1.10 by pcg, Wed May 31 00:31:47 2006 UTC

1// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it 1// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
2// 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, RUN callback.pl to regenerate it 3// THIS IS A GENERATED FILE: distribution.
4// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
5// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
6// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
7 4
8/* 5/*
9 callback.h -- C++ callback mechanism 6 callback.h -- C++ callback mechanism
10 Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de> 7 Copyright (C) 2003-2006 Marc Lehmann <pcg@goof.com>
11 8
12 This file is part of GVPE. 9 This file is part of GVPE.
13 10
14 GVPE is free software; you can redistribute it and/or modify 11 GVPE is free software; you can redistribute it and/or modify
15 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
… …
27*/ 24*/
28 25
29#ifndef CALLBACK_H__ 26#ifndef CALLBACK_H__
30#define CALLBACK_H__ 27#define CALLBACK_H__
31 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
32template<class R> 37template<class R>
33class callback0 { 38class callback0
39{
34 struct object { }; 40 struct object { };
41
42 typedef R (object::*ptr_type)();
35 43
36 void *obj; 44 void *obj;
37 R (object::*meth)(); 45 R (object::*meth)();
38 46
39 /* 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 */
40 struct proxy_base { 48 struct proxy_base {
41 virtual R call (void *obj, R (object::*meth)()) = 0; 49 virtual R call (void *obj, R (object::*meth)()) const = 0;
42 }; 50 };
43 template<class O1, class O2> 51 template<class O1, class O2>
44 struct proxy : proxy_base { 52 struct proxy : proxy_base {
45 virtual R call (void *obj, R (object::*meth)()) 53 virtual R call (void *obj, R (object::*meth)()) const
46 { 54 {
47 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth))) 55 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
48 (); 56 ();
49 } 57 }
50 }; 58 };
51 59
52 proxy_base *prxy; 60 proxy_base *prxy;
53 61
54public: 62public:
55 template<class O1, class O2> 63 template<class O1, class O2>
56 callback0 (O1 *object, R (O2::*method)()) 64 explicit callback0 (O1 *object, R (O2::*method)())
57 { 65 {
58 static proxy<O1,O2> p; 66 static proxy<O1,O2> p;
59 obj = reinterpret_cast<void *>(object); 67 obj = reinterpret_cast<void *>(object);
60 meth = reinterpret_cast<R (object::*)()>(method); 68 meth = reinterpret_cast<R (object::*)()>(method);
61 prxy = &p; 69 prxy = &p;
… …
70 { 78 {
71 return call (); 79 return call ();
72 } 80 }
73}; 81};
74 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
75template<class R, class A1> 104template<class R, class A1>
76class callback1 { 105class callback1
106{
77 struct object { }; 107 struct object { };
108
109 typedef R (object::*ptr_type)(A1);
78 110
79 void *obj; 111 void *obj;
80 R (object::*meth)(A1); 112 R (object::*meth)(A1);
81 113
82 /* 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 */
83 struct proxy_base { 115 struct proxy_base {
84 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;
85 }; 117 };
86 template<class O1, class O2> 118 template<class O1, class O2>
87 struct proxy : proxy_base { 119 struct proxy : proxy_base {
88 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) 120 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const
89 { 121 {
90 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth))) 122 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
91 (a1); 123 (a1);
92 } 124 }
93 }; 125 };
94 126
95 proxy_base *prxy; 127 proxy_base *prxy;
96 128
97public: 129public:
98 template<class O1, class O2> 130 template<class O1, class O2>
99 callback1 (O1 *object, R (O2::*method)(A1)) 131 explicit callback1 (O1 *object, R (O2::*method)(A1))
100 { 132 {
101 static proxy<O1,O2> p; 133 static proxy<O1,O2> p;
102 obj = reinterpret_cast<void *>(object); 134 obj = reinterpret_cast<void *>(object);
103 meth = reinterpret_cast<R (object::*)(A1)>(method); 135 meth = reinterpret_cast<R (object::*)(A1)>(method);
104 prxy = &p; 136 prxy = &p;
… …
113 { 145 {
114 return call (a1); 146 return call (a1);
115 } 147 }
116}; 148};
117 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
118template<class R, class A1, class A2> 171template<class R, class A1, class A2>
119class callback2 { 172class callback2
173{
120 struct object { }; 174 struct object { };
175
176 typedef R (object::*ptr_type)(A1, A2);
121 177
122 void *obj; 178 void *obj;
123 R (object::*meth)(A1, A2); 179 R (object::*meth)(A1, A2);
124 180
125 /* 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 */
126 struct proxy_base { 182 struct proxy_base {
127 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;
128 }; 184 };
129 template<class O1, class O2> 185 template<class O1, class O2>
130 struct proxy : proxy_base { 186 struct proxy : proxy_base {
131 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
132 { 188 {
133 ((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)))
134 (a1, a2); 190 (a1, a2);
135 } 191 }
136 }; 192 };
137 193
138 proxy_base *prxy; 194 proxy_base *prxy;
139 195
140public: 196public:
141 template<class O1, class O2> 197 template<class O1, class O2>
142 callback2 (O1 *object, R (O2::*method)(A1, A2)) 198 explicit callback2 (O1 *object, R (O2::*method)(A1, A2))
143 { 199 {
144 static proxy<O1,O2> p; 200 static proxy<O1,O2> p;
145 obj = reinterpret_cast<void *>(object); 201 obj = reinterpret_cast<void *>(object);
146 meth = reinterpret_cast<R (object::*)(A1, A2)>(method); 202 meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
147 prxy = &p; 203 prxy = &p;
… …
156 { 212 {
157 return call (a1, a2); 213 return call (a1, a2);
158 } 214 }
159}; 215};
160 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
161template<class R, class A1, class A2, class A3> 238template<class R, class A1, class A2, class A3>
162class callback3 { 239class callback3
240{
163 struct object { }; 241 struct object { };
242
243 typedef R (object::*ptr_type)(A1, A2, A3);
164 244
165 void *obj; 245 void *obj;
166 R (object::*meth)(A1, A2, A3); 246 R (object::*meth)(A1, A2, A3);
167 247
168 /* 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 */
169 struct proxy_base { 249 struct proxy_base {
170 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;
171 }; 251 };
172 template<class O1, class O2> 252 template<class O1, class O2>
173 struct proxy : proxy_base { 253 struct proxy : proxy_base {
174 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
175 { 255 {
176 ((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)))
177 (a1, a2, a3); 257 (a1, a2, a3);
178 } 258 }
179 }; 259 };
180 260
181 proxy_base *prxy; 261 proxy_base *prxy;
182 262
183public: 263public:
184 template<class O1, class O2> 264 template<class O1, class O2>
185 callback3 (O1 *object, R (O2::*method)(A1, A2, A3)) 265 explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
186 { 266 {
187 static proxy<O1,O2> p; 267 static proxy<O1,O2> p;
188 obj = reinterpret_cast<void *>(object); 268 obj = reinterpret_cast<void *>(object);
189 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method); 269 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
190 prxy = &p; 270 prxy = &p;
… …
199 { 279 {
200 return call (a1, a2, a3); 280 return call (a1, a2, a3);
201 } 281 }
202}; 282};
203 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
204template<class R, class A1, class A2, class A3, class A4> 305template<class R, class A1, class A2, class A3, class A4>
205class callback4 { 306class callback4
307{
206 struct object { }; 308 struct object { };
309
310 typedef R (object::*ptr_type)(A1, A2, A3, A4);
207 311
208 void *obj; 312 void *obj;
209 R (object::*meth)(A1, A2, A3, A4); 313 R (object::*meth)(A1, A2, A3, A4);
210 314
211 /* 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 */
212 struct proxy_base { 316 struct proxy_base {
213 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;
214 }; 318 };
215 template<class O1, class O2> 319 template<class O1, class O2>
216 struct proxy : proxy_base { 320 struct proxy : proxy_base {
217 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
218 { 322 {
219 ((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)))
220 (a1, a2, a3, a4); 324 (a1, a2, a3, a4);
221 } 325 }
222 }; 326 };
223 327
224 proxy_base *prxy; 328 proxy_base *prxy;
225 329
226public: 330public:
227 template<class O1, class O2> 331 template<class O1, class O2>
228 callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4)) 332 explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
229 { 333 {
230 static proxy<O1,O2> p; 334 static proxy<O1,O2> p;
231 obj = reinterpret_cast<void *>(object); 335 obj = reinterpret_cast<void *>(object);
232 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method); 336 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
233 prxy = &p; 337 prxy = &p;
… …
242 { 346 {
243 return call (a1, a2, a3, a4); 347 return call (a1, a2, a3, a4);
244 } 348 }
245}; 349};
246 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
247template<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>
248class callback5 { 373class callback5
374{
249 struct object { }; 375 struct object { };
376
377 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5);
250 378
251 void *obj; 379 void *obj;
252 R (object::*meth)(A1, A2, A3, A4, A5); 380 R (object::*meth)(A1, A2, A3, A4, A5);
253 381
254 /* 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 */
255 struct proxy_base { 383 struct proxy_base {
256 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;
257 }; 385 };
258 template<class O1, class O2> 386 template<class O1, class O2>
259 struct proxy : proxy_base { 387 struct proxy : proxy_base {
260 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
261 { 389 {
262 ((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)))
263 (a1, a2, a3, a4, a5); 391 (a1, a2, a3, a4, a5);
264 } 392 }
265 }; 393 };
266 394
267 proxy_base *prxy; 395 proxy_base *prxy;
268 396
269public: 397public:
270 template<class O1, class O2> 398 template<class O1, class O2>
271 callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5)) 399 explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
272 { 400 {
273 static proxy<O1,O2> p; 401 static proxy<O1,O2> p;
274 obj = reinterpret_cast<void *>(object); 402 obj = reinterpret_cast<void *>(object);
275 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method); 403 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
276 prxy = &p; 404 prxy = &p;
… …
285 { 413 {
286 return call (a1, a2, a3, a4, a5); 414 return call (a1, a2, a3, a4, a5);
287 } 415 }
288}; 416};
289 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
290template<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>
291class callback6 { 440class callback6
441{
292 struct object { }; 442 struct object { };
443
444 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6);
293 445
294 void *obj; 446 void *obj;
295 R (object::*meth)(A1, A2, A3, A4, A5, A6); 447 R (object::*meth)(A1, A2, A3, A4, A5, A6);
296 448
297 /* 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 */
298 struct proxy_base { 450 struct proxy_base {
299 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;
300 }; 452 };
301 template<class O1, class O2> 453 template<class O1, class O2>
302 struct proxy : proxy_base { 454 struct proxy : proxy_base {
303 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
304 { 456 {
305 ((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)))
306 (a1, a2, a3, a4, a5, a6); 458 (a1, a2, a3, a4, a5, a6);
307 } 459 }
308 }; 460 };
309 461
310 proxy_base *prxy; 462 proxy_base *prxy;
311 463
312public: 464public:
313 template<class O1, class O2> 465 template<class O1, class O2>
314 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))
315 { 467 {
316 static proxy<O1,O2> p; 468 static proxy<O1,O2> p;
317 obj = reinterpret_cast<void *>(object); 469 obj = reinterpret_cast<void *>(object);
318 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);
319 prxy = &p; 471 prxy = &p;
… …
328 { 480 {
329 return call (a1, a2, a3, a4, a5, a6); 481 return call (a1, a2, a3, a4, a5, a6);
330 } 482 }
331}; 483};
332 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
333template<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>
334class callback7 { 507class callback7
508{
335 struct object { }; 509 struct object { };
510
511 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7);
336 512
337 void *obj; 513 void *obj;
338 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 514 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
339 515
340 /* 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 */
341 struct proxy_base { 517 struct proxy_base {
342 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;
343 }; 519 };
344 template<class O1, class O2> 520 template<class O1, class O2>
345 struct proxy : proxy_base { 521 struct proxy : proxy_base {
346 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
347 { 523 {
348 ((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)))
349 (a1, a2, a3, a4, a5, a6, a7); 525 (a1, a2, a3, a4, a5, a6, a7);
350 } 526 }
351 }; 527 };
352 528
353 proxy_base *prxy; 529 proxy_base *prxy;
354 530
355public: 531public:
356 template<class O1, class O2> 532 template<class O1, class O2>
357 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))
358 { 534 {
359 static proxy<O1,O2> p; 535 static proxy<O1,O2> p;
360 obj = reinterpret_cast<void *>(object); 536 obj = reinterpret_cast<void *>(object);
361 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);
362 prxy = &p; 538 prxy = &p;
… …
371 { 547 {
372 return call (a1, a2, a3, a4, a5, a6, a7); 548 return call (a1, a2, a3, a4, a5, a6, a7);
373 } 549 }
374}; 550};
375 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
376#endif 787#endif

Diff Legend

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