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.1 by pcg, Wed Apr 2 03:06:22 2003 UTC vs.
Revision 1.3 by pcg, Thu Oct 16 02:41:21 2003 UTC

1// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
2// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
3// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
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
1/* 8/*
2 callback.h -- C++ callback mechanism 9 callback.h -- C++ callback mechanism
10 Copyright (C) 2003 Marc Lehmann <pcg@goof.com>
3 11
4 This program is free software; you can redistribute it and/or modify 12 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by 13 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or 14 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version. 15 (at your option) any later version.
… …
17*/ 25*/
18 26
19#ifndef VPE_CALLBACK_H__ 27#ifndef VPE_CALLBACK_H__
20#define VPE_CALLBACK_H__ 28#define VPE_CALLBACK_H__
21 29
30template<class R>
31class callback0 {
32 struct object { };
33
34 void *obj;
35 R (object::*meth)();
36
37 /* a proxy is a kind of recipe on how to call a specific class method */
38 struct proxy_base {
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
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
63 {
64 return prxy->call (obj, meth);
65 }
66
67 R operator ()() const
68 {
69 return call ();
70 }
71};
72
22template<class R, class A> 73template<class R, class A1>
23class callback { 74class callback1 {
24 struct object { }; 75 struct object { };
25 76
26 void *obj; 77 void *obj;
27 R (object::*meth)(A arg); 78 R (object::*meth)(A1);
28 79
29 // a proxy is a kind of recipe on how to call a specific class method 80 /* a proxy is a kind of recipe on how to call a specific class method */
30 struct proxy_base { 81 struct proxy_base {
31 virtual R call (void *obj, R (object::*meth)(A), A arg) = 0; 82 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0;
32 }; 83 };
33 template<class O1, class O2> 84 template<class O1, class O2>
34 struct proxy : proxy_base { 85 struct proxy : proxy_base {
35 virtual R call (void *obj, R (object::*meth)(A), A arg) 86 virtual R call (void *obj, R (object::*meth)(A1), A1 a1)
36 { 87 {
37 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A)>(meth))) 88 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
38 (arg); 89 (a1);
39 } 90 }
40 }; 91 };
41 92
42 proxy_base *prxy; 93 proxy_base *prxy;
43 94
44public: 95public:
45 template<class O1, class O2> 96 template<class O1, class O2>
46 callback (O1 *object, R (O2::*method)(A)) 97 callback1 (O1 *object, R (O2::*method)(A1))
47 { 98 {
48 static proxy<O1,O2> p; 99 static proxy<O1,O2> p;
49 obj = reinterpret_cast<void *>(object); 100 obj = reinterpret_cast<void *>(object);
50 meth = reinterpret_cast<R (object::*)(A)>(method); 101 meth = reinterpret_cast<R (object::*)(A1)>(method);
51 prxy = &p; 102 prxy = &p;
52 } 103 }
53 104
54 R call(A arg) const 105 R call(A1 a1) const
55 { 106 {
56 return prxy->call (obj, meth, arg); 107 return prxy->call (obj, meth, a1);
57 } 108 }
58 109
59 R operator ()(A arg) const 110 R operator ()(A1 a1) const
60 { 111 {
61 return call (arg); 112 return call (a1);
113 }
114};
115
116template<class R, class A1, class A2>
117class callback2 {
118 struct object { };
119
120 void *obj;
121 R (object::*meth)(A1, A2);
122
123 /* a proxy is a kind of recipe on how to call a specific class method */
124 struct proxy_base {
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
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
149 {
150 return prxy->call (obj, meth, a1, a2);
151 }
152
153 R operator ()(A1 a1, A2 a2) const
154 {
155 return call (a1, a2);
156 }
157};
158
159template<class R, class A1, class A2, class A3>
160class callback3 {
161 struct object { };
162
163 void *obj;
164 R (object::*meth)(A1, A2, A3);
165
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:
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
192 {
193 return prxy->call (obj, meth, a1, a2, a3);
194 }
195
196 R operator ()(A1 a1, A2 a2, A3 a3) const
197 {
198 return call (a1, a2, a3);
199 }
200};
201
202template<class R, class A1, class A2, class A3, class A4>
203class callback4 {
204 struct object { };
205
206 void *obj;
207 R (object::*meth)(A1, A2, A3, A4);
208
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:
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
235 {
236 return prxy->call (obj, meth, a1, a2, a3, a4);
237 }
238
239 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
240 {
241 return call (a1, a2, a3, a4);
242 }
243};
244
245template<class R, class A1, class A2, class A3, class A4, class A5>
246class callback5 {
247 struct object { };
248
249 void *obj;
250 R (object::*meth)(A1, A2, A3, A4, A5);
251
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:
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
278 {
279 return prxy->call (obj, meth, a1, a2, a3, a4, a5);
280 }
281
282 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
283 {
284 return call (a1, a2, a3, a4, a5);
285 }
286};
287
288template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
289class callback6 {
290 struct object { };
291
292 void *obj;
293 R (object::*meth)(A1, A2, A3, A4, A5, A6);
294
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:
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
321 {
322 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
323 }
324
325 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
326 {
327 return call (a1, a2, a3, a4, a5, a6);
328 }
329};
330
331template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
332class callback7 {
333 struct object { };
334
335 void *obj;
336 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
337
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:
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
364 {
365 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
366 }
367
368 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
369 {
370 return call (a1, a2, a3, a4, a5, a6, a7);
62 } 371 }
63}; 372};
64 373
65#endif 374#endif
66

Diff Legend

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