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.2 by pcg, Sat Jan 17 01:20:01 2004 UTC vs.
Revision 1.14 by root, Thu May 22 18:54:32 2014 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 Marc Lehmann <pcg@goof.com> 7 Copyright (C) 2003-2007 Marc Lehmann <schmorp@schmorp.de>
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 3 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<typename signature>
32struct callback;
33
30template<class R> 34template<class R>
31class callback0 { 35struct callback<R ()>
32 struct object { }; 36{
37 typedef R (*ptr_type)(void *self);
33 38
34 void *obj; 39 template<class K, R (K::*method)()>
35 R (object::*meth)(); 40 void set (K *object)
36 41 {
37 /* a proxy is a kind of recipe on how to call a specific class method */ 42 self = object;
38 struct proxy_base { 43 func = thunk<K, method>;
39 virtual R call (void *obj, R (object::*meth)()) = 0;
40 }; 44 }
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 45
50 proxy_base *prxy;
51
52public:
53 template<class O1, class O2>
54 callback0 (O1 *object, R (O2::*method)())
55 {
56 static proxy<O1,O2> p;
57 obj = reinterpret_cast<void *>(object);
58 meth = reinterpret_cast<R (object::*)()>(method);
59 prxy = &p;
60 }
61
62 R call() const 46 R call () const
63 { 47 {
64 return prxy->call (obj, meth); 48 return func (self);
65 } 49 }
66 50
67 R operator ()() const 51 R operator ()() const
68 { 52 {
69 return call (); 53 return call ();
70 } 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 }
71}; 67};
72 68
73template<class R, class A1> 69template<class R, class A1>
74class callback1 { 70struct callback<R (A1)>
75 struct object { }; 71{
72 typedef R (*ptr_type)(void *self, A1);
76 73
77 void *obj; 74 template<class K, R (K::*method)(A1)>
78 R (object::*meth)(A1); 75 void set (K *object)
79 76 {
80 /* a proxy is a kind of recipe on how to call a specific class method */ 77 self = object;
81 struct proxy_base { 78 func = thunk<K, method>;
82 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0;
83 }; 79 }
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 80
93 proxy_base *prxy;
94
95public:
96 template<class O1, class O2>
97 callback1 (O1 *object, R (O2::*method)(A1))
98 {
99 static proxy<O1,O2> p;
100 obj = reinterpret_cast<void *>(object);
101 meth = reinterpret_cast<R (object::*)(A1)>(method);
102 prxy = &p;
103 }
104
105 R call(A1 a1) const 81 R call (A1 a1) const
106 { 82 {
107 return prxy->call (obj, meth, a1); 83 return func (self, a1);
108 } 84 }
109 85
110 R operator ()(A1 a1) const 86 R operator ()(A1 a1) const
111 { 87 {
112 return call (a1); 88 return call (a1);
113 } 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 }
114}; 102};
115 103
116template<class R, class A1, class A2> 104template<class R, class A1, class A2>
117class callback2 { 105struct callback<R (A1, A2)>
118 struct object { }; 106{
107 typedef R (*ptr_type)(void *self, A1, A2);
119 108
120 void *obj; 109 template<class K, R (K::*method)(A1, A2)>
121 R (object::*meth)(A1, A2); 110 void set (K *object)
122 111 {
123 /* a proxy is a kind of recipe on how to call a specific class method */ 112 self = object;
124 struct proxy_base { 113 func = thunk<K, method>;
125 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0;
126 }; 114 }
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 115
136 proxy_base *prxy;
137
138public:
139 template<class O1, class O2>
140 callback2 (O1 *object, R (O2::*method)(A1, A2))
141 {
142 static proxy<O1,O2> p;
143 obj = reinterpret_cast<void *>(object);
144 meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
145 prxy = &p;
146 }
147
148 R call(A1 a1, A2 a2) const 116 R call (A1 a1, A2 a2) const
149 { 117 {
150 return prxy->call (obj, meth, a1, a2); 118 return func (self, a1, a2);
151 } 119 }
152 120
153 R operator ()(A1 a1, A2 a2) const 121 R operator ()(A1 a1, A2 a2) const
154 { 122 {
155 return call (a1, a2); 123 return call (a1, a2);
156 } 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 }
157}; 137};
158 138
159template<class R, class A1, class A2, class A3> 139template<class R, class A1, class A2, class A3>
160class callback3 { 140struct callback<R (A1, A2, A3)>
161 struct object { }; 141{
142 typedef R (*ptr_type)(void *self, A1, A2, A3);
162 143
163 void *obj; 144 template<class K, R (K::*method)(A1, A2, A3)>
164 R (object::*meth)(A1, A2, A3); 145 void set (K *object)
165 146 {
166 /* a proxy is a kind of recipe on how to call a specific class method */ 147 self = object;
167 struct proxy_base { 148 func = thunk<K, method>;
168 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
169 }; 149 }
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 150
179 proxy_base *prxy;
180
181public:
182 template<class O1, class O2>
183 callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
184 {
185 static proxy<O1,O2> p;
186 obj = reinterpret_cast<void *>(object);
187 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
188 prxy = &p;
189 }
190
191 R call(A1 a1, A2 a2, A3 a3) const 151 R call (A1 a1, A2 a2, A3 a3) const
192 { 152 {
193 return prxy->call (obj, meth, a1, a2, a3); 153 return func (self, a1, a2, a3);
194 } 154 }
195 155
196 R operator ()(A1 a1, A2 a2, A3 a3) const 156 R operator ()(A1 a1, A2 a2, A3 a3) const
197 { 157 {
198 return call (a1, a2, a3); 158 return call (a1, a2, a3);
199 } 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 }
200}; 172};
201 173
202template<class R, class A1, class A2, class A3, class A4> 174template<class R, class A1, class A2, class A3, class A4>
203class callback4 { 175struct callback<R (A1, A2, A3, A4)>
204 struct object { }; 176{
177 typedef R (*ptr_type)(void *self, A1, A2, A3, A4);
205 178
206 void *obj; 179 template<class K, R (K::*method)(A1, A2, A3, A4)>
207 R (object::*meth)(A1, A2, A3, A4); 180 void set (K *object)
208 181 {
209 /* a proxy is a kind of recipe on how to call a specific class method */ 182 self = object;
210 struct proxy_base { 183 func = thunk<K, method>;
211 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
212 }; 184 }
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 185
222 proxy_base *prxy;
223
224public:
225 template<class O1, class O2>
226 callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
227 {
228 static proxy<O1,O2> p;
229 obj = reinterpret_cast<void *>(object);
230 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
231 prxy = &p;
232 }
233
234 R call(A1 a1, A2 a2, A3 a3, A4 a4) const 186 R call (A1 a1, A2 a2, A3 a3, A4 a4) const
235 { 187 {
236 return prxy->call (obj, meth, a1, a2, a3, a4); 188 return func (self, a1, a2, a3, a4);
237 } 189 }
238 190
239 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const 191 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
240 { 192 {
241 return call (a1, a2, a3, a4); 193 return call (a1, a2, a3, a4);
242 } 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 }
243}; 207};
244 208
245template<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>
246class callback5 { 210struct callback<R (A1, A2, A3, A4, A5)>
247 struct object { }; 211{
212 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5);
248 213
249 void *obj; 214 template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
250 R (object::*meth)(A1, A2, A3, A4, A5); 215 void set (K *object)
251 216 {
252 /* a proxy is a kind of recipe on how to call a specific class method */ 217 self = object;
253 struct proxy_base { 218 func = thunk<K, method>;
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 }; 219 }
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 220
265 proxy_base *prxy;
266
267public:
268 template<class O1, class O2>
269 callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
270 {
271 static proxy<O1,O2> p;
272 obj = reinterpret_cast<void *>(object);
273 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
274 prxy = &p;
275 }
276
277 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
278 { 222 {
279 return prxy->call (obj, meth, a1, a2, a3, a4, a5); 223 return func (self, a1, a2, a3, a4, a5);
280 } 224 }
281 225
282 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
283 { 227 {
284 return call (a1, a2, a3, a4, a5); 228 return call (a1, a2, a3, a4, a5);
285 } 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 }
286}; 242};
287 243
288template<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>
289class callback6 { 245struct callback<R (A1, A2, A3, A4, A5, A6)>
290 struct object { }; 246{
247 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6);
291 248
292 void *obj; 249 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
293 R (object::*meth)(A1, A2, A3, A4, A5, A6); 250 void set (K *object)
294 251 {
295 /* a proxy is a kind of recipe on how to call a specific class method */ 252 self = object;
296 struct proxy_base { 253 func = thunk<K, method>;
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 }; 254 }
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 255
308 proxy_base *prxy;
309
310public:
311 template<class O1, class O2>
312 callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
313 {
314 static proxy<O1,O2> p;
315 obj = reinterpret_cast<void *>(object);
316 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
317 prxy = &p;
318 }
319
320 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
321 { 257 {
322 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6); 258 return func (self, a1, a2, a3, a4, a5, a6);
323 } 259 }
324 260
325 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
326 { 262 {
327 return call (a1, a2, a3, a4, a5, a6); 263 return call (a1, a2, a3, a4, a5, a6);
328 } 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 }
329}; 277};
330 278
331template<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>
332class callback7 { 280struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
333 struct object { }; 281{
282 typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7);
334 283
335 void *obj; 284 template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
336 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 285 void set (K *object)
337 286 {
338 /* a proxy is a kind of recipe on how to call a specific class method */ 287 self = object;
339 struct proxy_base { 288 func = thunk<K, method>;
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 }; 289 }
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 290
351 proxy_base *prxy;
352
353public:
354 template<class O1, class O2>
355 callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
356 {
357 static proxy<O1,O2> p;
358 obj = reinterpret_cast<void *>(object);
359 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
360 prxy = &p;
361 }
362
363 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
364 { 292 {
365 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7); 293 return func (self, a1, a2, a3, a4, a5, a6, a7);
366 } 294 }
367 295
368 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
369 { 297 {
370 return call (a1, a2, a3, a4, a5, a6, a7); 298 return call (a1, a2, a3, a4, a5, a6, a7);
371 } 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 }
372}; 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
373 419
374#endif 420#endif

Diff Legend

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