[ViewVC] Diff of: cvs/gvpe/src/callback.h

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

Diff Legend

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

Comparing gvpe/src/callback.h (file contents): Revision 1.10 by pcg, Wed May 31 00:31:47 2006 UTC vs. Revision 1.13 by pcg, Tue Dec 4 17:17:19 2007 UTC

Diff Legend

Comparing gvpe/src/callback.h (file contents):
Revision 1.10 by pcg, Wed May 31 00:31:47 2006 UTC vs.
Revision 1.13 by pcg, Tue Dec 4 17:17:19 2007 UTC