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.2 by pcg, Wed Apr 2 05:14:59 2003 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
7 Copyright (C) 2003-2006 Marc Lehmann <pcg@goof.com>
10 8
9 This file is part of GVPE.
10
11 This program 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
13 the Free Software Foundation; either version 2 of the License, or 13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version. 14 (at your option) any later version.
15 15
16 This program is distributed in the hope that it will be useful, 16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details. 19 GNU General Public License for more details.
20 20
21 You should have received a copy of the GNU General Public License 21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software 22 along with gvpe; if not, write to the Free Software
23 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24*/ 24*/
25 25
26#ifndef VPE_CALLBACK_H__ 26#ifndef CALLBACK_H__
27#define VPE_CALLBACK_H__ 27#define CALLBACK_H__
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;
28 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 ((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 ((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 ((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 ((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 ((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 ((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 ((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 ((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