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.5 by pcg, Thu Mar 3 16:54:34 2005 UTC vs.
Revision 1.14 by pcg, Wed Dec 5 18:19:50 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-2005 Marc Lehmann <gvpe@schmorp.de> 7 Copyright (C) 2003-2007 Marc Lehmann <pcg@goof.com>
11 8
12 This file is part of GVPE. 9 This file is part of GVPE.
13 10
14 GVPE is free software; you can redistribute it and/or modify 11 GVPE is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by 12 it under the terms of the GNU General Public License as published by
… …
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details. 19 GNU General Public License for more details.
23 20
24 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
25 along with gvpe; if not, write to the Free Software 22 along with gvpe; if not, write to the Free Software
26 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
27*/ 24*/
28 25
29#ifndef CALLBACK_H__ 26#ifndef CALLBACK_H__
30#define CALLBACK_H__ 27#define CALLBACK_H__
31 28
29#define CALLBACK_H_VERSION 3
30
31template<typename signature>
32struct callback;
33
32template<class R> 34template<class R>
33class callback0 { 35struct callback<R ()>
34 struct object { }; 36{
37 typedef R (*ptr_type)(void *self);
35 38
36 void *obj; 39 template<class K, R (K::*method)()>
37 R (object::*meth)(); 40 void set (K *object)
38 41 {
39 /* a proxy is a kind of recipe on how to call a specific class method */ 42 self = object;
40 struct proxy_base { 43 func = thunk<K, method>;
41 virtual R call (void *obj, R (object::*meth)()) = 0;
42 }; 44 }
43 template<class O1, class O2>
44 struct proxy : proxy_base {
45 virtual R call (void *obj, R (object::*meth)())
46 {
47 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
48 ();
49 }
50 };
51 45
52 proxy_base *prxy;
53
54public:
55 template<class O1, class O2>
56 callback0 (O1 *object, R (O2::*method)())
57 {
58 static proxy<O1,O2> p;
59 obj = reinterpret_cast<void *>(object);
60 meth = reinterpret_cast<R (object::*)()>(method);
61 prxy = &p;
62 }
63
64 R call() const 46 R call () const
65 { 47 {
66 return prxy->call (obj, meth); 48 return func (self);
67 } 49 }
68 50
69 R operator ()() const 51 R operator ()() const
70 { 52 {
71 return call (); 53 return call ();
72 } 54 }
55
56private:
57
58 void *self;
59 ptr_type func;
60
61 template<class klass, R (klass::*method)()>
62 static R thunk (void *self)
63 {
64 klass *obj = static_cast<klass *>(self);
65 return (obj->*method) ();
66 }
73}; 67};
74 68
75template<class R, class A1> 69template<class R, class A1>
76class callback1 { 70struct callback<R (A1)>
77 struct object { }; 71{
72 typedef R (*ptr_type)(void *self, A1);
78 73
79 void *obj; 74 template<class K, R (K::*method)(A1)>
80 R (object::*meth)(A1); 75 void set (K *object)
81 76 {
82 /* a proxy is a kind of recipe on how to call a specific class method */ 77 self = object;
83 struct proxy_base { 78 func = thunk<K, method>;
84 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0;
85 }; 79 }
86 template<class O1, class O2>
87 struct proxy : proxy_base {
88 virtual R call (void *obj, R (object::*meth)(A1), A1 a1)
89 {
90 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
91 (a1);
92 }
93 };
94 80
95 proxy_base *prxy;
96
97public:
98 template<class O1, class O2>
99 callback1 (O1 *object, R (O2::*method)(A1))
100 {
101 static proxy<O1,O2> p;
102 obj = reinterpret_cast<void *>(object);
103 meth = reinterpret_cast<R (object::*)(A1)>(method);
104 prxy = &p;
105 }
106
107 R call(A1 a1) const 81 R call (A1 a1) const
108 { 82 {
109 return prxy->call (obj, meth, a1); 83 return func (self, a1);
110 } 84 }
111 85
112 R operator ()(A1 a1) const 86 R operator ()(A1 a1) const
113 { 87 {
114 return call (a1); 88 return call (a1);
115 } 89 }
90
91private:
92
93 void *self;
94 ptr_type func;
95
96 template<class klass, R (klass::*method)(A1)>
97 static R thunk (void *self, A1 a1)
98 {
99 klass *obj = static_cast<klass *>(self);
100 return (obj->*method) (a1);
101 }
116}; 102};
117 103
118template<class R, class A1, class A2> 104template<class R, class A1, class A2>
119class callback2 { 105struct callback<R (A1, A2)>
120 struct object { }; 106{
107 typedef R (*ptr_type)(void *self, A1, A2);
121 108
122 void *obj; 109 template<class K, R (K::*method)(A1, A2)>
123 R (object::*meth)(A1, A2); 110 void set (K *object)
124 111 {
125 /* a proxy is a kind of recipe on how to call a specific class method */ 112 self = object;
126 struct proxy_base { 113 func = thunk<K, method>;
127 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0;
128 }; 114 }
129 template<class O1, class O2>
130 struct proxy : proxy_base {
131 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2)
132 {
133 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
134 (a1, a2);
135 }
136 };
137 115
138 proxy_base *prxy;
139
140public:
141 template<class O1, class O2>
142 callback2 (O1 *object, R (O2::*method)(A1, A2))
143 {
144 static proxy<O1,O2> p;
145 obj = reinterpret_cast<void *>(object);
146 meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
147 prxy = &p;
148 }
149
150 R call(A1 a1, A2 a2) const 116 R call (A1 a1, A2 a2) const
151 { 117 {
152 return prxy->call (obj, meth, a1, a2); 118 return func (self, a1, a2);
153 } 119 }
154 120
155 R operator ()(A1 a1, A2 a2) const 121 R operator ()(A1 a1, A2 a2) const
156 { 122 {
157 return call (a1, a2); 123 return call (a1, a2);
158 } 124 }
125
126private:
127
128 void *self;
129 ptr_type func;
130
131 template<class klass, R (klass::*method)(A1, A2)>
132 static R thunk (void *self, A1 a1, A2 a2)
133 {
134 klass *obj = static_cast<klass *>(self);
135 return (obj->*method) (a1, a2);
136 }
159}; 137};
160 138
161template<class R, class A1, class A2, class A3> 139template<class R, class A1, class A2, class A3>
162class callback3 { 140struct callback<R (A1, A2, A3)>
163 struct object { }; 141{
142 typedef R (*ptr_type)(void *self, A1, A2, A3);
164 143
165 void *obj; 144 template<class K, R (K::*method)(A1, A2, A3)>
166 R (object::*meth)(A1, A2, A3); 145 void set (K *object)
167 146 {
168 /* a proxy is a kind of recipe on how to call a specific class method */ 147 self = object;
169 struct proxy_base { 148 func = thunk<K, method>;
170 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
171 }; 149 }
172 template<class O1, class O2>
173 struct proxy : proxy_base {
174 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3)
175 {
176 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
177 (a1, a2, a3);
178 }
179 };
180 150
181 proxy_base *prxy;
182
183public:
184 template<class O1, class O2>
185 callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
186 {
187 static proxy<O1,O2> p;
188 obj = reinterpret_cast<void *>(object);
189 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
190 prxy = &p;
191 }
192
193 R call(A1 a1, A2 a2, A3 a3) const 151 R call (A1 a1, A2 a2, A3 a3) const
194 { 152 {
195 return prxy->call (obj, meth, a1, a2, a3); 153 return func (self, a1, a2, a3);
196 } 154 }
197 155
198 R operator ()(A1 a1, A2 a2, A3 a3) const 156 R operator ()(A1 a1, A2 a2, A3 a3) const
199 { 157 {
200 return call (a1, a2, a3); 158 return call (a1, a2, a3);
201 } 159 }
160
161private:
162
163 void *self;
164 ptr_type func;
165
166 template<class klass, R (klass::*method)(A1, A2, A3)>
167 static R thunk (void *self, A1 a1, A2 a2, A3 a3)
168 {
169 klass *obj = static_cast<klass *>(self);
170 return (obj->*method) (a1, a2, a3);
171 }
202}; 172};
203 173
204template<class R, class A1, class A2, class A3, class A4> 174template<class R, class A1, class A2, class A3, class A4>
205class callback4 { 175struct callback<R (A1, A2, A3, A4)>
206 struct object { }; 176{
177 typedef R (*ptr_type)(void *self, A1, A2, A3, A4);
207 178
208 void *obj; 179 template<class K, R (K::*method)(A1, A2, A3, A4)>
209 R (object::*meth)(A1, A2, A3, A4); 180 void set (K *object)
210 181 {
211 /* a proxy is a kind of recipe on how to call a specific class method */ 182 self = object;
212 struct proxy_base { 183 func = thunk<K, method>;
213 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
214 }; 184 }
215 template<class O1, class O2>
216 struct proxy : proxy_base {
217 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
218 {
219 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
220 (a1, a2, a3, a4);
221 }
222 };
223 185
224 proxy_base *prxy;
225
226public:
227 template<class O1, class O2>
228 callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
229 {
230 static proxy<O1,O2> p;
231 obj = reinterpret_cast<void *>(object);
232 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
233 prxy = &p;
234 }
235
236 R call(A1 a1, A2 a2, A3 a3, A4 a4) const 186 R call (A1 a1, A2 a2, A3 a3, A4 a4) const
237 { 187 {
238 return prxy->call (obj, meth, a1, a2, a3, a4); 188 return func (self, a1, a2, a3, a4);
239 } 189 }
240 190
241 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const 191 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
242 { 192 {
243 return call (a1, a2, a3, a4); 193 return call (a1, a2, a3, a4);
244 } 194 }
195
196private:
197
198 void *self;
199 ptr_type func;
200
201 template<class klass, R (klass::*method)(A1, A2, A3, A4)>
202 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)
203 {
204 klass *obj = static_cast<klass *>(self);
205 return (obj->*method) (a1, a2, a3, a4);
206 }
245}; 207};
246 208
247template<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>
248class callback5 { 210struct callback<R (A1, A2, A3, A4, A5)>
249 struct object { }; 211{
212 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5);
250 213
251 void *obj; 214 template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
252 R (object::*meth)(A1, A2, A3, A4, A5); 215 void set (K *object)
253 216 {
254 /* a proxy is a kind of recipe on how to call a specific class method */ 217 self = object;
255 struct proxy_base { 218 func = thunk<K, method>;
256 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
257 }; 219 }
258 template<class O1, class O2>
259 struct proxy : proxy_base {
260 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
261 {
262 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
263 (a1, a2, a3, a4, a5);
264 }
265 };
266 220
267 proxy_base *prxy;
268
269public:
270 template<class O1, class O2>
271 callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
272 {
273 static proxy<O1,O2> p;
274 obj = reinterpret_cast<void *>(object);
275 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
276 prxy = &p;
277 }
278
279 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
280 { 222 {
281 return prxy->call (obj, meth, a1, a2, a3, a4, a5); 223 return func (self, a1, a2, a3, a4, a5);
282 } 224 }
283 225
284 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
285 { 227 {
286 return call (a1, a2, a3, a4, a5); 228 return call (a1, a2, a3, a4, a5);
287 } 229 }
230
231private:
232
233 void *self;
234 ptr_type func;
235
236 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>
237 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
238 {
239 klass *obj = static_cast<klass *>(self);
240 return (obj->*method) (a1, a2, a3, a4, a5);
241 }
288}; 242};
289 243
290template<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>
291class callback6 { 245struct callback<R (A1, A2, A3, A4, A5, A6)>
292 struct object { }; 246{
247 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6);
293 248
294 void *obj; 249 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
295 R (object::*meth)(A1, A2, A3, A4, A5, A6); 250 void set (K *object)
296 251 {
297 /* a proxy is a kind of recipe on how to call a specific class method */ 252 self = object;
298 struct proxy_base { 253 func = thunk<K, method>;
299 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
300 }; 254 }
301 template<class O1, class O2>
302 struct proxy : proxy_base {
303 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
304 {
305 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
306 (a1, a2, a3, a4, a5, a6);
307 }
308 };
309 255
310 proxy_base *prxy;
311
312public:
313 template<class O1, class O2>
314 callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
315 {
316 static proxy<O1,O2> p;
317 obj = reinterpret_cast<void *>(object);
318 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
319 prxy = &p;
320 }
321
322 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
323 { 257 {
324 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6); 258 return func (self, a1, a2, a3, a4, a5, a6);
325 } 259 }
326 260
327 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
328 { 262 {
329 return call (a1, a2, a3, a4, a5, a6); 263 return call (a1, a2, a3, a4, a5, a6);
330 } 264 }
265
266private:
267
268 void *self;
269 ptr_type func;
270
271 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>
272 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
273 {
274 klass *obj = static_cast<klass *>(self);
275 return (obj->*method) (a1, a2, a3, a4, a5, a6);
276 }
331}; 277};
332 278
333template<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>
334class callback7 { 280struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
335 struct object { }; 281{
282 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7);
336 283
337 void *obj; 284 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
338 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 285 void set (K *object)
339 286 {
340 /* a proxy is a kind of recipe on how to call a specific class method */ 287 self = object;
341 struct proxy_base { 288 func = thunk<K, method>;
342 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
343 }; 289 }
344 template<class O1, class O2>
345 struct proxy : proxy_base {
346 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
347 {
348 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
349 (a1, a2, a3, a4, a5, a6, a7);
350 }
351 };
352 290
353 proxy_base *prxy;
354
355public:
356 template<class O1, class O2>
357 callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
358 {
359 static proxy<O1,O2> p;
360 obj = reinterpret_cast<void *>(object);
361 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
362 prxy = &p;
363 }
364
365 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
366 { 292 {
367 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7); 293 return func (self, a1, a2, a3, a4, a5, a6, a7);
368 } 294 }
369 295
370 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
371 { 297 {
372 return call (a1, a2, a3, a4, a5, a6, a7); 298 return call (a1, a2, a3, a4, a5, a6, a7);
373 } 299 }
300
301private:
302
303 void *self;
304 ptr_type func;
305
306 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>
307 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
308 {
309 klass *obj = static_cast<klass *>(self);
310 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);
311 }
374}; 312};
313
314template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
315struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>
316{
317 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8);
318
319 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
320 void set (K *object)
321 {
322 self = object;
323 func = thunk<K, method>;
324 }
325
326 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
327 {
328 return func (self, a1, a2, a3, a4, a5, a6, a7, a8);
329 }
330
331 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
332 {
333 return call (a1, a2, a3, a4, a5, a6, a7, a8);
334 }
335
336private:
337
338 void *self;
339 ptr_type func;
340
341 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
342 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
343 {
344 klass *obj = static_cast<klass *>(self);
345 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);
346 }
347};
348
349template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
350struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
351{
352 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9);
353
354 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
355 void set (K *object)
356 {
357 self = object;
358 func = thunk<K, method>;
359 }
360
361 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
362 {
363 return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9);
364 }
365
366 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
367 {
368 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
369 }
370
371private:
372
373 void *self;
374 ptr_type func;
375
376 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
377 static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
378 {
379 klass *obj = static_cast<klass *>(self);
380 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
381 }
382};
383
384template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
385struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
386{
387 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
388
389 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
390 void set (K *object)
391 {
392 self = object;
393 func = thunk<K, method>;
394 }
395
396 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
397 {
398 return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
399 }
400
401 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
402 {
403 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
404 }
405
406private:
407
408 void *self;
409 ptr_type func;
410
411 template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
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)
413 {
414 klass *obj = static_cast<klass *>(self);
415 return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
416 }
417};
418
375 419
376#endif 420#endif

Diff Legend

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