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

Comparing rxvt-unicode/src/callback.h (file contents):
Revision 1.8 by root, Wed May 31 00:32:56 2006 UTC vs.
Revision 1.14 by root, Thu May 22 18:54:32 2014 UTC

… …
2// THIS IS A GENERATED FILE: callback.pl is part of the GVPE 2// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
3// THIS IS A GENERATED FILE: distribution. 3// THIS IS A GENERATED FILE: distribution.
4 4
5/* 5/*
6 callback.h -- C++ callback mechanism 6 callback.h -- C++ callback mechanism
7 Copyright (C) 2003-2006 Marc Lehmann <pcg@goof.com> 7 Copyright (C) 2003-2007 Marc Lehmann <schmorp@schmorp.de>
8 8
9 This file is part of GVPE. 9 This file is part of GVPE.
10 10
11 GVPE is free software; you can redistribute it and/or modify 11 GVPE is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by 12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or 13 the Free Software Foundation; either version 3 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
… …
24*/ 24*/
25 25
26#ifndef CALLBACK_H__ 26#ifndef CALLBACK_H__
27#define CALLBACK_H__ 27#define CALLBACK_H__
28 28
29#define CALLBACK_H_VERSION 2 29#define CALLBACK_H_VERSION 3
30 30
31template<class signature> 31template<typename signature>
32struct callback_funtype_trait;
33
34template<int arity, class signature>
35struct callback_get_impl; 32struct callback;
36 33
37template<class R> 34template<class R>
38class callback0 35struct callback<R ()>
39{ 36{
40 struct object { }; 37 typedef R (*ptr_type)(void *self);
41 38
42 typedef R (object::*ptr_type)(); 39 template<class K, R (K::*method)()>
43 40 void set (K *object)
44 void *obj; 41 {
45 R (object::*meth)(); 42 self = object;
46 43 func = thunk<K, method>;
47 /* a proxy is a kind of recipe on how to call a specific class method */
48 struct proxy_base {
49 virtual R call (void *obj, R (object::*meth)()) const = 0;
50 }; 44 }
51 template<class O1, class O2>
52 struct proxy : proxy_base {
53 virtual R call (void *obj, R (object::*meth)()) const
54 {
55 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
56 ();
57 }
58 };
59 45
60 proxy_base *prxy;
61
62public:
63 template<class O1, class O2>
64 explicit callback0 (O1 *object, R (O2::*method)())
65 {
66 static proxy<O1,O2> p;
67 obj = reinterpret_cast<void *>(object);
68 meth = reinterpret_cast<R (object::*)()>(method);
69 prxy = &p;
70 }
71
72 R call() const 46 R call () const
73 { 47 {
74 return prxy->call (obj, meth); 48 return func (self);
75 } 49 }
76 50
77 R operator ()() const 51 R operator ()() const
78 { 52 {
79 return call (); 53 return call ();
80 }
81};
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 54 }
90};
91 55
92template<class R> 56private:
93struct callback_funtype_trait<R ()> : callback_funtype_trait0<R>
94{
95};
96 57
97template<class signature> 58 void *self;
98struct callback_get_impl<0, signature> 59 ptr_type func;
99{ 60
100 typedef callback_funtype_trait<signature> T; 61 template<class klass, R (klass::*method)()>
101 typedef callback0<typename T::result_type> type; 62 static R thunk (void *self)
63 {
64 klass *obj = static_cast<klass *>(self);
65 return (obj->*method) ();
66 }
102}; 67};
103 68
104template<class R, class A1> 69template<class R, class A1>
105class callback1 70struct callback<R (A1)>
106{ 71{
107 struct object { }; 72 typedef R (*ptr_type)(void *self, A1);
108 73
109 typedef R (object::*ptr_type)(A1); 74 template<class K, R (K::*method)(A1)>
110 75 void set (K *object)
111 void *obj; 76 {
112 R (object::*meth)(A1); 77 self = object;
113 78 func = thunk<K, method>;
114 /* a proxy is a kind of recipe on how to call a specific class method */
115 struct proxy_base {
116 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const = 0;
117 }; 79 }
118 template<class O1, class O2>
119 struct proxy : proxy_base {
120 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const
121 {
122 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
123 (a1);
124 }
125 };
126 80
127 proxy_base *prxy;
128
129public:
130 template<class O1, class O2>
131 explicit callback1 (O1 *object, R (O2::*method)(A1))
132 {
133 static proxy<O1,O2> p;
134 obj = reinterpret_cast<void *>(object);
135 meth = reinterpret_cast<R (object::*)(A1)>(method);
136 prxy = &p;
137 }
138
139 R call(A1 a1) const 81 R call (A1 a1) const
140 { 82 {
141 return prxy->call (obj, meth, a1); 83 return func (self, a1);
142 } 84 }
143 85
144 R operator ()(A1 a1) const 86 R operator ()(A1 a1) const
145 { 87 {
146 return call (a1); 88 return call (a1);
147 } 89 }
148};
149 90
150template<class R, class A1> 91private:
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 92
159template<class R, class A1> 93 void *self;
160struct callback_funtype_trait<R (A1)> : callback_funtype_trait1<R, A1> 94 ptr_type func;
161{
162};
163 95
164template<class signature> 96 template<class klass, R (klass::*method)(A1)>
165struct callback_get_impl<1, signature> 97 static R thunk (void *self, A1 a1)
166{ 98 {
167 typedef callback_funtype_trait<signature> T; 99 klass *obj = static_cast<klass *>(self);
168 typedef callback1<typename T::result_type, typename T::arg1_type> type; 100 return (obj->*method) (a1);
101 }
169}; 102};
170 103
171template<class R, class A1, class A2> 104template<class R, class A1, class A2>
172class callback2 105struct callback<R (A1, A2)>
173{ 106{
174 struct object { };
175
176 typedef R (object::*ptr_type)(A1, A2); 107 typedef R (*ptr_type)(void *self, A1, A2);
177 108
178 void *obj; 109 template<class K, R (K::*method)(A1, A2)>
179 R (object::*meth)(A1, A2); 110 void set (K *object)
180 111 {
181 /* a proxy is a kind of recipe on how to call a specific class method */ 112 self = object;
182 struct proxy_base { 113 func = thunk<K, method>;
183 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const = 0;
184 }; 114 }
185 template<class O1, class O2>
186 struct proxy : proxy_base {
187 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const
188 {
189 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
190 (a1, a2);
191 }
192 };
193 115
194 proxy_base *prxy;
195
196public:
197 template<class O1, class O2>
198 explicit callback2 (O1 *object, R (O2::*method)(A1, A2))
199 {
200 static proxy<O1,O2> p;
201 obj = reinterpret_cast<void *>(object);
202 meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
203 prxy = &p;
204 }
205
206 R call(A1 a1, A2 a2) const 116 R call (A1 a1, A2 a2) const
207 { 117 {
208 return prxy->call (obj, meth, a1, a2); 118 return func (self, a1, a2);
209 } 119 }
210 120
211 R operator ()(A1 a1, A2 a2) const 121 R operator ()(A1 a1, A2 a2) const
212 { 122 {
213 return call (a1, a2); 123 return call (a1, a2);
214 } 124 }
215};
216 125
217template<class R, class A1, class A2> 126private:
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 127
226template<class R, class A1, class A2> 128 void *self;
227struct callback_funtype_trait<R (A1, A2)> : callback_funtype_trait2<R, A1, A2> 129 ptr_type func;
228{
229};
230 130
231template<class signature> 131 template<class klass, R (klass::*method)(A1, A2)>
232struct callback_get_impl<2, signature> 132 static R thunk (void *self, A1 a1, A2 a2)
233{ 133 {
234 typedef callback_funtype_trait<signature> T; 134 klass *obj = static_cast<klass *>(self);
235 typedef callback2<typename T::result_type, typename T::arg1_type, typename T::arg2_type> type; 135 return (obj->*method) (a1, a2);
136 }
236}; 137};
237 138
238template<class R, class A1, class A2, class A3> 139template<class R, class A1, class A2, class A3>
239class callback3 140struct callback<R (A1, A2, A3)>
240{ 141{
241 struct object { };
242
243 typedef R (object::*ptr_type)(A1, A2, A3); 142 typedef R (*ptr_type)(void *self, A1, A2, A3);
244 143
245 void *obj; 144 template<class K, R (K::*method)(A1, A2, A3)>
246 R (object::*meth)(A1, A2, A3); 145 void set (K *object)
247 146 {
248 /* a proxy is a kind of recipe on how to call a specific class method */ 147 self = object;
249 struct proxy_base { 148 func = thunk<K, method>;
250 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const = 0;
251 }; 149 }
252 template<class O1, class O2>
253 struct proxy : proxy_base {
254 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const
255 {
256 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
257 (a1, a2, a3);
258 }
259 };
260 150
261 proxy_base *prxy;
262
263public:
264 template<class O1, class O2>
265 explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
266 {
267 static proxy<O1,O2> p;
268 obj = reinterpret_cast<void *>(object);
269 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
270 prxy = &p;
271 }
272
273 R call(A1 a1, A2 a2, A3 a3) const 151 R call (A1 a1, A2 a2, A3 a3) const
274 { 152 {
275 return prxy->call (obj, meth, a1, a2, a3); 153 return func (self, a1, a2, a3);
276 } 154 }
277 155
278 R operator ()(A1 a1, A2 a2, A3 a3) const 156 R operator ()(A1 a1, A2 a2, A3 a3) const
279 { 157 {
280 return call (a1, a2, a3); 158 return call (a1, a2, a3);
281 } 159 }
282};
283 160
284template<class R, class A1, class A2, class A3> 161private:
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 162
293template<class R, class A1, class A2, class A3> 163 void *self;
294struct callback_funtype_trait<R (A1, A2, A3)> : callback_funtype_trait3<R, A1, A2, A3> 164 ptr_type func;
295{
296};
297 165
298template<class signature> 166 template<class klass, R (klass::*method)(A1, A2, A3)>
299struct callback_get_impl<3, signature> 167 static R thunk (void *self, A1 a1, A2 a2, A3 a3)
300{ 168 {
301 typedef callback_funtype_trait<signature> T; 169 klass *obj = static_cast<klass *>(self);
302 typedef callback3<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type> type; 170 return (obj->*method) (a1, a2, a3);
171 }
303}; 172};
304 173
305template<class R, class A1, class A2, class A3, class A4> 174template<class R, class A1, class A2, class A3, class A4>
306class callback4 175struct callback<R (A1, A2, A3, A4)>
307{ 176{
308 struct object { };
309
310 typedef R (object::*ptr_type)(A1, A2, A3, A4); 177 typedef R (*ptr_type)(void *self, A1, A2, A3, A4);
311 178
312 void *obj; 179 template<class K, R (K::*method)(A1, A2, A3, A4)>
313 R (object::*meth)(A1, A2, A3, A4); 180 void set (K *object)
314 181 {
315 /* a proxy is a kind of recipe on how to call a specific class method */ 182 self = object;
316 struct proxy_base { 183 func = thunk<K, method>;
317 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const = 0;
318 }; 184 }
319 template<class O1, class O2>
320 struct proxy : proxy_base {
321 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const
322 {
323 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
324 (a1, a2, a3, a4);
325 }
326 };
327 185
328 proxy_base *prxy;
329
330public:
331 template<class O1, class O2>
332 explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
333 {
334 static proxy<O1,O2> p;
335 obj = reinterpret_cast<void *>(object);
336 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
337 prxy = &p;
338 }
339
340 R call(A1 a1, A2 a2, A3 a3, A4 a4) const 186 R call (A1 a1, A2 a2, A3 a3, A4 a4) const
341 { 187 {
342 return prxy->call (obj, meth, a1, a2, a3, a4); 188 return func (self, a1, a2, a3, a4);
343 } 189 }
344 190
345 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const 191 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
346 { 192 {
347 return call (a1, a2, a3, a4); 193 return call (a1, a2, a3, a4);
348 } 194 }
349};
350 195
351template<class R, class A1, class A2, class A3, class A4> 196private:
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 197
360template<class R, class A1, class A2, class A3, class A4> 198 void *self;
361struct callback_funtype_trait<R (A1, A2, A3, A4)> : callback_funtype_trait4<R, A1, A2, A3, A4> 199 ptr_type func;
362{
363};
364 200
365template<class signature> 201 template<class klass, R (klass::*method)(A1, A2, A3, A4)>
366struct callback_get_impl<4, signature> 202 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)
367{ 203 {
368 typedef callback_funtype_trait<signature> T; 204 klass *obj = static_cast<klass *>(self);
369 typedef callback4<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type> type; 205 return (obj->*method) (a1, a2, a3, a4);
206 }
370}; 207};
371 208
372template<class R, class A1, class A2, class A3, class A4, class A5> 209template<class R, class A1, class A2, class A3, class A4, class A5>
373class callback5 210struct callback<R (A1, A2, A3, A4, A5)>
374{ 211{
375 struct object { };
376
377 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5); 212 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5);
378 213
379 void *obj; 214 template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
380 R (object::*meth)(A1, A2, A3, A4, A5); 215 void set (K *object)
381 216 {
382 /* a proxy is a kind of recipe on how to call a specific class method */ 217 self = object;
383 struct proxy_base { 218 func = thunk<K, method>;
384 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const = 0;
385 }; 219 }
386 template<class O1, class O2>
387 struct proxy : proxy_base {
388 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
389 {
390 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
391 (a1, a2, a3, a4, a5);
392 }
393 };
394 220
395 proxy_base *prxy;
396
397public:
398 template<class O1, class O2>
399 explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
400 {
401 static proxy<O1,O2> p;
402 obj = reinterpret_cast<void *>(object);
403 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
404 prxy = &p;
405 }
406
407 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 221 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
408 { 222 {
409 return prxy->call (obj, meth, a1, a2, a3, a4, a5); 223 return func (self, a1, a2, a3, a4, a5);
410 } 224 }
411 225
412 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 226 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
413 { 227 {
414 return call (a1, a2, a3, a4, a5); 228 return call (a1, a2, a3, a4, a5);
415 } 229 }
416};
417 230
418template<class R, class A1, class A2, class A3, class A4, class A5> 231private:
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 232
427template<class R, class A1, class A2, class A3, class A4, class A5> 233 void *self;
428struct callback_funtype_trait<R (A1, A2, A3, A4, A5)> : callback_funtype_trait5<R, A1, A2, A3, A4, A5> 234 ptr_type func;
429{
430};
431 235
432template<class signature> 236 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>
433struct callback_get_impl<5, signature> 237 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
434{ 238 {
435 typedef callback_funtype_trait<signature> T; 239 klass *obj = static_cast<klass *>(self);
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; 240 return (obj->*method) (a1, a2, a3, a4, a5);
241 }
437}; 242};
438 243
439template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 244template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
440class callback6 245struct callback<R (A1, A2, A3, A4, A5, A6)>
441{ 246{
442 struct object { };
443
444 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6); 247 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6);
445 248
446 void *obj; 249 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
447 R (object::*meth)(A1, A2, A3, A4, A5, A6); 250 void set (K *object)
448 251 {
449 /* a proxy is a kind of recipe on how to call a specific class method */ 252 self = object;
450 struct proxy_base { 253 func = thunk<K, method>;
451 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const = 0;
452 }; 254 }
453 template<class O1, class O2>
454 struct proxy : proxy_base {
455 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
456 {
457 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
458 (a1, a2, a3, a4, a5, a6);
459 }
460 };
461 255
462 proxy_base *prxy;
463
464public:
465 template<class O1, class O2>
466 explicit callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
467 {
468 static proxy<O1,O2> p;
469 obj = reinterpret_cast<void *>(object);
470 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
471 prxy = &p;
472 }
473
474 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 256 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
475 { 257 {
476 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6); 258 return func (self, a1, a2, a3, a4, a5, a6);
477 } 259 }
478 260
479 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 261 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
480 { 262 {
481 return call (a1, a2, a3, a4, a5, a6); 263 return call (a1, a2, a3, a4, a5, a6);
482 } 264 }
483};
484 265
485template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 266private:
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 267
494template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 268 void *self;
495struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6)> : callback_funtype_trait6<R, A1, A2, A3, A4, A5, A6> 269 ptr_type func;
496{
497};
498 270
499template<class signature> 271 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>
500struct callback_get_impl<6, signature> 272 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
501{ 273 {
502 typedef callback_funtype_trait<signature> T; 274 klass *obj = static_cast<klass *>(self);
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; 275 return (obj->*method) (a1, a2, a3, a4, a5, a6);
276 }
504}; 277};
505 278
506template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 279template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
507class callback7 280struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
508{ 281{
509 struct object { };
510
511 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7); 282 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7);
512 283
513 void *obj; 284 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
514 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 285 void set (K *object)
515 286 {
516 /* a proxy is a kind of recipe on how to call a specific class method */ 287 self = object;
517 struct proxy_base { 288 func = thunk<K, method>;
518 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const = 0;
519 }; 289 }
520 template<class O1, class O2>
521 struct proxy : proxy_base {
522 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
523 {
524 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
525 (a1, a2, a3, a4, a5, a6, a7);
526 }
527 };
528 290
529 proxy_base *prxy;
530
531public:
532 template<class O1, class O2>
533 explicit callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
534 {
535 static proxy<O1,O2> p;
536 obj = reinterpret_cast<void *>(object);
537 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
538 prxy = &p;
539 }
540
541 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 291 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
542 { 292 {
543 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7); 293 return func (self, a1, a2, a3, a4, a5, a6, a7);
544 } 294 }
545 295
546 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 296 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
547 { 297 {
548 return call (a1, a2, a3, a4, a5, a6, a7); 298 return call (a1, a2, a3, a4, a5, a6, a7);
549 } 299 }
550};
551 300
552template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 301private:
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 302
561template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 303 void *self;
562struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7)> : callback_funtype_trait7<R, A1, A2, A3, A4, A5, A6, A7> 304 ptr_type func;
563{
564};
565 305
566template<class signature> 306 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>
567struct callback_get_impl<7, signature> 307 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
568{ 308 {
569 typedef callback_funtype_trait<signature> T; 309 klass *obj = static_cast<klass *>(self);
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; 310 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);
311 }
571}; 312};
572 313
573template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 314template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
574class callback8 315struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>
575{ 316{
576 struct object { };
577
578 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8); 317 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8);
579 318
580 void *obj;
581 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8); 319 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
582 320 void set (K *object)
583 /* a proxy is a kind of recipe on how to call a specific class method */ 321 {
584 struct proxy_base { 322 self = object;
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; 323 func = thunk<K, method>;
586 }; 324 }
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 325
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 326 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
609 { 327 {
610 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8); 328 return func (self, a1, a2, a3, a4, a5, a6, a7, a8);
611 } 329 }
612 330
613 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const 331 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
614 { 332 {
615 return call (a1, a2, a3, a4, a5, a6, a7, a8); 333 return call (a1, a2, a3, a4, a5, a6, a7, a8);
616 } 334 }
617};
618 335
619template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 336private:
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 337
628template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 338 void *self;
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> 339 ptr_type func;
630{
631};
632 340
633template<class signature> 341 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
634struct callback_get_impl<8, signature> 342 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
635{ 343 {
636 typedef callback_funtype_trait<signature> T; 344 klass *obj = static_cast<klass *>(self);
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; 345 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);
346 }
638}; 347};
639 348
640template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 349template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
641class callback9 350struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
642{ 351{
643 struct object { };
644
645 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9); 352 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9);
646 353
647 void *obj;
648 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9); 354 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
649 355 void set (K *object)
650 /* a proxy is a kind of recipe on how to call a specific class method */ 356 {
651 struct proxy_base { 357 self = object;
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; 358 func = thunk<K, method>;
653 }; 359 }
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 360
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 361 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
676 { 362 {
677 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9); 363 return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9);
678 } 364 }
679 365
680 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const 366 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
681 { 367 {
682 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9); 368 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
683 } 369 }
684};
685 370
686template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 371private:
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 372
695template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 373 void *self;
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> 374 ptr_type func;
697{
698};
699 375
700template<class signature> 376 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
701struct callback_get_impl<9, signature> 377 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
702{ 378 {
703 typedef callback_funtype_trait<signature> T; 379 klass *obj = static_cast<klass *>(self);
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; 380 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
381 }
705}; 382};
706 383
707template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> 384template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
708class callback10 385struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
709{ 386{
710 struct object { };
711
712 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); 387 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
713 388
714 void *obj;
715 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); 389 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
716 390 void set (K *object)
717 /* a proxy is a kind of recipe on how to call a specific class method */ 391 {
718 struct proxy_base { 392 self = object;
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; 393 func = thunk<K, method>;
720 }; 394 }
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 395
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 396 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
743 { 397 {
744 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); 398 return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
745 } 399 }
746 400
747 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const 401 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
748 { 402 {
749 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); 403 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
750 } 404 }
751};
752 405
753template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> 406private:
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 407
762template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> 408 void *self;
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> 409 ptr_type func;
764{
765};
766 410
767template<class signature> 411 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
768struct callback_get_impl<10, signature> 412 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
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 { 413 {
414 klass *obj = static_cast<klass *>(self);
415 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
784 } 416 }
785}; 417};
418
786 419
787#endif 420#endif

Diff Legend

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