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

Diff Legend

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