[ViewVC] Diff of: cvs/rxvt-unicode/src/callback.h

Comparing rxvt-unicode/src/callback.h (file contents):
Revision 1.10 by root, Tue Dec 4 14:50:40 2007 UTC vs.
Revision 1.12 by root, Wed Dec 5 18:20:39 2007 UTC

…		…
29	#define CALLBACK_H_VERSION 3	29	#define CALLBACK_H_VERSION 3
30		30
31	template<typename signature>	31	template<typename signature>
32	struct callback;	32	struct callback;
33		33
34	#define callback_set(callback,obj,klass,method) callback.set<klass, &klass::method> (obj)
35
36	template<class R>	34	template<class R>
37	struct callback<R ()>	35	struct callback<R ()>
38	{	36	{
39	typedef R (ptr_type)(void self);	37	typedef R (ptr_type)(void self);
40		38
41	private:	39	template<class K, R (K::*method)()>
42		40	void set (K *object)
43	void *self;
44	ptr_type func;
45
46	protected:
47
48	template<typename method>
49	struct thunktype;
50
51	template<class klass>
52	struct thunktype<R (klass::*)>
53	{	41	{
54	typedef klass K;	42	self = object;
		43	func = thunk<K, method>;
55	};	44	}
		45
		46	R call () const
		47	{
		48	return func (self);
		49	}
		50
		51	R operator ()() const
		52	{
		53	return call ();
		54	}
		55
		56	private:
		57
		58	void *self;
		59	ptr_type func;
56		60
57	template<class klass, R (klass::*method)()>	61	template<class klass, R (klass::*method)()>
58	static R thunk (void *self)	62	static R thunk (void *self)
59	{	63	{
60	klass obj = static_cast<klass >(self);	64	klass obj = static_cast<klass >(self);
61	return (obj->*method) ();	65	return (obj->*method) ();
62	}	66	}
63
64	public:
65	template<class K, R (K::*method)()>
66	void set (K *object)
67	{
68	self = object;
69	func = thunk<K, method>;
70	}
71
72	R call () const
73	{
74	return func (self);
75	}
76
77	R operator ()() const
78	{
79	return call ();
80	}
81	};	67	};
82		68
83	template<class R, class A1>	69	template<class R, class A1>
84	struct callback<R (A1)>	70	struct callback<R (A1)>
85	{	71	{
86	typedef R (ptr_type)(void self, A1);	72	typedef R (ptr_type)(void self, A1);
87		73
88	private:	74	template<class K, R (K::*method)(A1)>
89		75	void set (K *object)
90	void *self;
91	ptr_type func;
92
93	protected:
94
95	template<typename method>
96	struct thunktype;
97
98	template<class klass>
99	struct thunktype<R (klass::*)>
100	{	76	{
101	typedef klass K;	77	self = object;
		78	func = thunk<K, method>;
102	};	79	}
		80
		81	R call (A1 a1) const
		82	{
		83	return func (self, a1);
		84	}
		85
		86	R operator ()(A1 a1) const
		87	{
		88	return call (a1);
		89	}
		90
		91	private:
		92
		93	void *self;
		94	ptr_type func;
103		95
104	template<class klass, R (klass::*method)(A1)>	96	template<class klass, R (klass::*method)(A1)>
105	static R thunk (void *self, A1 a1)	97	static R thunk (void *self, A1 a1)
106	{	98	{
107	klass obj = static_cast<klass >(self);	99	klass obj = static_cast<klass >(self);
108	return (obj->*method) (a1);	100	return (obj->*method) (a1);
109	}	101	}
110
111	public:
112	template<class K, R (K::*method)(A1)>
113	void set (K *object)
114	{
115	self = object;
116	func = thunk<K, method>;
117	}
118
119	R call (A1 a1) const
120	{
121	return func (self, a1);
122	}
123
124	R operator ()(A1 a1) const
125	{
126	return call (a1);
127	}
128	};	102	};
129		103
130	template<class R, class A1, class A2>	104	template<class R, class A1, class A2>
131	struct callback<R (A1, A2)>	105	struct callback<R (A1, A2)>
132	{	106	{
133	typedef R (ptr_type)(void self, A1, A2);	107	typedef R (ptr_type)(void self, A1, A2);
134		108
135	private:	109	template<class K, R (K::*method)(A1, A2)>
136		110	void set (K *object)
137	void *self;
138	ptr_type func;
139
140	protected:
141
142	template<typename method>
143	struct thunktype;
144
145	template<class klass>
146	struct thunktype<R (klass::*)>
147	{	111	{
148	typedef klass K;	112	self = object;
		113	func = thunk<K, method>;
149	};	114	}
		115
		116	R call (A1 a1, A2 a2) const
		117	{
		118	return func (self, a1, a2);
		119	}
		120
		121	R operator ()(A1 a1, A2 a2) const
		122	{
		123	return call (a1, a2);
		124	}
		125
		126	private:
		127
		128	void *self;
		129	ptr_type func;
150		130
151	template<class klass, R (klass::*method)(A1, A2)>	131	template<class klass, R (klass::*method)(A1, A2)>
152	static R thunk (void *self, A1 a1, A2 a2)	132	static R thunk (void *self, A1 a1, A2 a2)
153	{	133	{
154	klass obj = static_cast<klass >(self);	134	klass obj = static_cast<klass >(self);
155	return (obj->*method) (a1, a2);	135	return (obj->*method) (a1, a2);
156	}	136	}
157
158	public:
159	template<class K, R (K::*method)(A1, A2)>
160	void set (K *object)
161	{
162	self = object;
163	func = thunk<K, method>;
164	}
165
166	R call (A1 a1, A2 a2) const
167	{
168	return func (self, a1, a2);
169	}
170
171	R operator ()(A1 a1, A2 a2) const
172	{
173	return call (a1, a2);
174	}
175	};	137	};
176		138
177	template<class R, class A1, class A2, class A3>	139	template<class R, class A1, class A2, class A3>
178	struct callback<R (A1, A2, A3)>	140	struct callback<R (A1, A2, A3)>
179	{	141	{
180	typedef R (ptr_type)(void self, A1, A2, A3);	142	typedef R (ptr_type)(void self, A1, A2, A3);
181		143
182	private:	144	template<class K, R (K::*method)(A1, A2, A3)>
183		145	void set (K *object)
184	void *self;
185	ptr_type func;
186
187	protected:
188
189	template<typename method>
190	struct thunktype;
191
192	template<class klass>
193	struct thunktype<R (klass::*)>
194	{	146	{
195	typedef klass K;	147	self = object;
		148	func = thunk<K, method>;
196	};	149	}
		150
		151	R call (A1 a1, A2 a2, A3 a3) const
		152	{
		153	return func (self, a1, a2, a3);
		154	}
		155
		156	R operator ()(A1 a1, A2 a2, A3 a3) const
		157	{
		158	return call (a1, a2, a3);
		159	}
		160
		161	private:
		162
		163	void *self;
		164	ptr_type func;
197		165
198	template<class klass, R (klass::*method)(A1, A2, A3)>	166	template<class klass, R (klass::*method)(A1, A2, A3)>
199	static R thunk (void *self, A1 a1, A2 a2, A3 a3)	167	static R thunk (void *self, A1 a1, A2 a2, A3 a3)
200	{	168	{
201	klass obj = static_cast<klass >(self);	169	klass obj = static_cast<klass >(self);
202	return (obj->*method) (a1, a2, a3);	170	return (obj->*method) (a1, a2, a3);
203	}	171	}
204
205	public:
206	template<class K, R (K::*method)(A1, A2, A3)>
207	void set (K *object)
208	{
209	self = object;
210	func = thunk<K, method>;
211	}
212
213	R call (A1 a1, A2 a2, A3 a3) const
214	{
215	return func (self, a1, a2, a3);
216	}
217
218	R operator ()(A1 a1, A2 a2, A3 a3) const
219	{
220	return call (a1, a2, a3);
221	}
222	};	172	};
223		173
224	template<class R, class A1, class A2, class A3, class A4>	174	template<class R, class A1, class A2, class A3, class A4>
225	struct callback<R (A1, A2, A3, A4)>	175	struct callback<R (A1, A2, A3, A4)>
226	{	176	{
227	typedef R (ptr_type)(void self, A1, A2, A3, A4);	177	typedef R (ptr_type)(void self, A1, A2, A3, A4);
228		178
229	private:	179	template<class K, R (K::*method)(A1, A2, A3, A4)>
230		180	void set (K *object)
231	void *self;
232	ptr_type func;
233
234	protected:
235
236	template<typename method>
237	struct thunktype;
238
239	template<class klass>
240	struct thunktype<R (klass::*)>
241	{	181	{
242	typedef klass K;	182	self = object;
		183	func = thunk<K, method>;
243	};	184	}
		185
		186	R call (A1 a1, A2 a2, A3 a3, A4 a4) const
		187	{
		188	return func (self, a1, a2, a3, a4);
		189	}
		190
		191	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
		192	{
		193	return call (a1, a2, a3, a4);
		194	}
		195
		196	private:
		197
		198	void *self;
		199	ptr_type func;
244		200
245	template<class klass, R (klass::*method)(A1, A2, A3, A4)>	201	template<class klass, R (klass::*method)(A1, A2, A3, A4)>
246	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)	202	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)
247	{	203	{
248	klass obj = static_cast<klass >(self);	204	klass obj = static_cast<klass >(self);
249	return (obj->*method) (a1, a2, a3, a4);	205	return (obj->*method) (a1, a2, a3, a4);
250	}	206	}
251
252	public:
253	template<class K, R (K::*method)(A1, A2, A3, A4)>
254	void set (K *object)
255	{
256	self = object;
257	func = thunk<K, method>;
258	}
259
260	R call (A1 a1, A2 a2, A3 a3, A4 a4) const
261	{
262	return func (self, a1, a2, a3, a4);
263	}
264
265	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
266	{
267	return call (a1, a2, a3, a4);
268	}
269	};	207	};
270		208
271	template<class R, class A1, class A2, class A3, class A4, class A5>	209	template<class R, class A1, class A2, class A3, class A4, class A5>
272	struct callback<R (A1, A2, A3, A4, A5)>	210	struct callback<R (A1, A2, A3, A4, A5)>
273	{	211	{
274	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5);	212	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5);
275		213
276	private:	214	template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
277		215	void set (K *object)
278	void *self;
279	ptr_type func;
280
281	protected:
282
283	template<typename method>
284	struct thunktype;
285
286	template<class klass>
287	struct thunktype<R (klass::*)>
288	{	216	{
289	typedef klass K;	217	self = object;
		218	func = thunk<K, method>;
290	};	219	}
		220
		221	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
		222	{
		223	return func (self, a1, a2, a3, a4, a5);
		224	}
		225
		226	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
		227	{
		228	return call (a1, a2, a3, a4, a5);
		229	}
		230
		231	private:
		232
		233	void *self;
		234	ptr_type func;
291		235
292	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>	236	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>
293	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)	237	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
294	{	238	{
295	klass obj = static_cast<klass >(self);	239	klass obj = static_cast<klass >(self);
296	return (obj->*method) (a1, a2, a3, a4, a5);	240	return (obj->*method) (a1, a2, a3, a4, a5);
297	}	241	}
298
299	public:
300	template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
301	void set (K *object)
302	{
303	self = object;
304	func = thunk<K, method>;
305	}
306
307	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
308	{
309	return func (self, a1, a2, a3, a4, a5);
310	}
311
312	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
313	{
314	return call (a1, a2, a3, a4, a5);
315	}
316	};	242	};
317		243
318	template<class R, class A1, class A2, class A3, class A4, class A5, class A6>	244	template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
319	struct callback<R (A1, A2, A3, A4, A5, A6)>	245	struct callback<R (A1, A2, A3, A4, A5, A6)>
320	{	246	{
321	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6);	247	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6);
322		248
323	private:	249	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
324		250	void set (K *object)
325	void *self;
326	ptr_type func;
327
328	protected:
329
330	template<typename method>
331	struct thunktype;
332
333	template<class klass>
334	struct thunktype<R (klass::*)>
335	{	251	{
336	typedef klass K;	252	self = object;
		253	func = thunk<K, method>;
337	};	254	}
		255
		256	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
		257	{
		258	return func (self, a1, a2, a3, a4, a5, a6);
		259	}
		260
		261	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
		262	{
		263	return call (a1, a2, a3, a4, a5, a6);
		264	}
		265
		266	private:
		267
		268	void *self;
		269	ptr_type func;
338		270
339	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>	271	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>
340	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)	272	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
341	{	273	{
342	klass obj = static_cast<klass >(self);	274	klass obj = static_cast<klass >(self);
343	return (obj->*method) (a1, a2, a3, a4, a5, a6);	275	return (obj->*method) (a1, a2, a3, a4, a5, a6);
344	}	276	}
345
346	public:
347	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
348	void set (K *object)
349	{
350	self = object;
351	func = thunk<K, method>;
352	}
353
354	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
355	{
356	return func (self, a1, a2, a3, a4, a5, a6);
357	}
358
359	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
360	{
361	return call (a1, a2, a3, a4, a5, a6);
362	}
363	};	277	};
364		278
365	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>	279	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
366	struct callback<R (A1, A2, A3, A4, A5, A6, A7)>	280	struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
367	{	281	{
368	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7);	282	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7);
369		283
370	private:	284	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
371		285	void set (K *object)
372	void *self;
373	ptr_type func;
374
375	protected:
376
377	template<typename method>
378	struct thunktype;
379
380	template<class klass>
381	struct thunktype<R (klass::*)>
382	{	286	{
383	typedef klass K;	287	self = object;
		288	func = thunk<K, method>;
384	};	289	}
		290
		291	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
		292	{
		293	return func (self, a1, a2, a3, a4, a5, a6, a7);
		294	}
		295
		296	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
		297	{
		298	return call (a1, a2, a3, a4, a5, a6, a7);
		299	}
		300
		301	private:
		302
		303	void *self;
		304	ptr_type func;
385		305
386	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>	306	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>
387	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)	307	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
388	{	308	{
389	klass obj = static_cast<klass >(self);	309	klass obj = static_cast<klass >(self);
390	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);	310	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);
391	}	311	}
392
393	public:
394	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
395	void set (K *object)
396	{
397	self = object;
398	func = thunk<K, method>;
399	}
400
401	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
402	{
403	return func (self, a1, a2, a3, a4, a5, a6, a7);
404	}
405
406	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
407	{
408	return call (a1, a2, a3, a4, a5, a6, a7);
409	}
410	};	312	};
411		313
412	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>	314	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
413	struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>	315	struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>
414	{	316	{
415	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8);	317	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8);
416		318
417	private:	319	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
418		320	void set (K *object)
419	void *self;
420	ptr_type func;
421
422	protected:
423
424	template<typename method>
425	struct thunktype;
426
427	template<class klass>
428	struct thunktype<R (klass::*)>
429	{	321	{
430	typedef klass K;	322	self = object;
		323	func = thunk<K, method>;
431	};	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
		336	private:
		337
		338	void *self;
		339	ptr_type func;
432		340
433	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>	341	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
434	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)	342	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
435	{	343	{
436	klass obj = static_cast<klass >(self);	344	klass obj = static_cast<klass >(self);
437	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);	345	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);
438	}	346	}
439
440	public:
441	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
442	void set (K *object)
443	{
444	self = object;
445	func = thunk<K, method>;
446	}
447
448	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
449	{
450	return func (self, a1, a2, a3, a4, a5, a6, a7, a8);
451	}
452
453	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
454	{
455	return call (a1, a2, a3, a4, a5, a6, a7, a8);
456	}
457	};	347	};
458		348
459	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>	349	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
460	struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>	350	struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
461	{	351	{
462	typedef R (ptr_type)(void self, 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);
463		353
464	private:	354	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
465		355	void set (K *object)
466	void *self;
467	ptr_type func;
468
469	protected:
470
471	template<typename method>
472	struct thunktype;
473
474	template<class klass>
475	struct thunktype<R (klass::*)>
476	{	356	{
477	typedef klass K;	357	self = object;
		358	func = thunk<K, method>;
478	};	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
		371	private:
		372
		373	void *self;
		374	ptr_type func;
479		375
480	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>	376	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
481	static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 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)
482	{	378	{
483	klass obj = static_cast<klass >(self);	379	klass obj = static_cast<klass >(self);
484	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);	380	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
485	}	381	}
486
487	public:
488	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
489	void set (K *object)
490	{
491	self = object;
492	func = thunk<K, method>;
493	}
494
495	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
496	{
497	return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9);
498	}
499
500	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
501	{
502	return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
503	}
504	};	382	};
505		383
506	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>	384	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
507	struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>	385	struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
508	{	386	{
509	typedef R (ptr_type)(void self, 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);
510		388
511	private:	389	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
512		390	void set (K *object)
513	void *self;
514	ptr_type func;
515
516	protected:
517
518	template<typename method>
519	struct thunktype;
520
521	template<class klass>
522	struct thunktype<R (klass::*)>
523	{	391	{
524	typedef klass K;	392	self = object;
		393	func = thunk<K, method>;
525	};	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
		406	private:
		407
		408	void *self;
		409	ptr_type func;
526		410
527	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>	411	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
528	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)	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)
529	{	413	{
530	klass obj = static_cast<klass >(self);	414	klass obj = static_cast<klass >(self);
531	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);	415	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
532	}	416	}
533
534	public:
535	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
536	void set (K *object)
537	{
538	self = object;
539	func = thunk<K, method>;
540	}
541
542	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
543	{
544	return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
545	}
546
547	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
548	{
549	return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
550	}
551	};	417	};
552		418
553		419
554	#endif	420	#endif

Diff Legend

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

Comparing rxvt-unicode/src/callback.h (file contents): Revision 1.10 by root, Tue Dec 4 14:50:40 2007 UTC vs. Revision 1.12 by root, Wed Dec 5 18:20:39 2007 UTC

Diff Legend

Comparing rxvt-unicode/src/callback.h (file contents):
Revision 1.10 by root, Tue Dec 4 14:50:40 2007 UTC vs.
Revision 1.12 by root, Wed Dec 5 18:20:39 2007 UTC