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

Revision 7, 39.7 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_CALLBACK2_H__
32 #define __COMMON_BASE_CALLBACK_CALLBACK2_H__
33
34 #include <whisperlib/common/base/callback/callback.h>
35
36 template<typename X0, typename X1>
37 class Callback2 : public Callback {
38 public:
39   Callback2(bool is_permanent)
40     : Callback(),
41       is_permanent_(is_permanent) {
42   }
43   virtual ~Callback2() {
44   }
45   void Run(X0 x0, X1 x1) {
46     const bool permanent = is_permanent();
47     RunInternal(x0, x1);
48     if ( !permanent ) {
49       delete this;
50     }
51   }
52   bool is_permanent() const { return is_permanent_; }
53 protected:
54   virtual void RunInternal(X0 x0, X1 x1) = 0;
55 private:
56   const bool is_permanent_;
57 };
58
59 //////////////////////////////////////////////////////////////////////
60
61 template<typename X0, typename X1>
62 class Callback2_0 : public Callback2<X0, X1> {
63 public:
64   typedef void (*Fun)(X0, X1);
65   Callback2_0(bool is_permanent, Fun fun)
66     : Callback2<X0, X1>(is_permanent),
67       fun_(fun) {
68   }
69 protected:
70   virtual void RunInternal(X0 x0, X1 x1) {
71     (*fun_)(x0, x1);
72   }
73 private:
74   Fun fun_;
75 };
76 template<typename X0, typename X1>
77 Callback2_0<X0, X1>* NewCallback(void (*fun)(X0, X1)) {
78   return new Callback2_0<X0, X1>(false, fun);
79 }
80 template<typename X0, typename X1>
81 Callback2_0<X0, X1>* NewPermanentCallback(void (*fun)(X0, X1)) {
82   return new Callback2_0<X0, X1>(true, fun);
83 }
84
85 template<typename C, typename X0, typename X1>
86 class MemberCallback2_0 : public Callback2<X0, X1> {
87 public:
88   typedef void (C::*Fun)(X0, X1);
89   MemberCallback2_0 (bool is_permanent, C* c, Fun fun)
90     : Callback2<X0, X1>(is_permanent),
91       c_(c),
92       fun_(fun) {
93   }
94 protected:
95   virtual void RunInternal(X0 x0, X1 x1) {
96     (c_->*fun_)(x0, x1);
97   }
98 private:
99   C* c_;
100   Fun fun_;
101 };
102
103 template<typename C, typename X0, typename X1>
104 MemberCallback2_0<C, X0, X1>* NewCallback(C* c, void (C::*fun)(X0, X1)) {
105   return new MemberCallback2_0<C, X0, X1>(false, c, fun);
106 }
107 template<typename C, typename X0, typename X1>
108 MemberCallback2_0<C, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(X0, X1)) {
109   return new MemberCallback2_0<C, X0, X1>(true, c, fun);
110 }
111
112 template<typename C, typename X0, typename X1>
113 class ConstMemberCallback2_0 : public Callback2<X0, X1> {
114 public:
115   typedef void (C::*Fun)(X0, X1) const;
116   ConstMemberCallback2_0 (bool is_permanent, const C* c, Fun fun)
117     : Callback2<X0, X1>(is_permanent),
118       c_(c),
119       fun_(fun) {
120   }
121 protected:
122   virtual void RunInternal(X0 x0, X1 x1) {
123     (c_->*fun_)(x0, x1);
124   }
125 private:
126   const C* c_;
127   Fun fun_;
128 };
129
130 template<typename C, typename X0, typename X1>
131 ConstMemberCallback2_0<C, X0, X1>* NewCallback(const C* c, void (C::*fun)(X0, X1) const) {
132   return new ConstMemberCallback2_0<C, X0, X1>(false, c, fun);
133 }
134 template<typename C, typename X0, typename X1>
135 ConstMemberCallback2_0<C, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(X0, X1) const) {
136   return new ConstMemberCallback2_0<C, X0, X1>(true, c, fun);
137 }
138
139 //////////////////////////////////////////////////////////////////////
140 //
141 // Autogenerated callback classes (w/ print_callback.py)
142 //
143
144 template<typename T0, typename X0, typename X1>
145 class Callback2_1 : public Callback2<X0, X1> {
146 public:
147   typedef void (*Fun)(T0, X0, X1);
148   Callback2_1(bool is_permanent, Fun fun, T0 p0)
149     : Callback2<X0, X1>(is_permanent),
150     p0_(p0),
151       fun_(fun) {
152   }
153 protected:
154   virtual void RunInternal(X0 x0, X1 x1) {
155     (*fun_)(p0_, x0, x1);
156   }
157 private:
158   T0 p0_;
159   Fun fun_;
160 };
161 template<typename T0, typename X0, typename X1>
162 Callback2_1<T0, X0, X1>* NewCallback(void (*fun)(T0, X0, X1), T0 p0) {
163   return new Callback2_1<T0, X0, X1>(false, fun, p0);
164 }
165 template<typename T0, typename X0, typename X1>
166 Callback2_1<T0, X0, X1>* NewPermanentCallback(void (*fun)(T0, X0, X1), T0 p0) {
167   return new Callback2_1<T0, X0, X1>(true, fun, p0);
168 }
169
170
171 template<typename C, typename T0, typename X0, typename X1>
172 class ConstMemberCallback2_1 : public Callback2<X0, X1> {
173 public:
174   typedef void (C::*Fun)(T0, X0, X1) const;
175   ConstMemberCallback2_1 (bool is_permanent, const C* c, Fun fun, T0 p0)
176     : Callback2<X0, X1>(is_permanent),
177     c_(c),
178     p0_(p0),
179       fun_(fun) {
180   }
181 protected:
182   virtual void RunInternal(X0 x0, X1 x1) {
183       (c_->*fun_)(p0_, x0, x1);
184   }
185 private:
186   const C* c_;
187   T0 p0_;
188   Fun fun_;
189 };
190
191 template<typename C, typename T0, typename X0, typename X1>
192 ConstMemberCallback2_1<C, T0, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, X0, X1) const, T0 p0) {
193   return new ConstMemberCallback2_1<C, T0, X0, X1>(false, c, fun, p0);
194 }
195 template<typename C, typename T0, typename X0, typename X1>
196 ConstMemberCallback2_1<C, T0, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, X0, X1) const, T0 p0) {
197   return new ConstMemberCallback2_1<C, T0, X0, X1>(true, c, fun, p0);
198 }
199
200
201
202 template<typename C, typename T0, typename X0, typename X1>
203 class MemberCallback2_1 : public Callback2<X0, X1> {
204 public:
205   typedef void (C::*Fun)(T0, X0, X1);
206   MemberCallback2_1 (bool is_permanent, C* c, Fun fun, T0 p0)
207     : Callback2<X0, X1>(is_permanent),
208     c_(c),
209     p0_(p0),
210       fun_(fun) {
211   }
212 protected:
213   virtual void RunInternal(X0 x0, X1 x1) {
214       (c_->*fun_)(p0_, x0, x1);
215   }
216 private:
217   C* c_;
218   T0 p0_;
219   Fun fun_;
220 };
221
222 template<typename C, typename T0, typename X0, typename X1>
223 MemberCallback2_1<C, T0, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, X0, X1), T0 p0) {
224   return new MemberCallback2_1<C, T0, X0, X1>(false, c, fun, p0);
225 }
226 template<typename C, typename T0, typename X0, typename X1>
227 MemberCallback2_1<C, T0, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, X0, X1), T0 p0) {
228   return new MemberCallback2_1<C, T0, X0, X1>(true, c, fun, p0);
229 }
230
231
232
233 template<typename T0, typename T1, typename X0, typename X1>
234 class Callback2_2 : public Callback2<X0, X1> {
235 public:
236   typedef void (*Fun)(T0, T1, X0, X1);
237   Callback2_2(bool is_permanent, Fun fun, T0 p0, T1 p1)
238     : Callback2<X0, X1>(is_permanent),
239     p0_(p0),
240 p1_(p1),
241       fun_(fun) {
242   }
243 protected:
244   virtual void RunInternal(X0 x0, X1 x1) {
245     (*fun_)(p0_, p1_, x0, x1);
246   }
247 private:
248   T0 p0_;
249 T1 p1_;
250   Fun fun_;
251 };
252 template<typename T0, typename T1, typename X0, typename X1>
253 Callback2_2<T0, T1, X0, X1>* NewCallback(void (*fun)(T0, T1, X0, X1), T0 p0, T1 p1) {
254   return new Callback2_2<T0, T1, X0, X1>(false, fun, p0, p1);
255 }
256 template<typename T0, typename T1, typename X0, typename X1>
257 Callback2_2<T0, T1, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, X0, X1), T0 p0, T1 p1) {
258   return new Callback2_2<T0, T1, X0, X1>(true, fun, p0, p1);
259 }
260
261
262 template<typename C, typename T0, typename T1, typename X0, typename X1>
263 class ConstMemberCallback2_2 : public Callback2<X0, X1> {
264 public:
265   typedef void (C::*Fun)(T0, T1, X0, X1) const;
266   ConstMemberCallback2_2 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1)
267     : Callback2<X0, X1>(is_permanent),
268     c_(c),
269     p0_(p0),
270 p1_(p1),
271       fun_(fun) {
272   }
273 protected:
274   virtual void RunInternal(X0 x0, X1 x1) {
275       (c_->*fun_)(p0_, p1_, x0, x1);
276   }
277 private:
278   const C* c_;
279   T0 p0_;
280 T1 p1_;
281   Fun fun_;
282 };
283
284 template<typename C, typename T0, typename T1, typename X0, typename X1>
285 ConstMemberCallback2_2<C, T0, T1, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, X0, X1) const, T0 p0, T1 p1) {
286   return new ConstMemberCallback2_2<C, T0, T1, X0, X1>(false, c, fun, p0, p1);
287 }
288 template<typename C, typename T0, typename T1, typename X0, typename X1>
289 ConstMemberCallback2_2<C, T0, T1, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, X0, X1) const, T0 p0, T1 p1) {
290   return new ConstMemberCallback2_2<C, T0, T1, X0, X1>(true, c, fun, p0, p1);
291 }
292
293
294
295 template<typename C, typename T0, typename T1, typename X0, typename X1>
296 class MemberCallback2_2 : public Callback2<X0, X1> {
297 public:
298   typedef void (C::*Fun)(T0, T1, X0, X1);
299   MemberCallback2_2 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1)
300     : Callback2<X0, X1>(is_permanent),
301     c_(c),
302     p0_(p0),
303 p1_(p1),
304       fun_(fun) {
305   }
306 protected:
307   virtual void RunInternal(X0 x0, X1 x1) {
308       (c_->*fun_)(p0_, p1_, x0, x1);
309   }
310 private:
311   C* c_;
312   T0 p0_;
313 T1 p1_;
314   Fun fun_;
315 };
316
317 template<typename C, typename T0, typename T1, typename X0, typename X1>
318 MemberCallback2_2<C, T0, T1, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, X0, X1), T0 p0, T1 p1) {
319   return new MemberCallback2_2<C, T0, T1, X0, X1>(false, c, fun, p0, p1);
320 }
321 template<typename C, typename T0, typename T1, typename X0, typename X1>
322 MemberCallback2_2<C, T0, T1, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, X0, X1), T0 p0, T1 p1) {
323   return new MemberCallback2_2<C, T0, T1, X0, X1>(true, c, fun, p0, p1);
324 }
325
326
327
328 template<typename T0, typename T1, typename T2, typename X0, typename X1>
329 class Callback2_3 : public Callback2<X0, X1> {
330 public:
331   typedef void (*Fun)(T0, T1, T2, X0, X1);
332   Callback2_3(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2)
333     : Callback2<X0, X1>(is_permanent),
334     p0_(p0),
335 p1_(p1),
336 p2_(p2),
337       fun_(fun) {
338   }
339 protected:
340   virtual void RunInternal(X0 x0, X1 x1) {
341     (*fun_)(p0_, p1_, p2_, x0, x1);
342   }
343 private:
344   T0 p0_;
345 T1 p1_;
346 T2 p2_;
347   Fun fun_;
348 };
349 template<typename T0, typename T1, typename T2, typename X0, typename X1>
350 Callback2_3<T0, T1, T2, X0, X1>* NewCallback(void (*fun)(T0, T1, T2, X0, X1), T0 p0, T1 p1, T2 p2) {
351   return new Callback2_3<T0, T1, T2, X0, X1>(false, fun, p0, p1, p2);
352 }
353 template<typename T0, typename T1, typename T2, typename X0, typename X1>
354 Callback2_3<T0, T1, T2, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, T2, X0, X1), T0 p0, T1 p1, T2 p2) {
355   return new Callback2_3<T0, T1, T2, X0, X1>(true, fun, p0, p1, p2);
356 }
357
358
359 template<typename C, typename T0, typename T1, typename T2, typename X0, typename X1>
360 class ConstMemberCallback2_3 : public Callback2<X0, X1> {
361 public:
362   typedef void (C::*Fun)(T0, T1, T2, X0, X1) const;
363   ConstMemberCallback2_3 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2)
364     : Callback2<X0, X1>(is_permanent),
365     c_(c),
366     p0_(p0),
367 p1_(p1),
368 p2_(p2),
369       fun_(fun) {
370   }
371 protected:
372   virtual void RunInternal(X0 x0, X1 x1) {
373       (c_->*fun_)(p0_, p1_, p2_, x0, x1);
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 T0, typename T1, typename T2, typename X0, typename X1>
384 ConstMemberCallback2_3<C, T0, T1, T2, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, T2, X0, X1) const, T0 p0, T1 p1, T2 p2) {
385   return new ConstMemberCallback2_3<C, T0, T1, T2, X0, X1>(false, c, fun, p0, p1, p2);
386 }
387 template<typename C, typename T0, typename T1, typename T2, typename X0, typename X1>
388 ConstMemberCallback2_3<C, T0, T1, T2, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, T2, X0, X1) const, T0 p0, T1 p1, T2 p2) {
389   return new ConstMemberCallback2_3<C, T0, T1, T2, X0, X1>(true, c, fun, p0, p1, p2);
390 }
391
392
393
394 template<typename C, typename T0, typename T1, typename T2, typename X0, typename X1>
395 class MemberCallback2_3 : public Callback2<X0, X1> {
396 public:
397   typedef void (C::*Fun)(T0, T1, T2, X0, X1);
398   MemberCallback2_3 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2)
399     : Callback2<X0, X1>(is_permanent),
400     c_(c),
401     p0_(p0),
402 p1_(p1),
403 p2_(p2),
404       fun_(fun) {
405   }
406 protected:
407   virtual void RunInternal(X0 x0, X1 x1) {
408       (c_->*fun_)(p0_, p1_, p2_, x0, x1);
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 T0, typename T1, typename T2, typename X0, typename X1>
419 MemberCallback2_3<C, T0, T1, T2, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, T2, X0, X1), T0 p0, T1 p1, T2 p2) {
420   return new MemberCallback2_3<C, T0, T1, T2, X0, X1>(false, c, fun, p0, p1, p2);
421 }
422 template<typename C, typename T0, typename T1, typename T2, typename X0, typename X1>
423 MemberCallback2_3<C, T0, T1, T2, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, T2, X0, X1), T0 p0, T1 p1, T2 p2) {
424   return new MemberCallback2_3<C, T0, T1, T2, X0, X1>(true, c, fun, p0, p1, p2);
425 }
426
427
428
429 template<typename T0, typename T1, typename T2, typename T3, typename X0, typename X1>
430 class Callback2_4 : public Callback2<X0, X1> {
431 public:
432   typedef void (*Fun)(T0, T1, T2, T3, X0, X1);
433   Callback2_4(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3)
434     : Callback2<X0, X1>(is_permanent),
435     p0_(p0),
436 p1_(p1),
437 p2_(p2),
438 p3_(p3),
439       fun_(fun) {
440   }
441 protected:
442   virtual void RunInternal(X0 x0, X1 x1) {
443     (*fun_)(p0_, p1_, p2_, p3_, x0, x1);
444   }
445 private:
446   T0 p0_;
447 T1 p1_;
448 T2 p2_;
449 T3 p3_;
450   Fun fun_;
451 };
452 template<typename T0, typename T1, typename T2, typename T3, typename X0, typename X1>
453 Callback2_4<T0, T1, T2, T3, X0, X1>* NewCallback(void (*fun)(T0, T1, T2, T3, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3) {
454   return new Callback2_4<T0, T1, T2, T3, X0, X1>(false, fun, p0, p1, p2, p3);
455 }
456 template<typename T0, typename T1, typename T2, typename T3, typename X0, typename X1>
457 Callback2_4<T0, T1, T2, T3, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, T2, T3, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3) {
458   return new Callback2_4<T0, T1, T2, T3, X0, X1>(true, fun, p0, p1, p2, p3);
459 }
460
461
462 template<typename C, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1>
463 class ConstMemberCallback2_4 : public Callback2<X0, X1> {
464 public:
465   typedef void (C::*Fun)(T0, T1, T2, T3, X0, X1) const;
466   ConstMemberCallback2_4 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3)
467     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
477       (c_->*fun_)(p0_, p1_, p2_, p3_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename X0, typename X1>
489 ConstMemberCallback2_4<C, T0, T1, T2, T3, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3) {
490   return new ConstMemberCallback2_4<C, T0, T1, T2, T3, X0, X1>(false, c, fun, p0, p1, p2, p3);
491 }
492 template<typename C, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1>
493 ConstMemberCallback2_4<C, T0, T1, T2, T3, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3) {
494   return new ConstMemberCallback2_4<C, T0, T1, T2, T3, X0, X1>(true, c, fun, p0, p1, p2, p3);
495 }
496
497
498
499 template<typename C, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1>
500 class MemberCallback2_4 : public Callback2<X0, X1> {
501 public:
502   typedef void (C::*Fun)(T0, T1, T2, T3, X0, X1);
503   MemberCallback2_4 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3)
504     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
514       (c_->*fun_)(p0_, p1_, p2_, p3_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename X0, typename X1>
526 MemberCallback2_4<C, T0, T1, T2, T3, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, T2, T3, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3) {
527   return new MemberCallback2_4<C, T0, T1, T2, T3, X0, X1>(false, c, fun, p0, p1, p2, p3);
528 }
529 template<typename C, typename T0, typename T1, typename T2, typename T3, typename X0, typename X1>
530 MemberCallback2_4<C, T0, T1, T2, T3, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, T2, T3, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3) {
531   return new MemberCallback2_4<C, T0, T1, T2, T3, X0, X1>(true, c, fun, p0, p1, p2, p3);
532 }
533
534
535
536 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
537 class Callback2_5 : public Callback2<X0, X1> {
538 public:
539   typedef void (*Fun)(T0, T1, T2, T3, T4, X0, X1);
540   Callback2_5(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
541     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
551     (*fun_)(p0_, p1_, p2_, p3_, p4_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
562 Callback2_5<T0, T1, T2, T3, T4, X0, X1>* NewCallback(void (*fun)(T0, T1, T2, T3, T4, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
563   return new Callback2_5<T0, T1, T2, T3, T4, X0, X1>(false, fun, p0, p1, p2, p3, p4);
564 }
565 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
566 Callback2_5<T0, T1, T2, T3, T4, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, T2, T3, T4, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
567   return new Callback2_5<T0, T1, T2, T3, T4, X0, X1>(true, fun, p0, p1, p2, p3, p4);
568 }
569
570
571 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
572 class ConstMemberCallback2_5 : public Callback2<X0, X1> {
573 public:
574   typedef void (C::*Fun)(T0, T1, T2, T3, T4, X0, X1) const;
575   ConstMemberCallback2_5 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
576     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
587       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
600 ConstMemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
601   return new ConstMemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>(false, c, fun, p0, p1, p2, p3, p4);
602 }
603 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
604 ConstMemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
605   return new ConstMemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>(true, c, fun, p0, p1, p2, p3, p4);
606 }
607
608
609
610 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
611 class MemberCallback2_5 : public Callback2<X0, X1> {
612 public:
613   typedef void (C::*Fun)(T0, T1, T2, T3, T4, X0, X1);
614   MemberCallback2_5 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
615     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
626       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
639 MemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
640   return new MemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>(false, c, fun, p0, p1, p2, p3, p4);
641 }
642 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename X0, typename X1>
643 MemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4) {
644   return new MemberCallback2_5<C, T0, T1, T2, T3, T4, X0, X1>(true, c, fun, p0, p1, p2, p3, p4);
645 }
646
647
648
649 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
650 class Callback2_6 : public Callback2<X0, X1> {
651 public:
652   typedef void (*Fun)(T0, T1, T2, T3, T4, T5, X0, X1);
653   Callback2_6(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
654     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
665     (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
677 Callback2_6<T0, T1, T2, T3, T4, T5, X0, X1>* NewCallback(void (*fun)(T0, T1, T2, T3, T4, T5, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
678   return new Callback2_6<T0, T1, T2, T3, T4, T5, X0, X1>(false, fun, p0, p1, p2, p3, p4, p5);
679 }
680 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
681 Callback2_6<T0, T1, T2, T3, T4, T5, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, T2, T3, T4, T5, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
682   return new Callback2_6<T0, T1, T2, T3, T4, T5, X0, X1>(true, fun, p0, p1, p2, p3, p4, p5);
683 }
684
685
686 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
687 class ConstMemberCallback2_6 : public Callback2<X0, X1> {
688 public:
689   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, X0, X1) const;
690   ConstMemberCallback2_6 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
691     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
703       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
717 ConstMemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
718   return new ConstMemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5);
719 }
720 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
721 ConstMemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
722   return new ConstMemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5);
723 }
724
725
726
727 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
728 class MemberCallback2_6 : public Callback2<X0, X1> {
729 public:
730   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, X0, X1);
731   MemberCallback2_6 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
732     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
744       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
758 MemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
759   return new MemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5);
760 }
761 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename X0, typename X1>
762 MemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) {
763   return new MemberCallback2_6<C, T0, T1, T2, T3, T4, T5, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5);
764 }
765
766
767
768 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
769 class Callback2_7 : public Callback2<X0, X1> {
770 public:
771   typedef void (*Fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1);
772   Callback2_7(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
773     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
785     (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
798 Callback2_7<T0, T1, T2, T3, T4, T5, T6, X0, X1>* NewCallback(void (*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
799   return new Callback2_7<T0, T1, T2, T3, T4, T5, T6, X0, X1>(false, fun, p0, p1, p2, p3, p4, p5, p6);
800 }
801 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
802 Callback2_7<T0, T1, T2, T3, T4, T5, T6, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
803   return new Callback2_7<T0, T1, T2, T3, T4, T5, T6, X0, X1>(true, fun, p0, p1, p2, p3, p4, p5, p6);
804 }
805
806
807 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
808 class ConstMemberCallback2_7 : public Callback2<X0, X1> {
809 public:
810   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1) const;
811   ConstMemberCallback2_7 (bool is_permanent, const C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
812     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
825       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
840 ConstMemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
841   return new ConstMemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5, p6);
842 }
843 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
844 ConstMemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
845   return new ConstMemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5, p6);
846 }
847
848
849
850 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
851 class MemberCallback2_7 : public Callback2<X0, X1> {
852 public:
853   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1);
854   MemberCallback2_7 (bool is_permanent, C* c, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
855     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
868       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
883 MemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
884   return new MemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5, p6);
885 }
886 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename X0, typename X1>
887 MemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6) {
888   return new MemberCallback2_7<C, T0, T1, T2, T3, T4, T5, T6, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5, p6);
889 }
890
891
892
893 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
894 class Callback2_8 : public Callback2<X0, X1> {
895 public:
896   typedef void (*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1);
897   Callback2_8(bool is_permanent, Fun fun, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
898     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
911     (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
925 Callback2_8<T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>* NewCallback(void (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
926   return new Callback2_8<T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>(false, fun, p0, p1, p2, p3, p4, p5, p6, p7);
927 }
928 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
929 Callback2_8<T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
930   return new Callback2_8<T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>(true, fun, p0, p1, p2, p3, p4, p5, p6, p7);
931 }
932
933
934 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
935 class ConstMemberCallback2_8 : public Callback2<X0, X1> {
936 public:
937   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1) const;
938   ConstMemberCallback2_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     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
953       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
969 ConstMemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
970   return new ConstMemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
971 }
972 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
973 ConstMemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
974   return new ConstMemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
975 }
976
977
978
979 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
980 class MemberCallback2_8 : public Callback2<X0, X1> {
981 public:
982   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1);
983   MemberCallback2_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     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
998       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
1014 MemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
1015   return new MemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
1016 }
1017 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename X0, typename X1>
1018 MemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7) {
1019   return new MemberCallback2_8<C, T0, T1, T2, T3, T4, T5, T6, T7, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7);
1020 }
1021
1022
1023
1024 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1025 class Callback2_9 : public Callback2<X0, X1> {
1026 public:
1027   typedef void (*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1);
1028   Callback2_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     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
1043     (*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, p8_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1058 Callback2_9<T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>* NewCallback(void (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1059   return new Callback2_9<T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>(false, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1060 }
1061 template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1062 Callback2_9<T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>* NewPermanentCallback(void (*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1063   return new Callback2_9<T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>(true, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1064 }
1065
1066
1067 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1068 class ConstMemberCallback2_9 : public Callback2<X0, X1> {
1069 public:
1070   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1) const;
1071   ConstMemberCallback2_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     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
1087       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, p8_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1104 ConstMemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>* NewCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1105   return new ConstMemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1106 }
1107 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1108 ConstMemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>* NewPermanentCallback(const C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1) const, T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1109   return new ConstMemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1110 }
1111
1112
1113
1114 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1115 class MemberCallback2_9 : public Callback2<X0, X1> {
1116 public:
1117   typedef void (C::*Fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1);
1118   MemberCallback2_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     : Callback2<X0, X1>(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 void RunInternal(X0 x0, X1 x1) {
1134       (c_->*fun_)(p0_, p1_, p2_, p3_, p4_, p5_, p6_, p7_, p8_, x0, x1);
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 T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1151 MemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>* NewCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1152   return new MemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>(false, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1153 }
1154 template<typename C, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename X0, typename X1>
1155 MemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>* NewPermanentCallback(C* c, void (C::*fun)(T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1), T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8) {
1156   return new MemberCallback2_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, X0, X1>(true, c, fun, p0, p1, p2, p3, p4, p5, p6, p7, p8);
1157 }
1158
1159 #endif   //  __COMMON_BASE_CALLBACK_CALLBACK2_H__
Note: See TracBrowser for help on using the browser.