print_callback.py

Revision 7, 16.8 kB (checked in by whispercastorg, 2 years ago)
version 0.2.0

Line
1	#!/usr/bin/python
2	#
3	# Copyright (c) 2009, Whispersoft s.r.l.
4	# All rights reserved.
5	#
6	# Redistribution and use in source and binary forms, with or without
7	# modification, are permitted provided that the following conditions are
8	# met:
9	#
10	# * Redistributions of source code must retain the above copyright
11	# notice, this list of conditions and the following disclaimer.
12	# * Redistributions in binary form must reproduce the above
13	# copyright notice, this list of conditions and the following disclaimer
14	# in the documentation and/or other materials provided with the
15	# distribution.
16	# * Neither the name of Whispersoft s.r.l. nor the names of its
17	# contributors may be used to endorse or promote products derived from
18	# this software without specific prior written permission.
19	#
20	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21	# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22	# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23	# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24	# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25	# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26	# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	#
32	# Authors: Catalin Popescu
33	#
34	# This handy script generates functor classes (see callback.h, callback1.h
35	# for examples..)
36	#
37	######################################################################
38
39	def ClosureN(N):
40	typenames = ', '.join(['typename T%d' % i for i in range(N)])
41	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
42	typeargs = ', '.join(['T%d' % i for i in range(N)])
43	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
44	print """
45	template<%s>
46	class Closure%d : public Closure {
47	public:
48	typedef void (*Fun)(%s);
49	Closure%d(bool is_permanent, Fun fun, %s)
50	: Closure(is_permanent),
51	%s
52	fun_(fun) {
53	}
54	protected:
55	virtual void RunInternal() {
56	(*fun_)(%s);
57	}
58	private:
59	%s
60	Fun fun_;
61	};
62	template<%s>
63	Closure%d<%s>* NewCallback(void (*fun)(%s), %s) {
64	return new Closure%d<%s>(false, fun, %s);
65	}
66	template<%s>
67	Closure%d<%s>* NewPermanentCallback(void (*fun)(%s), %s) {
68	return new Closure%d<%s>(true, fun, %s);
69	}
70	""" % (typenames,
71	N,
72	typeargs,
73	N,
74	params,
75	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
76	', '.join(['p%d_' % (i) for i in range(N)]),
77	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)]),
78	typenames,
79	N, typeargs, typeargs,
80	params, N, typeargs, paramnames,
81	typenames,
82	N, typeargs, typeargs,
83	params, N, typeargs, paramnames)
84
85	######################################################################
86
87	def ConstMemberClosureN(N):
88	typenames = ', '.join(['typename T%d' % i for i in range(N)])
89	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
90	typeargs = ', '.join(['T%d' % i for i in range(N)])
91	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
92	print """
93	template<typename C, %s>
94	class ConstMemberClosure%d : public Closure {
95	public:
96	typedef void (C::*Fun)(%s) const;
97	ConstMemberClosure%d(bool is_permanent, const C* c, Fun fun, %s)
98	: Closure(is_permanent),
99	c_(c),
100	%s
101	fun_(fun) {
102	}
103	protected:
104	virtual void RunInternal() {
105	(c_->*fun_)(%s);
106	}
107	private:
108	const C* c_;
109	%s
110	Fun fun_;
111	};
112	template<typename C, %s>
113	ConstMemberClosure%d<C, %s>* NewCallback(const C* c, void (C::*fun)(%s) const, %s) {
114	return new ConstMemberClosure%d<C, %s>(false, c, fun, %s);
115	}
116	template<typename C, %s>
117	ConstMemberClosure%d<C, %s>* NewPermanentCallback(C* c, void (C::*fun)(%s) const, %s) {
118	return new ConstMemberClosure%d<C, %s>(true, c, fun, %s);
119	}
120	""" % (typenames,
121	N,
122	typeargs,
123	N,
124	params,
125	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
126	', '.join(['p%d_' % (i) for i in range(N)]),
127	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)]),
128	typenames,
129	N, typeargs, typeargs,
130	params, N, typeargs, paramnames,
131	typenames,
132	N, typeargs, typeargs,
133	params, N, typeargs, paramnames)
134
135	######################################################################
136
137	def MemberClosureN(N):
138	typenames = ', '.join(['typename T%d' % i for i in range(N)])
139	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
140	typeargs = ', '.join(['T%d' % i for i in range(N)])
141	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
142	print """
143	template<typename C, %s>
144	class MemberClosure%d : public Closure {
145	public:
146	typedef void (C::*Fun)(%s);
147	MemberClosure%d(bool is_permanent, C* c, Fun fun, %s)
148	: Closure(is_permanent),
149	c_(c),
150	%s
151	fun_(fun) {
152	}
153	protected:
154	virtual void RunInternal() {
155	(c_->*fun_)(%s);
156	}
157	private:
158	C* c_;
159	%s
160	Fun fun_;
161	};
162	template<typename C, %s>
163	MemberClosure%d<C, %s>* NewCallback(C* c, void (C::*fun)(%s), %s) {
164	return new MemberClosure%d<C, %s>(false, c, fun, %s);
165	}
166	template<typename C, %s>
167	MemberClosure%d<C, %s>* NewPermanentCallback(C* c, void (C::*fun)(%s), %s) {
168	return new MemberClosure%d<C, %s>(true, c, fun, %s);
169	}
170	""" % (typenames,
171	N,
172	typeargs,
173	N,
174	params,
175	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
176	', '.join(['p%d_' % (i) for i in range(N)]),
177	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)]),
178	typenames,
179	N, typeargs, typeargs,
180	params, N, typeargs, paramnames,
181	typenames,
182	N, typeargs, typeargs,
183	params, N, typeargs, paramnames)
184
185	######################################################################
186
187	## Callback X
188
189	######################################################################
190
191	def CallbackX(M, N):
192	typenames = ', '.join(['typename T%d' % i for i in range(N)])
193	typenamesX = ', '.join(['typename X%d' % i for i in range(M)])
194	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
195	paramsX = ', '.join(['X%d x%d' % (i, i) for i in range(M)])
196	typeargs = ', '.join(['T%d' % i for i in range(N)])
197	typeargsX = ', '.join(['X%d' % i for i in range(M)])
198	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
199	print """
200	template<%s, %s>
201	class Callback%d_%d : public Callback%d<%s> {
202	public:
203	typedef void (*Fun)(%s, %s);
204	Callback%d_%d(bool is_permanent, Fun fun, %s)
205	: Callback%d<%s>(is_permanent),
206	%s
207	fun_(fun) {
208	}
209	protected:
210	virtual void RunInternal(%s) {
211	(*fun_)(%s, %s);
212	}
213	private:
214	%s
215	Fun fun_;
216	};
217	template<%s, %s>
218	Callback%d_%d<%s, %s>* NewCallback(void (*fun)(%s, %s), %s) {
219	return new Callback%d_%d<%s, %s>(false, fun, %s);
220	}
221	template<%s, %s>
222	Callback%d_%d<%s, %s>* NewPermanentCallback(void (*fun)(%s, %s), %s) {
223	return new Callback%d_%d<%s, %s>(true, fun, %s);
224	}
225	""" % (typenames, typenamesX,
226	M, N,
227	M, typeargsX,
228	typeargs, typeargsX,
229	M, N, params,
230	M, typeargsX,
231	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
232	paramsX,
233	', '.join(['p%d_' % (i) for i in range(N)]),
234	', '.join(['x%d' % (i) for i in range(M)]),
235	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)]),
236	typenames, typenamesX,
237	M, N, typeargs, typeargsX, typeargs, typeargsX,
238	params, M, N, typeargs, typeargsX, paramnames,
239	typenames, typenamesX,
240	M, N, typeargs, typeargsX, typeargs, typeargsX,
241	params, M, N, typeargs, typeargsX, paramnames)
242
243	######################################################################
244
245	def ConstMemberCallbackX(M, N):
246	typenames = ', '.join(['typename T%d' % i for i in range(N)])
247	typenamesX = ', '.join(['typename X%d' % i for i in range(M)])
248	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
249	paramsX = ', '.join(['X%d x%d' % (i, i) for i in range(M)])
250	typeargs = ', '.join(['T%d' % i for i in range(N)])
251	typeargsX = ', '.join(['X%d' % i for i in range(M)])
252	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
253	print """
254	template<typename C, %s, %s>
255	class ConstMemberCallback%d_%d : public Callback%d<%s> {
256	public:
257	typedef void (C::*Fun)(%s, %s) const;
258	ConstMemberCallback%d_%d (bool is_permanent, const C* c, Fun fun, %s)
259	: Callback%d<%s>(is_permanent),
260	c_(c),
261	%s
262	fun_(fun) {
263	}
264	protected:
265	virtual void RunInternal(%s) {
266	(c_->*fun_)(%s, %s);
267	}
268	private:
269	const C* c_;
270	%s
271	Fun fun_;
272	}; """ % ( typenames, typenamesX,
273	M, N,
274	M, typeargsX,
275	typeargs, typeargsX,
276	M, N, params,
277	M, typeargsX,
278	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
279	paramsX,
280	', '.join(['p%d_' % (i) for i in range(N)]),
281	', '.join(['x%d' % (i) for i in range(M)]),
282	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)])
283	)
284	print """
285	template<typename C, %s, %s>
286	ConstMemberCallback%d_%d<C, %s, %s>* NewCallback(const C* c, void (C::*fun)(%s, %s) const, %s) {
287	return new ConstMemberCallback%d_%d<C, %s, %s>(false, c, fun, %s);
288	}
289	template<typename C, %s, %s>
290	ConstMemberCallback%d_%d<C, %s, %s>* NewPermanentCallback(const C* c, void (C::*fun)(%s, %s) const, %s) {
291	return new ConstMemberCallback%d_%d<C, %s, %s>(true, c, fun, %s);
292	}
293
294	""" % (
295	typenames, typenamesX,
296	M, N, typeargs, typeargsX, typeargs, typeargsX,
297	params, M, N, typeargs, typeargsX, paramnames,
298	typenames, typenamesX,
299	M, N, typeargs, typeargsX, typeargs, typeargsX,
300	params, M, N, typeargs, typeargsX, paramnames)
301
302	######################################################################
303
304	def MemberCallbackX(M, N):
305	typenames = ', '.join(['typename T%d' % i for i in range(N)])
306	typenamesX = ', '.join(['typename X%d' % i for i in range(M)])
307	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
308	paramsX = ', '.join(['X%d x%d' % (i, i) for i in range(M)])
309	typeargs = ', '.join(['T%d' % i for i in range(N)])
310	typeargsX = ', '.join(['X%d' % i for i in range(M)])
311	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
312	print """
313	template<typename C, %s, %s>
314	class MemberCallback%d_%d : public Callback%d<%s> {
315	public:
316	typedef void (C::*Fun)(%s, %s);
317	MemberCallback%d_%d (bool is_permanent, C* c, Fun fun, %s)
318	: Callback%d<%s>(is_permanent),
319	c_(c),
320	%s
321	fun_(fun) {
322	}
323	protected:
324	virtual void RunInternal(%s) {
325	(c_->*fun_)(%s, %s);
326	}
327	private:
328	C* c_;
329	%s
330	Fun fun_;
331	}; """ % ( typenames, typenamesX,
332	M, N,
333	M, typeargsX,
334	typeargs, typeargsX,
335	M, N, params,
336	M, typeargsX,
337	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
338	paramsX,
339	', '.join(['p%d_' % (i) for i in range(N)]),
340	', '.join(['x%d' % (i) for i in range(M)]),
341	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)])
342	)
343	print """
344	template<typename C, %s, %s>
345	MemberCallback%d_%d<C, %s, %s>* NewCallback(C* c, void (C::*fun)(%s, %s), %s) {
346	return new MemberCallback%d_%d<C, %s, %s>(false, c, fun, %s);
347	}
348	template<typename C, %s, %s>
349	MemberCallback%d_%d<C, %s, %s>* NewPermanentCallback(C* c, void (C::*fun)(%s, %s), %s) {
350	return new MemberCallback%d_%d<C, %s, %s>(true, c, fun, %s);
351	}
352
353	""" % (
354	typenames, typenamesX,
355	M, N, typeargs, typeargsX, typeargs, typeargsX,
356	params, M, N, typeargs, typeargsX, paramnames,
357	typenames, typenamesX,
358	M, N, typeargs, typeargsX, typeargs, typeargsX,
359	params, M, N, typeargs, typeargsX, paramnames)
360
361
362	######################################################################
363
364	## ResultCallback X
365
366	######################################################################
367
368	def ResultCallbackX(M, N):
369	typenames = ', '.join(['typename T%d' % i for i in range(N)])
370	typenamesX = ', '.join(['typename X%d' % i for i in range(M)])
371	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
372	paramsX = ', '.join(['X%d x%d' % (i, i) for i in range(M)])
373	typeargs = ', '.join(['T%d' % i for i in range(N)])
374	typeargsX = ', '.join(['X%d' % i for i in range(M)])
375	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
376	print """
377	template<typename R, %s, %s>
378	class ResultCallback%d_%d : public ResultCallback%d<R, %s> {
379	public:
380	typedef R (*Fun)(%s, %s);
381	ResultCallback%d_%d(bool is_permanent, Fun fun, %s)
382	: ResultCallback%d<R, %s>(is_permanent),
383	%s
384	fun_(fun) {
385	}
386	protected:
387	virtual R RunInternal(%s) {
388	return (*fun_)(%s, %s);
389	}
390	private:
391	%s
392	Fun fun_;
393	};
394	template<typename R, %s, %s>
395	ResultCallback%d_%d<R, %s, %s>* NewCallback(R (*fun)(%s, %s), %s) {
396	return new ResultCallback%d_%d<R, %s, %s>(false, fun, %s);
397	}
398	template<typename R, %s, %s>
399	ResultCallback%d_%d<R, %s, %s>* NewPermanentCallback(R (*fun)(%s, %s), %s) {
400	return new ResultCallback%d_%d<R, %s, %s>(true, fun, %s);
401	}
402	""" % (typenames, typenamesX,
403	M, N,
404	M, typeargsX,
405	typeargs, typeargsX,
406	M, N, params,
407	M, typeargsX,
408	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
409	paramsX,
410	', '.join(['p%d_' % (i) for i in range(N)]),
411	', '.join(['x%d' % (i) for i in range(M)]),
412	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)]),
413	typenames, typenamesX,
414	M, N, typeargs, typeargsX, typeargs, typeargsX,
415	params, M, N, typeargs, typeargsX, paramnames,
416	typenames, typenamesX,
417	M, N, typeargs, typeargsX, typeargs, typeargsX,
418	params, M, N, typeargs, typeargsX, paramnames)
419
420	######################################################################
421
422	def ResultConstMemberCallbackX(M, N):
423	typenames = ', '.join(['typename T%d' % i for i in range(N)])
424	typenamesX = ', '.join(['typename X%d' % i for i in range(M)])
425	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
426	paramsX = ', '.join(['X%d x%d' % (i, i) for i in range(M)])
427	typeargs = ', '.join(['T%d' % i for i in range(N)])
428	typeargsX = ', '.join(['X%d' % i for i in range(M)])
429	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
430	print """
431	template<typename C, typename R, %s, %s>
432	class ResultConstMemberCallback%d_%d : public ResultCallback%d<R, %s> {
433	public:
434	typedef R (C::*Fun)(%s, %s) const;
435	ResultConstMemberCallback%d_%d (bool is_permanent, const C* c, Fun fun, %s)
436	: ResultCallback%d<R, %s>(is_permanent),
437	c_(c),
438	%s
439	fun_(fun) {
440	}
441	protected:
442	virtual R RunInternal(%s) {
443	return (c_->*fun_)(%s, %s);
444	}
445	private:
446	const C* c_;
447	%s
448	Fun fun_;
449	}; """ % ( typenames, typenamesX,
450	M, N,
451	M, typeargsX,
452	typeargs, typeargsX,
453	M, N, params,
454	M, typeargsX,
455	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
456	paramsX,
457	', '.join(['p%d_' % (i) for i in range(N)]),
458	', '.join(['x%d' % (i) for i in range(M)]),
459	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)])
460	)
461	print """
462	template<typename C, typename R, %s, %s>
463	ResultConstMemberCallback%d_%d<C, R, %s, %s>* NewCallback(const C* c, R (C::*fun)(%s, %s) const, %s) {
464	return new ResultConstMemberCallback%d_%d<C, R, %s, %s>(false, c, fun, %s);
465	}
466	template<typename C, typename R, %s, %s>
467	ResultConstMemberCallback%d_%d<C, R, %s, %s>* NewPermanentCallback(const C* c, R (C::*fun)(%s, %s) const, %s) {
468	return new ResultConstMemberCallback%d_%d<C, R, %s, %s>(true, c, fun, %s);
469	}
470
471	""" % (
472	typenames, typenamesX,
473	M, N, typeargs, typeargsX, typeargs, typeargsX,
474	params, M, N, typeargs, typeargsX, paramnames,
475	typenames, typenamesX,
476	M, N, typeargs, typeargsX, typeargs, typeargsX,
477	params, M, N, typeargs, typeargsX, paramnames)
478
479	######################################################################
480
481	def ResultMemberCallbackX(M, N):
482	typenames = ', '.join(['typename T%d' % i for i in range(N)])
483	typenamesX = ', '.join(['typename X%d' % i for i in range(M)])
484	params = ', '.join(['T%d p%d' % (i, i) for i in range(N)])
485	paramsX = ', '.join(['X%d x%d' % (i, i) for i in range(M)])
486	typeargs = ', '.join(['T%d' % i for i in range(N)])
487	typeargsX = ', '.join(['X%d' % i for i in range(M)])
488	paramnames = ', '.join(['p%d' % (i) for i in range(N)])
489	print """
490	template<typename C, typename R, %s, %s>
491	class ResultMemberCallback%d_%d : public ResultCallback%d<R, %s> {
492	public:
493	typedef R (C::*Fun)(%s, %s);
494	ResultMemberCallback%d_%d (bool is_permanent, C* c, Fun fun, %s)
495	: ResultCallback%d<R, %s>(is_permanent),
496	c_(c),
497	%s
498	fun_(fun) {
499	}
500	protected:
501	virtual R RunInternal(%s) {
502	return (c_->*fun_)(%s, %s);
503	}
504	private:
505	C* c_;
506	%s
507	Fun fun_;
508	}; """ % ( typenames, typenamesX,
509	M, N,
510	M, typeargsX,
511	typeargs, typeargsX,
512	M, N, params,
513	M, typeargsX,
514	'\n'.join(['p%d_(p%d),' % (i, i) for i in range(N)]),
515	paramsX,
516	', '.join(['p%d_' % (i) for i in range(N)]),
517	', '.join(['x%d' % (i) for i in range(M)]),
518	'\n'.join(['T%d p%d_;' % (i, i) for i in range(N)])
519	)
520	print """
521	template<typename C, typename R, %s, %s>
522	ResultMemberCallback%d_%d<C, R, %s, %s>* NewCallback(C* c, R (C::*fun)(%s, %s), %s) {
523	return new ResultMemberCallback%d_%d<C, R, %s, %s>(false, c, fun, %s);
524	}
525	template<typename C, typename R, %s, %s>
526	ResultMemberCallback%d_%d<C, R, %s, %s>* NewPermanentCallback(C* c, R (C::*fun)(%s, %s), %s) {
527	return new ResultMemberCallback%d_%d<C, R, %s, %s>(true, c, fun, %s);
528	}
529
530	""" % (
531	typenames, typenamesX,
532	M, N, typeargs, typeargsX, typeargs, typeargsX,
533	params, M, N, typeargs, typeargsX, paramnames,
534	typenames, typenamesX,
535	M, N, typeargs, typeargsX, typeargs, typeargsX,
536	params, M, N, typeargs, typeargsX, paramnames)
537
538
539	for i in range(1, 10):
540	ClosureN(i)
541	MemberClosureN(i)
542	ConstMemberClosureN(i)
543
544	#for i in range(1, 10):
545	# CallbackX(1,i)
546	# ConstMemberCallbackX(1, i)
547	# MemberCallbackX(1, i)
548
549	#for i in range(1, 10):
550	# ResultCallbackX(1,i)
551	# ResultConstMemberCallbackX(1, i)
552	# ResultMemberCallbackX(1, i)

Note: See TracBrowser for help on using the browser.

root/trunk/whisperlib/common/base/callback/print_callback.py

Download in other formats: