result_callback3.h

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

Line
1	// Copyright (c) 2009, Whispersoft s.r.l.
2	// All rights reserved.
3	//
4	// Redistribution and use in source and binary forms, with or without
5	// modification, are permitted provided that the following conditions are
6	// met:
7	//
8	// * Redistributions of source code must retain the above copyright
9	// notice, this list of conditions and the following disclaimer.
10	// * Redistributions in binary form must reproduce the above
11	// copyright notice, this list of conditions and the following disclaimer
12	// in the documentation and/or other materials provided with the
13	// distribution.
14	// * Neither the name of Whispersoft s.r.l. nor the names of its
15	// contributors may be used to endorse or promote products derived from
16	// this software without specific prior written permission.
17	//
18	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	//
30
31	#ifndef __COMMON_BASE_CALLBACK_RESULT_CALLBACK3_H__
32	#define __COMMON_BASE_CALLBACK_RESULT_CALLBACK3_H__
33
34
35	template<typename R, typename X0, typename X1, typename X2>
36	class ResultCallback3 {
37	public:
38	ResultCallback3(bool is_permanent)
39	: is_permanent_(is_permanent) {
40	}
41	virtual ~ResultCallback3() {
42	}
43	R Run(X0 x0, X1 x1, X2 x2) {
44	R ret = RunInternal(x0, x1, x2);
45	if ( !is_permanent_ )
46	delete this;
47	return ret;
48	}
49	bool is_permanent() const { return is_permanent_; }
50	protected:
51	virtual R RunInternal(X0 x0, X1 x1, X2 x2) = 0;
52	private:
53	bool is_permanent_;
54	};
55
56	//////////////////////////////////////////////////////////////////////
57
58	template<typename R, typename X0, typename X1, typename X2>
59	class ResultCallback3_0 : public ResultCallback3<R, X0, X1, X2> {
60	public:
61	typedef R (*Fun)(X0, X1, X2);
62	ResultCallback3_0(bool is_permanent, Fun fun)
63	: ResultCallback3<R, X0, X1, X2>(is_permanent),
64	fun_(fun) {
65	}
66	protected:
67	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
68	return (*fun_)(x0, x1, x2);
69	}
70	private:
71	Fun fun_;
72	};
73	template<typename R, typename X0, typename X1, typename X2>
74	ResultCallback3_0<R, X0, X1, X2>* NewCallback(R (*fun)(X0, X1, X2)) {
75	return new ResultCallback3_0<R, X0, X1, X2>(false, fun);
76	}
77	template<typename R, typename X0, typename X1, typename X2>
78	ResultCallback3_0<R, X0, X1, X2>* NewPermanentCallback(R (*fun)(X0, X1, X2)) {
79	return new ResultCallback3_0<R, X0, X1, X2>(true, fun);
80	}
81
82
83	template<typename C, typename R, typename X0, typename X1, typename X2>
84	class ResultConstMemberCallback3_0 : public ResultCallback3<R, X0, X1, X2> {
85	public:
86	typedef R (C::*Fun)(X0, X1, X2) const;
87	ResultConstMemberCallback3_0 (bool is_permanent, const C* c, Fun fun)
88	: ResultCallback3<R, X0, X1, X2>(is_permanent),
89	c_(c),
90	fun_(fun) {
91	}
92	protected:
93	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
94	return (c_->*fun_)(x0, x1, x2);
95	}
96	private:
97	const C* c_;
98	Fun fun_;
99	};
100
101	template<typename C, typename R, typename X0, typename X1, typename X2>
102	ResultConstMemberCallback3_0<C, R, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(X0, X1, X2) const) {
103	return new ResultConstMemberCallback3_0<C, R, X0, X1, X2>(false, c, fun);
104	}
105	template<typename C, typename R, typename X0, typename X1, typename X2>
106	ResultConstMemberCallback3_0<C, R, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(X0, X1, X2) const) {
107	return new ResultConstMemberCallback3_0<C, R, X0, X1, X2>(true, c, fun);
108	}
109
110
111
112	template<typename C, typename R, typename X0, typename X1, typename X2>
113	class ResultMemberCallback3_0 : public ResultCallback3<R, X0, X1, X2> {
114	public:
115	typedef R (C::*Fun)(X0, X1, X2);
116	ResultMemberCallback3_0 (bool is_permanent, C* c, Fun fun)
117	: ResultCallback3<R, X0, X1, X2>(is_permanent),
118	c_(c),
119	fun_(fun) {
120	}
121	protected:
122	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
123	return (c_->*fun_)(x0, x1, x2);
124	}
125	private:
126	C* c_;
127	Fun fun_;
128	};
129
130	template<typename C, typename R, typename X0, typename X1, typename X2>
131	ResultMemberCallback3_0<C, R, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(X0, X1, X2)) {
132	return new ResultMemberCallback3_0<C, R, X0, X1, X2>(false, c, fun);
133	}
134	template<typename C, typename R, typename X0, typename X1, typename X2>
135	ResultMemberCallback3_0<C, R, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(X0, X1, X2)) {
136	return new ResultMemberCallback3_0<C, R, X0, X1, X2>(true, c, fun);
137	}
138
139	//////////////////////////////////////////////////////////////////////
140	//
141	// Autogenerated callback classes (w/ print_callback.py)
142	//
143
144	template<typename R, typename T0, typename X0, typename X1, typename X2>
145	class ResultCallback3_1 : public ResultCallback3<R, X0, X1, X2> {
146	public:
147	typedef R (*Fun)(T0, X0, X1, X2);
148	ResultCallback3_1(bool is_permanent, Fun fun, T0 p0)
149	: ResultCallback3<R, X0, X1, X2>(is_permanent),
150	p0_(p0),
151	fun_(fun) {
152	}
153	protected:
154	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
155	return (*fun_)(p0_, x0, x1, x2);
156	}
157	private:
158	T0 p0_;
159	Fun fun_;
160	};
161	template<typename R, typename T0, typename X0, typename X1, typename X2>
162	ResultCallback3_1<R, T0, X0, X1, X2>* NewCallback(R (*fun)(T0, X0, X1, X2), T0 p0) {
163	return new ResultCallback3_1<R, T0, X0, X1, X2>(false, fun, p0);
164	}
165	template<typename R, typename T0, typename X0, typename X1, typename X2>
166	ResultCallback3_1<R, T0, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, X0, X1, X2), T0 p0) {
167	return new ResultCallback3_1<R, T0, X0, X1, X2>(true, fun, p0);
168	}
169
170
171	template<typename C, typename R, typename T0, typename X0, typename X1, typename X2>
172	class ResultConstMemberCallback3_1 : public ResultCallback3<R, X0, X1, X2> {
173	public:
174	typedef R (C::*Fun)(T0, X0, X1, X2) const;
175	ResultConstMemberCallback3_1 (bool is_permanent, const C* c, Fun fun, T0 p0)
176	: ResultCallback3<R, X0, X1, X2>(is_permanent),
177	c_(c),
178	p0_(p0),
179	fun_(fun) {
180	}
181	protected:
182	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
183	return (c_->*fun_)(p0_, x0, x1, x2);
184	}
185	private:
186	const C* c_;
187	T0 p0_;
188	Fun fun_;
189	};
190
191	template<typename C, typename R, typename T0, typename X0, typename X1, typename X2>
192	ResultConstMemberCallback3_1<C, R, T0, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, X0, X1, X2) const, T0 p0) {
193	return new ResultConstMemberCallback3_1<C, R, T0, X0, X1, X2>(false, c, fun, p0);
194	}
195	template<typename C, typename R, typename T0, typename X0, typename X1, typename X2>
196	ResultConstMemberCallback3_1<C, R, T0, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, X0, X1, X2) const, T0 p0) {
197	return new ResultConstMemberCallback3_1<C, R, T0, X0, X1, X2>(true, c, fun, p0);
198	}
199
200
201
202	template<typename C, typename R, typename T0, typename X0, typename X1, typename X2>
203	class ResultMemberCallback3_1 : public ResultCallback3<R, X0, X1, X2> {
204	public:
205	typedef R (C::*Fun)(T0, X0, X1, X2);
206	ResultMemberCallback3_1 (bool is_permanent, C* c, Fun fun, T0 p0)
207	: ResultCallback3<R, X0, X1, X2>(is_permanent),
208	c_(c),
209	p0_(p0),
210	fun_(fun) {
211	}
212	protected:
213	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
214	return (c_->*fun_)(p0_, x0, x1, x2);
215	}
216	private:
217	C* c_;
218	T0 p0_;
219	Fun fun_;
220	};
221
222	template<typename C, typename R, typename T0, typename X0, typename X1, typename X2>
223	ResultMemberCallback3_1<C, R, T0, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, X0, X1, X2), T0 p0) {
224	return new ResultMemberCallback3_1<C, R, T0, X0, X1, X2>(false, c, fun, p0);
225	}
226	template<typename C, typename R, typename T0, typename X0, typename X1, typename X2>
227	ResultMemberCallback3_1<C, R, T0, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, X0, X1, X2), T0 p0) {
228	return new ResultMemberCallback3_1<C, R, T0, X0, X1, X2>(true, c, fun, p0);
229	}
230
231
232
233	template<typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
234	class ResultCallback3_2 : public ResultCallback3<R, X0, X1, X2> {
235	public:
236	typedef R (*Fun)(T0, T1, X0, X1, X2);
237	ResultCallback3_2(bool is_permanent, Fun fun, T0 p0, T1 p1)
238	: ResultCallback3<R, X0, X1, X2>(is_permanent),
239	p0_(p0),
240	p1_(p1),
241	fun_(fun) {
242	}
243	protected:
244	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
245	return (*fun_)(p0_, p1_, x0, x1, x2);
246	}
247	private:
248	T0 p0_;
249	T1 p1_;
250	Fun fun_;
251	};
252	template<typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
253	ResultCallback3_2<R, T0, T1, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, X0, X1, X2), T0 p0, T1 p1) {
254	return new ResultCallback3_2<R, T0, T1, X0, X1, X2>(false, fun, p0, p1);
255	}
256	template<typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
257	ResultCallback3_2<R, T0, T1, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, X0, X1, X2), T0 p0, T1 p1) {
258	return new ResultCallback3_2<R, T0, T1, X0, X1, X2>(true, fun, p0, p1);
259	}
260
261
262	template<typename C, typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
263	class ResultConstMemberCallback3_2 : public ResultCallback3<R, X0, X1, X2> {
264	public:
265	typedef R (C::*Fun)(T0, T1, X0, X1, X2) const;
266	ResultConstMemberCallback3_2 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1)
267	: ResultCallback3<R, X0, X1, X2>(is_permanent),
268	c_(c),
269	p0_(p0),
270	p1_(p1),
271	fun_(fun) {
272	}
273	protected:
274	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
275	return (c_->*fun_)(p0_, p1_, x0, x1, x2);
276	}
277	private:
278	const C* c_;
279	T0 p0_;
280	T1 p1_;
281	Fun fun_;
282	};
283
284	template<typename C, typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
285	ResultConstMemberCallback3_2<C, R, T0, T1, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, X0, X1, X2) const, T0 p0, T1 p1) {
286	return new ResultConstMemberCallback3_2<C, R, T0, T1, X0, X1, X2>(false, c, fun, p0, p1);
287	}
288	template<typename C, typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
289	ResultConstMemberCallback3_2<C, R, T0, T1, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, X0, X1, X2) const, T0 p0, T1 p1) {
290	return new ResultConstMemberCallback3_2<C, R, T0, T1, X0, X1, X2>(true, c, fun, p0, p1);
291	}
292
293
294
295	template<typename C, typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
296	class ResultMemberCallback3_2 : public ResultCallback3<R, X0, X1, X2> {
297	public:
298	typedef R (C::*Fun)(T0, T1, X0, X1, X2);
299	ResultMemberCallback3_2 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1)
300	: ResultCallback3<R, X0, X1, X2>(is_permanent),
301	c_(c),
302	p0_(p0),
303	p1_(p1),
304	fun_(fun) {
305	}
306	protected:
307	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
308	return (c_->*fun_)(p0_, p1_, x0, x1, x2);
309	}
310	private:
311	C* c_;
312	T0 p0_;
313	T1 p1_;
314	Fun fun_;
315	};
316
317	template<typename C, typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
318	ResultMemberCallback3_2<C, R, T0, T1, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, X0, X1, X2), T0 p0, T1 p1) {
319	return new ResultMemberCallback3_2<C, R, T0, T1, X0, X1, X2>(false, c, fun, p0, p1);
320	}
321	template<typename C, typename R, typename T0, typename T1, typename X0, typename X1, typename X2>
322	ResultMemberCallback3_2<C, R, T0, T1, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, X0, X1, X2), T0 p0, T1 p1) {
323	return new ResultMemberCallback3_2<C, R, T0, T1, X0, X1, X2>(true, c, fun, p0, p1);
324	}
325
326
327
328	template<typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
329	class ResultCallback3_3 : public ResultCallback3<R, X0, X1, X2> {
330	public:
331	typedef R (*Fun)(T0, T1, T2, X0, X1, X2);
332	ResultCallback3_3(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2)
333	: ResultCallback3<R, X0, X1, X2>(is_permanent),
334	p0_(p0),
335	p1_(p1),
336	p2_(p2),
337	fun_(fun) {
338	}
339	protected:
340	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
341	return (*fun_)(p0_, p1_, p2_, x0, x1, x2);
342	}
343	private:
344	T0 p0_;
345	T1 p1_;
346	T2 p2_;
347	Fun fun_;
348	};
349	template<typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
350	ResultCallback3_3<R, T0, T1, T2, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, T2, X0, X1, X2), T0 p0, T1 p1, T2 p2) {
351	return new ResultCallback3_3<R, T0, T1, T2, X0, X1, X2>(false, fun, p0, p1, p2);
352	}
353	template<typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
354	ResultCallback3_3<R, T0, T1, T2, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, T2, X0, X1, X2), T0 p0, T1 p1, T2 p2) {
355	return new ResultCallback3_3<R, T0, T1, T2, X0, X1, X2>(true, fun, p0, p1, p2);
356	}
357
358
359	template<typename C, typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
360	class ResultConstMemberCallback3_3 : public ResultCallback3<R, X0, X1, X2> {
361	public:
362	typedef R (C::*Fun)(T0, T1, T2, X0, X1, X2) const;
363	ResultConstMemberCallback3_3 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2)
364	: ResultCallback3<R, X0, X1, X2>(is_permanent),
365	c_(c),
366	p0_(p0),
367	p1_(p1),
368	p2_(p2),
369	fun_(fun) {
370	}
371	protected:
372	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
373	return (c_->*fun_)(p0_, p1_, p2_, x0, x1, x2);
374	}
375	private:
376	const C* c_;
377	T0 p0_;
378	T1 p1_;
379	T2 p2_;
380	Fun fun_;
381	};
382
383	template<typename C, typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
384	ResultConstMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, T2, X0, X1, X2) const, T0 p0, T1 p1, T2 p2) {
385	return new ResultConstMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>(false, c, fun, p0, p1, p2);
386	}
387	template<typename C, typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
388	ResultConstMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, T2, X0, X1, X2) const, T0 p0, T1 p1, T2 p2) {
389	return new ResultConstMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>(true, c, fun, p0, p1, p2);
390	}
391
392
393
394	template<typename C, typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
395	class ResultMemberCallback3_3 : public ResultCallback3<R, X0, X1, X2> {
396	public:
397	typedef R (C::*Fun)(T0, T1, T2, X0, X1, X2);
398	ResultMemberCallback3_3 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2)
399	: ResultCallback3<R, X0, X1, X2>(is_permanent),
400	c_(c),
401	p0_(p0),
402	p1_(p1),
403	p2_(p2),
404	fun_(fun) {
405	}
406	protected:
407	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
408	return (c_->*fun_)(p0_, p1_, p2_, x0, x1, x2);
409	}
410	private:
411	C* c_;
412	T0 p0_;
413	T1 p1_;
414	T2 p2_;
415	Fun fun_;
416	};
417
418	template<typename C, typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
419	ResultMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, T2, X0, X1, X2), T0 p0, T1 p1, T2 p2) {
420	return new ResultMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>(false, c, fun, p0, p1, p2);
421	}
422	template<typename C, typename R, typename T0, typename T1, typename T2, typename X0, typename X1, typename X2>
423	ResultMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, T2, X0, X1, X2), T0 p0, T1 p1, T2 p2) {
424	return new ResultMemberCallback3_3<C, R, T0, T1, T2, X0, X1, X2>(true, c, fun, p0, p1, p2);
425	}
426
427
428
429	template<typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
430	class ResultCallback3_4 : public ResultCallback3<R, X0, X1, X2> {
431	public:
432	typedef R (*Fun)(T0, T1, T2, T3, X0, X1, X2);
433	ResultCallback3_4(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3)
434	: ResultCallback3<R, X0, X1, X2>(is_permanent),
435	p0_(p0),
436	p1_(p1),
437	p2_(p2),
438	p3_(p3),
439	fun_(fun) {
440	}
441	protected:
442	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
443	return (*fun_)(p0_, p1_, p2_, p3_, x0, x1, x2);
444	}
445	private:
446	T0 p0_;
447	T1 p1_;
448	T2 p2_;
449	T3 p3_;
450	Fun fun_;
451	};
452	template<typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
453	ResultCallback3_4<R, T0, T1, T2, T3, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, T2, T3, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3) {
454	return new ResultCallback3_4<R, T0, T1, T2, T3, X0, X1, X2>(false, fun, p0, p1, p2, p3);
455	}
456	template<typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
457	ResultCallback3_4<R, T0, T1, T2, T3, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, T2, T3, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3) {
458	return new ResultCallback3_4<R, T0, T1, T2, T3, X0, X1, X2>(true, fun, p0, p1, p2, p3);
459	}
460
461
462	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
463	class ResultConstMemberCallback3_4 : public ResultCallback3<R, X0, X1, X2> {
464	public:
465	typedef R (C::*Fun)(T0, T1, T2, T3, X0, X1, X2) const;
466	ResultConstMemberCallback3_4 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3)
467	: ResultCallback3<R, X0, X1, X2>(is_permanent),
468	c_(c),
469	p0_(p0),
470	p1_(p1),
471	p2_(p2),
472	p3_(p3),
473	fun_(fun) {
474	}
475	protected:
476	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
477	return (c_->*fun_)(p0_, p1_, p2_, p3_, x0, x1, x2);
478	}
479	private:
480	const C* c_;
481	T0 p0_;
482	T1 p1_;
483	T2 p2_;
484	T3 p3_;
485	Fun fun_;
486	};
487
488	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
489	ResultConstMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3) {
490	return new ResultConstMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>(false, c, fun, p0, p1, p2, p3);
491	}
492	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
493	ResultConstMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3) {
494	return new ResultConstMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>(true, c, fun, p0, p1, p2, p3);
495	}
496
497
498
499	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
500	class ResultMemberCallback3_4 : public ResultCallback3<R, X0, X1, X2> {
501	public:
502	typedef R (C::*Fun)(T0, T1, T2, T3, X0, X1, X2);
503	ResultMemberCallback3_4 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3)
504	: ResultCallback3<R, X0, X1, X2>(is_permanent),
505	c_(c),
506	p0_(p0),
507	p1_(p1),
508	p2_(p2),
509	p3_(p3),
510	fun_(fun) {
511	}
512	protected:
513	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
514	return (c_->*fun_)(p0_, p1_, p2_, p3_, x0, x1, x2);
515	}
516	private:
517	C* c_;
518	T0 p0_;
519	T1 p1_;
520	T2 p2_;
521	T3 p3_;
522	Fun fun_;
523	};
524
525	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
526	ResultMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, T2, T3, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3) {
527	return new ResultMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>(false, c, fun, p0, p1, p2, p3);
528	}
529	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1, typename X2>
530	ResultMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, T2, T3, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3) {
531	return new ResultMemberCallback3_4<C, R, T0, T1, T2, T3, X0, X1, X2>(true, c, fun, p0, p1, p2, p3);
532	}
533
534
535
536	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
537	class ResultCallback3_5 : public ResultCallback3<R, X0, X1, X2> {
538	public:
539	typedef R (*Fun)(T0, T1, T2, T3, T4, X0, X1, X2);
540	ResultCallback3_5(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
541	: ResultCallback3<R, X0, X1, X2>(is_permanent),
542	p0_(p0),
543	p1_(p1),
544	p2_(p2),
545	p3_(p3),
546	p4_(p4),
547	fun_(fun) {
548	}
549	protected:
550	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
551	return (*fun_)(p0_, p1_, p2_, p3_, p4_, x0, x1, x2);
552	}
553	private:
554	T0 p0_;
555	T1 p1_;
556	T2 p2_;
557	T3 p3_;
558	T4 p4_;
559	Fun fun_;
560	};
561	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
562	ResultCallback3_5<R, T0, T1, T2, T3, T4, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, T2, T3, T4, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
563	return new ResultCallback3_5<R, T0, T1, T2, T3, T4, X0, X1, X2>(false, fun, p0, p1, p2, p3, p4);
564	}
565	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
566	ResultCallback3_5<R, T0, T1, T2, T3, T4, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, T2, T3, T4, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
567	return new ResultCallback3_5<R, T0, T1, T2, T3, T4, X0, X1, X2>(true, fun, p0, p1, p2, p3, p4);
568	}
569
570
571	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
572	class ResultConstMemberCallback3_5 : public ResultCallback3<R, X0, X1, X2> {
573	public:
574	typedef R (C::*Fun)(T0, T1, T2, T3, T4, X0, X1, X2) const;
575	ResultConstMemberCallback3_5 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
576	: ResultCallback3<R, X0, X1, X2>(is_permanent),
577	c_(c),
578	p0_(p0),
579	p1_(p1),
580	p2_(p2),
581	p3_(p3),
582	p4_(p4),
583	fun_(fun) {
584	}
585	protected:
586	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
587	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, x0, x1, x2);
588	}
589	private:
590	const C* c_;
591	T0 p0_;
592	T1 p1_;
593	T2 p2_;
594	T3 p3_;
595	T4 p4_;
596	Fun fun_;
597	};
598
599	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
600	ResultConstMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
601	return new ResultConstMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4);
602	}
603	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
604	ResultConstMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
605	return new ResultConstMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4);
606	}
607
608
609
610	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
611	class ResultMemberCallback3_5 : public ResultCallback3<R, X0, X1, X2> {
612	public:
613	typedef R (C::*Fun)(T0, T1, T2, T3, T4, X0, X1, X2);
614	ResultMemberCallback3_5 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
615	: ResultCallback3<R, X0, X1, X2>(is_permanent),
616	c_(c),
617	p0_(p0),
618	p1_(p1),
619	p2_(p2),
620	p3_(p3),
621	p4_(p4),
622	fun_(fun) {
623	}
624	protected:
625	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
626	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, x0, x1, x2);
627	}
628	private:
629	C* c_;
630	T0 p0_;
631	T1 p1_;
632	T2 p2_;
633	T3 p3_;
634	T4 p4_;
635	Fun fun_;
636	};
637
638	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
639	ResultMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
640	return new ResultMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4);
641	}
642	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1, typename X2>
643	ResultMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
644	return new ResultMemberCallback3_5<C, R, T0, T1, T2, T3, T4, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4);
645	}
646
647
648
649	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
650	class ResultCallback3_6 : public ResultCallback3<R, X0, X1, X2> {
651	public:
652	typedef R (*Fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2);
653	ResultCallback3_6(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
654	: ResultCallback3<R, X0, X1, X2>(is_permanent),
655	p0_(p0),
656	p1_(p1),
657	p2_(p2),
658	p3_(p3),
659	p4_(p4),
660	p5_(p5),
661	fun_(fun) {
662	}
663	protected:
664	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
665	return (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, x0, x1, x2);
666	}
667	private:
668	T0 p0_;
669	T1 p1_;
670	T2 p2_;
671	T3 p3_;
672	T4 p4_;
673	T5 p5_;
674	Fun fun_;
675	};
676	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
677	ResultCallback3_6<R, T0, T1, T2, T3, T4, T5, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
678	return new ResultCallback3_6<R, T0, T1, T2, T3, T4, T5, X0, X1, X2>(false, fun, p0, p1, p2, p3, p4, p5);
679	}
680	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
681	ResultCallback3_6<R, T0, T1, T2, T3, T4, T5, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
682	return new ResultCallback3_6<R, T0, T1, T2, T3, T4, T5, X0, X1, X2>(true, fun, p0, p1, p2, p3, p4, p5);
683	}
684
685
686	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
687	class ResultConstMemberCallback3_6 : public ResultCallback3<R, X0, X1, X2> {
688	public:
689	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2) const;
690	ResultConstMemberCallback3_6 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
691	: ResultCallback3<R, X0, X1, X2>(is_permanent),
692	c_(c),
693	p0_(p0),
694	p1_(p1),
695	p2_(p2),
696	p3_(p3),
697	p4_(p4),
698	p5_(p5),
699	fun_(fun) {
700	}
701	protected:
702	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
703	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, x0, x1, x2);
704	}
705	private:
706	const C* c_;
707	T0 p0_;
708	T1 p1_;
709	T2 p2_;
710	T3 p3_;
711	T4 p4_;
712	T5 p5_;
713	Fun fun_;
714	};
715
716	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
717	ResultConstMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
718	return new ResultConstMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5);
719	}
720	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
721	ResultConstMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
722	return new ResultConstMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5);
723	}
724
725
726
727	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
728	class ResultMemberCallback3_6 : public ResultCallback3<R, X0, X1, X2> {
729	public:
730	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2);
731	ResultMemberCallback3_6 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
732	: ResultCallback3<R, X0, X1, X2>(is_permanent),
733	c_(c),
734	p0_(p0),
735	p1_(p1),
736	p2_(p2),
737	p3_(p3),
738	p4_(p4),
739	p5_(p5),
740	fun_(fun) {
741	}
742	protected:
743	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
744	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, x0, x1, x2);
745	}
746	private:
747	C* c_;
748	T0 p0_;
749	T1 p1_;
750	T2 p2_;
751	T3 p3_;
752	T4 p4_;
753	T5 p5_;
754	Fun fun_;
755	};
756
757	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
758	ResultMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
759	return new ResultMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5);
760	}
761	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1, typename X2>
762	ResultMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
763	return new ResultMemberCallback3_6<C, R, T0, T1, T2, T3, T4, T5, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5);
764	}
765
766
767
768	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
769	class ResultCallback3_7 : public ResultCallback3<R, X0, X1, X2> {
770	public:
771	typedef R (*Fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2);
772	ResultCallback3_7(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
773	: ResultCallback3<R, X0, X1, X2>(is_permanent),
774	p0_(p0),
775	p1_(p1),
776	p2_(p2),
777	p3_(p3),
778	p4_(p4),
779	p5_(p5),
780	p6_(p6),
781	fun_(fun) {
782	}
783	protected:
784	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
785	return (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, x0, x1, x2);
786	}
787	private:
788	T0 p0_;
789	T1 p1_;
790	T2 p2_;
791	T3 p3_;
792	T4 p4_;
793	T5 p5_;
794	T6 p6_;
795	Fun fun_;
796	};
797	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
798	ResultCallback3_7<R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
799	return new ResultCallback3_7<R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>(false, fun, p0, p1, p2, p3, p4, p5, p6);
800	}
801	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
802	ResultCallback3_7<R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
803	return new ResultCallback3_7<R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>(true, fun, p0, p1, p2, p3, p4, p5, p6);
804	}
805
806
807	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
808	class ResultConstMemberCallback3_7 : public ResultCallback3<R, X0, X1, X2> {
809	public:
810	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2) const;
811	ResultConstMemberCallback3_7 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
812	: ResultCallback3<R, X0, X1, X2>(is_permanent),
813	c_(c),
814	p0_(p0),
815	p1_(p1),
816	p2_(p2),
817	p3_(p3),
818	p4_(p4),
819	p5_(p5),
820	p6_(p6),
821	fun_(fun) {
822	}
823	protected:
824	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
825	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, x0, x1, x2);
826	}
827	private:
828	const C* c_;
829	T0 p0_;
830	T1 p1_;
831	T2 p2_;
832	T3 p3_;
833	T4 p4_;
834	T5 p5_;
835	T6 p6_;
836	Fun fun_;
837	};
838
839	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
840	ResultConstMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
841	return new ResultConstMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5, p6);
842	}
843	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
844	ResultConstMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
845	return new ResultConstMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5, p6);
846	}
847
848
849
850	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
851	class ResultMemberCallback3_7 : public ResultCallback3<R, X0, X1, X2> {
852	public:
853	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2);
854	ResultMemberCallback3_7 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
855	: ResultCallback3<R, X0, X1, X2>(is_permanent),
856	c_(c),
857	p0_(p0),
858	p1_(p1),
859	p2_(p2),
860	p3_(p3),
861	p4_(p4),
862	p5_(p5),
863	p6_(p6),
864	fun_(fun) {
865	}
866	protected:
867	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
868	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, x0, x1, x2);
869	}
870	private:
871	C* c_;
872	T0 p0_;
873	T1 p1_;
874	T2 p2_;
875	T3 p3_;
876	T4 p4_;
877	T5 p5_;
878	T6 p6_;
879	Fun fun_;
880	};
881
882	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
883	ResultMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
884	return new ResultMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5, p6);
885	}
886	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1, typename X2>
887	ResultMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
888	return new ResultMemberCallback3_7<C, R, T0, T1, T2, T3, T4, T5, T6, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5, p6);
889	}
890
891
892
893	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
894	class ResultCallback3_8 : public ResultCallback3<R, X0, X1, X2> {
895	public:
896	typedef R (*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2);
897	ResultCallback3_8(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
898	: ResultCallback3<R, X0, X1, X2>(is_permanent),
899	p0_(p0),
900	p1_(p1),
901	p2_(p2),
902	p3_(p3),
903	p4_(p4),
904	p5_(p5),
905	p6_(p6),
906	p7_(p7),
907	fun_(fun) {
908	}
909	protected:
910	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
911	return (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, x0, x1, x2);
912	}
913	private:
914	T0 p0_;
915	T1 p1_;
916	T2 p2_;
917	T3 p3_;
918	T4 p4_;
919	T5 p5_;
920	T6 p6_;
921	T7 p7_;
922	Fun fun_;
923	};
924	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
925	ResultCallback3_8<R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
926	return new ResultCallback3_8<R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>(false, fun, p0, p1, p2, p3, p4, p5, p6, p7);
927	}
928	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
929	ResultCallback3_8<R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
930	return new ResultCallback3_8<R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>(true, fun, p0, p1, p2, p3, p4, p5, p6, p7);
931	}
932
933
934	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
935	class ResultConstMemberCallback3_8 : public ResultCallback3<R, X0, X1, X2> {
936	public:
937	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2) const;
938	ResultConstMemberCallback3_8 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
939	: ResultCallback3<R, X0, X1, X2>(is_permanent),
940	c_(c),
941	p0_(p0),
942	p1_(p1),
943	p2_(p2),
944	p3_(p3),
945	p4_(p4),
946	p5_(p5),
947	p6_(p6),
948	p7_(p7),
949	fun_(fun) {
950	}
951	protected:
952	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
953	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, x0, x1, x2);
954	}
955	private:
956	const C* c_;
957	T0 p0_;
958	T1 p1_;
959	T2 p2_;
960	T3 p3_;
961	T4 p4_;
962	T5 p5_;
963	T6 p6_;
964	T7 p7_;
965	Fun fun_;
966	};
967
968	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
969	ResultConstMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
970	return new ResultConstMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
971	}
972	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
973	ResultConstMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
974	return new ResultConstMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
975	}
976
977
978
979	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
980	class ResultMemberCallback3_8 : public ResultCallback3<R, X0, X1, X2> {
981	public:
982	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2);
983	ResultMemberCallback3_8 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
984	: ResultCallback3<R, X0, X1, X2>(is_permanent),
985	c_(c),
986	p0_(p0),
987	p1_(p1),
988	p2_(p2),
989	p3_(p3),
990	p4_(p4),
991	p5_(p5),
992	p6_(p6),
993	p7_(p7),
994	fun_(fun) {
995	}
996	protected:
997	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
998	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, x0, x1, x2);
999	}
1000	private:
1001	C* c_;
1002	T0 p0_;
1003	T1 p1_;
1004	T2 p2_;
1005	T3 p3_;
1006	T4 p4_;
1007	T5 p5_;
1008	T6 p6_;
1009	T7 p7_;
1010	Fun fun_;
1011	};
1012
1013	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
1014	ResultMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
1015	return new ResultMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
1016	}
1017	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1, typename X2>
1018	ResultMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
1019	return new ResultMemberCallback3_8<C, R, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
1020	}
1021
1022
1023
1024	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1025	class ResultCallback3_9 : public ResultCallback3<R, X0, X1, X2> {
1026	public:
1027	typedef R (*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2);
1028	ResultCallback3_9(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
1029	: ResultCallback3<R, X0, X1, X2>(is_permanent),
1030	p0_(p0),
1031	p1_(p1),
1032	p2_(p2),
1033	p3_(p3),
1034	p4_(p4),
1035	p5_(p5),
1036	p6_(p6),
1037	p7_(p7),
1038	p8_(p8),
1039	fun_(fun) {
1040	}
1041	protected:
1042	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
1043	return (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, p8_, x0, x1, x2);
1044	}
1045	private:
1046	T0 p0_;
1047	T1 p1_;
1048	T2 p2_;
1049	T3 p3_;
1050	T4 p4_;
1051	T5 p5_;
1052	T6 p6_;
1053	T7 p7_;
1054	T8 p8_;
1055	Fun fun_;
1056	};
1057	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1058	ResultCallback3_9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>* NewCallback(R (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1059	return new ResultCallback3_9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>(false, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1060	}
1061	template<typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1062	ResultCallback3_9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>* NewPermanentCallback(R (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1063	return new ResultCallback3_9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>(true, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1064	}
1065
1066
1067	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1068	class ResultConstMemberCallback3_9 : public ResultCallback3<R, X0, X1, X2> {
1069	public:
1070	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2) const;
1071	ResultConstMemberCallback3_9 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
1072	: ResultCallback3<R, X0, X1, X2>(is_permanent),
1073	c_(c),
1074	p0_(p0),
1075	p1_(p1),
1076	p2_(p2),
1077	p3_(p3),
1078	p4_(p4),
1079	p5_(p5),
1080	p6_(p6),
1081	p7_(p7),
1082	p8_(p8),
1083	fun_(fun) {
1084	}
1085	protected:
1086	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
1087	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, p8_, x0, x1, x2);
1088	}
1089	private:
1090	const C* c_;
1091	T0 p0_;
1092	T1 p1_;
1093	T2 p2_;
1094	T3 p3_;
1095	T4 p4_;
1096	T5 p5_;
1097	T6 p6_;
1098	T7 p7_;
1099	T8 p8_;
1100	Fun fun_;
1101	};
1102
1103	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1104	ResultConstMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>* NewCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1105	return new ResultConstMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1106	}
1107	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1108	ResultConstMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>* NewPermanentCallback(const C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1109	return new ResultConstMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1110	}
1111
1112
1113
1114	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1115	class ResultMemberCallback3_9 : public ResultCallback3<R, X0, X1, X2> {
1116	public:
1117	typedef R (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2);
1118	ResultMemberCallback3_9 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
1119	: ResultCallback3<R, X0, X1, X2>(is_permanent),
1120	c_(c),
1121	p0_(p0),
1122	p1_(p1),
1123	p2_(p2),
1124	p3_(p3),
1125	p4_(p4),
1126	p5_(p5),
1127	p6_(p6),
1128	p7_(p7),
1129	p8_(p8),
1130	fun_(fun) {
1131	}
1132	protected:
1133	virtual R RunInternal(X0 x0, X1 x1, X2 x2) {
1134	return (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, p8_, x0, x1, x2);
1135	}
1136	private:
1137	C* c_;
1138	T0 p0_;
1139	T1 p1_;
1140	T2 p2_;
1141	T3 p3_;
1142	T4 p4_;
1143	T5 p5_;
1144	T6 p6_;
1145	T7 p7_;
1146	T8 p8_;
1147	Fun fun_;
1148	};
1149
1150	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1151	ResultMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>* NewCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1152	return new ResultMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1153	}
1154	template<typename C, typename R, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1, typename X2>
1155	ResultMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>* NewPermanentCallback(C* c, R (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1156	return new ResultMemberCallback3_9<C, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1, X2>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1157	}
1158
1159	#endif // __COMMON_BASE_CALLBACK_RESULT_CALLBACK3_H__

Note: See TracBrowser for help on using the browser.

root/trunk/whisperlib/common/base/callback/result_callback3.h

Download in other formats: