All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
tesscallback.h
Go to the documentation of this file.
1 // File: tesscallback.h
3 // Description: classes and functions to replace pointer-to-functions
4 // Author: Samuel Charron
5 //
6 // (C) Copyright 2006, Google Inc.
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 // http://www.apache.org/licenses/LICENSE-2.0
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
18 
19 #ifndef _TESS_CALLBACK_SPECIALIZATIONS_H
20 #define _TESS_CALLBACK_SPECIALIZATIONS_H
21 
22 #include "host.h" // For NULL.
23 
25  static void FailIsRepeatable(const char* name);
26 };
27 
28 
29 class TessClosure {
30  public:
31  virtual ~TessClosure() { }
32  virtual void Run() = 0;
33 };
34 
35 template <class R>
37  public:
38  virtual ~TessResultCallback() { }
39  virtual R Run() = 0;
40 };
41 
42 template <bool del, class R, class T>
44  public:
46  typedef R (T::*MemberSignature)() const;
47 
48  private:
49  const T* object_;
50  MemberSignature member_;
51 
52  public:
54  const T* object, MemberSignature member)
55  : object_(object),
56  member_(member) {
57  }
58 
59  virtual R Run() {
60  if (!del) {
61  R result = (object_->*member_)();
62  return result;
63  } else {
64  R result = (object_->*member_)();
65  // zero out the pointer to ensure segfault if used again
66  member_ = NULL;
67  delete this;
68  return result;
69  }
70  }
71 };
72 
73 template <bool del, class T>
75  : public TessClosure {
76  public:
77  typedef TessClosure base;
78  typedef void (T::*MemberSignature)() const;
79 
80  private:
81  const T* object_;
82  MemberSignature member_;
83 
84  public:
86  const T* object, MemberSignature member)
87  : object_(object),
88  member_(member) {
89  }
90 
91  virtual void Run() {
92  if (!del) {
93  (object_->*member_)();
94  } else {
95  (object_->*member_)();
96  // zero out the pointer to ensure segfault if used again
97  member_ = NULL;
98  delete this;
99  }
100  }
101 };
102 
103 #ifndef SWIG
104 template <class T1, class T2, class R>
107  const T1* obj, R (T2::*member)() const) {
109  obj, member);
110 }
111 #endif
112 
113 #ifndef SWIG
114 template <class T1, class T2, class R>
117  const T1* obj, R (T2::*member)() const) {
119  obj, member);
120 }
121 #endif
122 
123 template <bool del, class R, class T>
125  public:
127  typedef R (T::*MemberSignature)() ;
128 
129  private:
130  T* object_;
131  MemberSignature member_;
132 
133  public:
135  T* object, MemberSignature member)
136  : object_(object),
137  member_(member) {
138  }
139 
140  virtual R Run() {
141  if (!del) {
142  R result = (object_->*member_)();
143  return result;
144  } else {
145  R result = (object_->*member_)();
146  // zero out the pointer to ensure segfault if used again
147  member_ = NULL;
148  delete this;
149  return result;
150  }
151  }
152 };
153 
154 template <bool del, class T>
155 class _TessMemberResultCallback_0_0<del, void, T>
156  : public TessClosure {
157  public:
158  typedef TessClosure base;
159  typedef void (T::*MemberSignature)() ;
160 
161  private:
162  T* object_;
163  MemberSignature member_;
164 
165  public:
167  T* object, MemberSignature member)
168  : object_(object),
169  member_(member) {
170  }
171 
172  virtual void Run() {
173  if (!del) {
174  (object_->*member_)();
175  } else {
176  (object_->*member_)();
177  // zero out the pointer to ensure segfault if used again
178  member_ = NULL;
179  delete this;
180  }
181  }
182 };
183 
184 #ifndef SWIG
185 template <class T1, class T2, class R>
188  T1* obj, R (T2::*member)() ) {
190  obj, member);
191 }
192 #endif
193 
194 #ifndef SWIG
195 template <class T1, class T2, class R>
198  T1* obj, R (T2::*member)() ) {
200  obj, member);
201 }
202 #endif
203 
204 template <bool del, class R>
206  public:
208  typedef R (*FunctionSignature)();
209 
210  private:
211  FunctionSignature function_;
212 
213  public:
215  FunctionSignature function)
216  : function_(function) {
217  }
218 
219  virtual R Run() {
220  if (!del) {
221  R result = (*function_)();
222  return result;
223  } else {
224  R result = (*function_)();
225  // zero out the pointer to ensure segfault if used again
226  function_ = NULL;
227  delete this;
228  return result;
229  }
230  }
231 };
232 
233 template <bool del>
235  : public TessClosure {
236  public:
237  typedef TessClosure base;
238  typedef void (*FunctionSignature)();
239 
240  private:
241  FunctionSignature function_;
242 
243  public:
245  FunctionSignature function)
246  : function_(function) {
247  }
248 
249  virtual void Run() {
250  if (!del) {
251  (*function_)();
252  } else {
253  (*function_)();
254  // zero out the pointer to ensure segfault if used again
255  function_ = NULL;
256  delete this;
257  }
258  }
259 };
260 
261 template <class R>
263 NewTessCallback(R (*function)()) {
264  return new _TessFunctionResultCallback_0_0<true,R>(function);
265 }
266 
267 template <class R>
269 NewPermanentTessCallback(R (*function)()) {
270  return new _TessFunctionResultCallback_0_0<false,R>(function);
271 }
272 
273 
274 
275 // Specified by TR1 [4.7.2] Reference modifications.
276 template <class T> struct remove_reference;
277 template<typename T> struct remove_reference { typedef T type; };
278 template<typename T> struct remove_reference<T&> { typedef T type; };
279 
280 // Identity<T>::type is a typedef of T. Useful for preventing the
281 // compiler from inferring the type of an argument in templates.
282 template <typename T>
283 struct Identity {
284  typedef T type;
285 };
286 
287 template <bool del, class R, class T, class P1>
289  public:
291  typedef R (T::*MemberSignature)(P1) const;
292 
293  private:
294  const T* object_;
295  MemberSignature member_;
296  typename remove_reference<P1>::type p1_;
297 
298  public:
299  inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1)
300  : object_(object),
301  member_(member), p1_(p1) { }
302 
303  virtual R Run() {
304  if (!del) {
305  R result = (object_->*member_)(p1_);
306  return result;
307  } else {
308  R result = (object_->*member_)(p1_);
309  // zero out the pointer to ensure segfault if used again
310  member_ = NULL;
311  delete this;
312  return result;
313  }
314  }
315 };
316 
317 template <bool del, class T, class P1>
318 class _ConstTessMemberResultCallback_1_0<del, void, T, P1> : public TessClosure {
319  public:
320  typedef TessClosure base;
321  typedef void (T::*MemberSignature)(P1) const;
322 
323  private:
324  const T* object_;
325  MemberSignature member_;
326  typename remove_reference<P1>::type p1_;
327 
328  public:
329  inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1)
330  : object_(object),
331  member_(member), p1_(p1) { }
332 
333  virtual void Run() {
334  if (!del) {
335  (object_->*member_)(p1_);
336  } else {
337  (object_->*member_)(p1_);
338  // zero out the pointer to ensure segfault if used again
339  member_ = NULL;
340  delete this;
341  }
342  }
343 };
344 
345 #ifndef SWIG
346 template <class T1, class T2, class R, class P1>
348 NewTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity<P1>::type p1) {
349  return new _ConstTessMemberResultCallback_1_0<true,R,T1,P1>(obj, member, p1);
350 }
351 #endif
352 
353 #ifndef SWIG
354 template <class T1, class T2, class R, class P1>
356 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity<P1>::type p1) {
357  return new _ConstTessMemberResultCallback_1_0<false,R,T1,P1>(obj, member, p1);
358 }
359 #endif
360 
361 template <bool del, class R, class T, class P1>
363  public:
365  typedef R (T::*MemberSignature)(P1) ;
366 
367  private:
368  T* object_;
369  MemberSignature member_;
370  typename remove_reference<P1>::type p1_;
371 
372  public:
373  inline _TessMemberResultCallback_1_0( T* object, MemberSignature member, P1 p1)
374  : object_(object),
375  member_(member), p1_(p1) { }
376 
377  virtual R Run() {
378  if (!del) {
379  R result = (object_->*member_)(p1_);
380  return result;
381  } else {
382  R result = (object_->*member_)(p1_);
383  // zero out the pointer to ensure segfault if used again
384  member_ = NULL;
385  delete this;
386  return result;
387  }
388  }
389 };
390 
391 template <bool del, class T, class P1>
392 class _TessMemberResultCallback_1_0<del, void, T, P1> : public TessClosure {
393  public:
394  typedef TessClosure base;
395  typedef void (T::*MemberSignature)(P1) ;
396 
397  private:
398  T* object_;
399  MemberSignature member_;
400  typename remove_reference<P1>::type p1_;
401 
402  public:
403  inline _TessMemberResultCallback_1_0( T* object, MemberSignature member, P1 p1)
404  : object_(object),
405  member_(member), p1_(p1) { }
406 
407  virtual void Run() {
408  if (!del) {
409  (object_->*member_)(p1_);
410  } else {
411  (object_->*member_)(p1_);
412  // zero out the pointer to ensure segfault if used again
413  member_ = NULL;
414  delete this;
415  }
416  }
417 };
418 
419 #ifndef SWIG
420 template <class T1, class T2, class R, class P1>
422 NewTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity<P1>::type p1) {
423  return new _TessMemberResultCallback_1_0<true,R,T1,P1>(obj, member, p1);
424 }
425 #endif
426 
427 #ifndef SWIG
428 template <class T1, class T2, class R, class P1>
430 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity<P1>::type p1) {
431  return new _TessMemberResultCallback_1_0<false,R,T1,P1>(obj, member, p1);
432 }
433 #endif
434 
435 template <bool del, class R, class P1>
437  public:
439  typedef R (*FunctionSignature)(P1);
440 
441  private:
442  FunctionSignature function_;
443  typename remove_reference<P1>::type p1_;
444 
445  public:
447  : function_(function), p1_(p1) { }
448 
449  virtual R Run() {
450  if (!del) {
451  R result = (*function_)(p1_);
452  return result;
453  } else {
454  R result = (*function_)(p1_);
455  // zero out the pointer to ensure segfault if used again
456  function_ = NULL;
457  delete this;
458  return result;
459  }
460  }
461 };
462 
463 template <bool del, class P1>
464 class _TessFunctionResultCallback_1_0<del, void, P1> : public TessClosure {
465  public:
466  typedef TessClosure base;
467  typedef void (*FunctionSignature)(P1);
468 
469  private:
470  FunctionSignature function_;
471  typename remove_reference<P1>::type p1_;
472 
473  public:
475  : function_(function), p1_(p1) { }
476 
477  virtual void Run() {
478  if (!del) {
479  (*function_)(p1_);
480  } else {
481  (*function_)(p1_);
482  // zero out the pointer to ensure segfault if used again
483  function_ = NULL;
484  delete this;
485  }
486  }
487 };
488 
489 template <class R, class P1>
491 NewTessCallback(R (*function)(P1), typename Identity<P1>::type p1) {
492  return new _TessFunctionResultCallback_1_0<true,R,P1>(function, p1);
493 }
494 
495 template <class R, class P1>
497 NewPermanentTessCallback(R (*function)(P1), typename Identity<P1>::type p1) {
498  return new _TessFunctionResultCallback_1_0<false,R,P1>(function, p1);
499 }
500 
501 template <bool del, class R, class T, class P1, class P2>
503  public:
505  typedef R (T::*MemberSignature)(P1,P2) const;
506 
507  private:
508  const T* object_;
509  MemberSignature member_;
510  typename remove_reference<P1>::type p1_;
511  typename remove_reference<P2>::type p2_;
512 
513  public:
514  inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2)
515  : object_(object),
516  member_(member), p1_(p1), p2_(p2) { }
517 
518  virtual R Run() {
519  if (!del) {
520  R result = (object_->*member_)(p1_,p2_);
521  return result;
522  } else {
523  R result = (object_->*member_)(p1_,p2_);
524  // zero out the pointer to ensure segfault if used again
525  member_ = NULL;
526  delete this;
527  return result;
528  }
529  }
530 };
531 
532 template <bool del, class T, class P1, class P2>
533 class _ConstTessMemberResultCallback_2_0<del, void, T, P1, P2> : public TessClosure {
534  public:
535  typedef TessClosure base;
536  typedef void (T::*MemberSignature)(P1,P2) const;
537 
538  private:
539  const T* object_;
540  MemberSignature member_;
541  typename remove_reference<P1>::type p1_;
542  typename remove_reference<P2>::type p2_;
543 
544  public:
545  inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2)
546  :
547  object_(object),
548  member_(member), p1_(p1), p2_(p2) { }
549 
550  virtual void Run() {
551  if (!del) {
552  (object_->*member_)(p1_,p2_);
553  } else {
554  (object_->*member_)(p1_,p2_);
555  // zero out the pointer to ensure segfault if used again
556  member_ = NULL;
557  delete this;
558  }
559  }
560 };
561 
562 #ifndef SWIG
563 template <class T1, class T2, class R, class P1, class P2>
565 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
566  return new _ConstTessMemberResultCallback_2_0<true,R,T1,P1,P2>(obj, member, p1, p2);
567 }
568 #endif
569 
570 #ifndef SWIG
571 template <class T1, class T2, class R, class P1, class P2>
573 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
574  return new _ConstTessMemberResultCallback_2_0<false,R,T1,P1,P2>(obj, member, p1, p2);
575 }
576 #endif
577 
578 template <bool del, class R, class T, class P1, class P2>
580  public:
582  typedef R (T::*MemberSignature)(P1,P2) ;
583 
584  private:
585  T* object_;
586  MemberSignature member_;
587  typename remove_reference<P1>::type p1_;
588  typename remove_reference<P2>::type p2_;
589 
590  public:
591  inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2)
592  : object_(object),
593  member_(member), p1_(p1), p2_(p2) { }
594 
595  virtual R Run() {
596  if (!del) {
597  R result = (object_->*member_)(p1_,p2_);
598  return result;
599  } else {
600  R result = (object_->*member_)(p1_,p2_);
601  // zero out the pointer to ensure segfault if used again
602  member_ = NULL;
603  delete this;
604  return result;
605  }
606  }
607 };
608 
609 template <bool del, class T, class P1, class P2>
610 class _TessMemberResultCallback_2_0<del, void, T, P1, P2> : public TessClosure {
611  public:
612  typedef TessClosure base;
613  typedef void (T::*MemberSignature)(P1,P2) ;
614 
615  private:
616  T* object_;
617  MemberSignature member_;
618  typename remove_reference<P1>::type p1_;
619  typename remove_reference<P2>::type p2_;
620 
621  public:
622  inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2)
623  :
624  object_(object),
625  member_(member), p1_(p1), p2_(p2) { }
626 
627  virtual void Run() {
628  if (!del) {
629  (object_->*member_)(p1_,p2_);
630  } else {
631  (object_->*member_)(p1_,p2_);
632  // zero out the pointer to ensure segfault if used again
633  member_ = NULL;
634  delete this;
635  }
636  }
637 };
638 
639 #ifndef SWIG
640 template <class T1, class T2, class R, class P1, class P2>
642 NewTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
643  return new _TessMemberResultCallback_2_0<true,R,T1,P1,P2>(obj, member, p1, p2);
644 }
645 #endif
646 
647 #ifndef SWIG
648 template <class T1, class T2, class R, class P1, class P2>
650 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
651  return new _TessMemberResultCallback_2_0<false,R,T1,P1,P2>(obj, member, p1, p2);
652 }
653 #endif
654 
655 template <bool del, class R, class P1, class P2>
657  public:
659  typedef R (*FunctionSignature)(P1,P2);
660 
661  private:
662  FunctionSignature function_;
663  typename remove_reference<P1>::type p1_;
664  typename remove_reference<P2>::type p2_;
665 
666  public:
667  inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
668  : function_(function), p1_(p1), p2_(p2) { }
669 
670  virtual R Run() {
671  if (!del) {
672  R result = (*function_)(p1_,p2_);
673  return result;
674  } else {
675  R result = (*function_)(p1_,p2_);
676  // zero out the pointer to ensure segfault if used again
677  function_ = NULL;
678  delete this;
679  return result;
680  }
681  }
682 };
683 
684 template <bool del, class P1, class P2>
685 class _TessFunctionResultCallback_2_0<del, void, P1, P2> : public TessClosure {
686  public:
687  typedef TessClosure base;
688  typedef void (*FunctionSignature)(P1,P2);
689 
690  private:
691  FunctionSignature function_;
692  typename remove_reference<P1>::type p1_;
693  typename remove_reference<P2>::type p2_;
694 
695  public:
696  inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
697  :
698  function_(function), p1_(p1), p2_(p2) { }
699 
700  virtual void Run() {
701  if (!del) {
702  (*function_)(p1_,p2_);
703  } else {
704  (*function_)(p1_,p2_);
705  // zero out the pointer to ensure segfault if used again
706  function_ = NULL;
707  delete this;
708  }
709  }
710 };
711 
712 template <class R, class P1, class P2>
714 NewTessCallback(R (*function)(P1,P2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
715  return new _TessFunctionResultCallback_2_0<true,R,P1,P2>(function, p1, p2);
716 }
717 
718 template <class R, class P1, class P2>
720 NewPermanentTessCallback(R (*function)(P1,P2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
721  return new _TessFunctionResultCallback_2_0<false,R,P1,P2>(function, p1, p2);
722 }
723 
724 template <bool del, class R, class T, class P1, class P2, class P3>
726  public:
728  typedef R (T::*MemberSignature)(P1,P2,P3) const;
729 
730  private:
731  const T* object_;
732  MemberSignature member_;
733  typename remove_reference<P1>::type p1_;
734  typename remove_reference<P2>::type p2_;
735  typename remove_reference<P3>::type p3_;
736 
737  public:
738  inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
739  :
740  object_(object),
741  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
742 
743  virtual R Run() {
744  if (!del) {
745  R result = (object_->*member_)(p1_,p2_,p3_);
746  return result;
747  } else {
748  R result = (object_->*member_)(p1_,p2_,p3_);
749  // zero out the pointer to ensure segfault if used again
750  member_ = NULL;
751  delete this;
752  return result;
753  }
754  }
755 };
756 
757 template <bool del, class T, class P1, class P2, class P3>
758 class _ConstTessMemberResultCallback_3_0<del, void, T, P1, P2, P3> : public TessClosure {
759  public:
760  typedef TessClosure base;
761  typedef void (T::*MemberSignature)(P1,P2,P3) const;
762 
763  private:
764  const T* object_;
765  MemberSignature member_;
766  typename remove_reference<P1>::type p1_;
767  typename remove_reference<P2>::type p2_;
768  typename remove_reference<P3>::type p3_;
769 
770  public:
771  inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
772  : object_(object),
773  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
774 
775  virtual void Run() {
776  if (!del) {
777  (object_->*member_)(p1_,p2_,p3_);
778  } else {
779  (object_->*member_)(p1_,p2_,p3_);
780  // zero out the pointer to ensure segfault if used again
781  member_ = NULL;
782  delete this;
783  }
784  }
785 };
786 
787 #ifndef SWIG
788 template <class T1, class T2, class R, class P1, class P2, class P3>
790 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
791  return new _ConstTessMemberResultCallback_3_0<true,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
792 }
793 #endif
794 
795 #ifndef SWIG
796 template <class T1, class T2, class R, class P1, class P2, class P3>
798 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
799  return new _ConstTessMemberResultCallback_3_0<false,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
800 }
801 #endif
802 
803 template <bool del, class R, class T, class P1, class P2, class P3>
805  public:
807  typedef R (T::*MemberSignature)(P1,P2,P3) ;
808 
809  private:
810  T* object_;
811  MemberSignature member_;
812  typename remove_reference<P1>::type p1_;
813  typename remove_reference<P2>::type p2_;
814  typename remove_reference<P3>::type p3_;
815 
816  public:
817  inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
818  : object_(object),
819  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
820 
821  virtual R Run() {
822  if (!del) {
823  R result = (object_->*member_)(p1_,p2_,p3_);
824  return result;
825  } else {
826  R result = (object_->*member_)(p1_,p2_,p3_);
827  // zero out the pointer to ensure segfault if used again
828  member_ = NULL;
829  delete this;
830  return result;
831  }
832  }
833 };
834 
835 template <bool del, class T, class P1, class P2, class P3>
836 class _TessMemberResultCallback_3_0<del, void, T, P1, P2, P3> : public TessClosure {
837  public:
838  typedef TessClosure base;
839  typedef void (T::*MemberSignature)(P1,P2,P3) ;
840 
841  private:
842  T* object_;
843  MemberSignature member_;
844  typename remove_reference<P1>::type p1_;
845  typename remove_reference<P2>::type p2_;
846  typename remove_reference<P3>::type p3_;
847 
848  public:
849  inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
850  : object_(object),
851  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
852 
853  virtual void Run() {
854  if (!del) {
855  (object_->*member_)(p1_,p2_,p3_);
856  } else {
857  (object_->*member_)(p1_,p2_,p3_);
858  // zero out the pointer to ensure segfault if used again
859  member_ = NULL;
860  delete this;
861  }
862  }
863 };
864 
865 #ifndef SWIG
866 template <class T1, class T2, class R, class P1, class P2, class P3>
868 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
869  return new _TessMemberResultCallback_3_0<true,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
870 }
871 #endif
872 
873 #ifndef SWIG
874 template <class T1, class T2, class R, class P1, class P2, class P3>
876 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
877  return new _TessMemberResultCallback_3_0<false,R,T1,P1,P2,P3>(obj, member, p1, p2, p3);
878 }
879 #endif
880 
881 template <bool del, class R, class P1, class P2, class P3>
883  public:
885  typedef R (*FunctionSignature)(P1,P2,P3);
886 
887  private:
888  FunctionSignature function_;
889  typename remove_reference<P1>::type p1_;
890  typename remove_reference<P2>::type p2_;
891  typename remove_reference<P3>::type p3_;
892 
893  public:
894  inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
895  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
896 
897  virtual R Run() {
898  if (!del) {
899  R result = (*function_)(p1_,p2_,p3_);
900  return result;
901  } else {
902  R result = (*function_)(p1_,p2_,p3_);
903  // zero out the pointer to ensure segfault if used again
904  function_ = NULL;
905  delete this;
906  return result;
907  }
908  }
909 };
910 
911 template <bool del, class P1, class P2, class P3>
912 class _TessFunctionResultCallback_3_0<del, void, P1, P2, P3> : public TessClosure {
913  public:
914  typedef TessClosure base;
915  typedef void (*FunctionSignature)(P1,P2,P3);
916 
917  private:
918  FunctionSignature function_;
919  typename remove_reference<P1>::type p1_;
920  typename remove_reference<P2>::type p2_;
921  typename remove_reference<P3>::type p3_;
922 
923  public:
924  inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
925  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
926 
927  virtual void Run() {
928  if (!del) {
929  (*function_)(p1_,p2_,p3_);
930  } else {
931  (*function_)(p1_,p2_,p3_);
932  // zero out the pointer to ensure segfault if used again
933  function_ = NULL;
934  delete this;
935  }
936  }
937 };
938 
939 template <class R, class P1, class P2, class P3>
941 NewTessCallback(R (*function)(P1,P2,P3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
942  return new _TessFunctionResultCallback_3_0<true,R,P1,P2,P3>(function, p1, p2, p3);
943 }
944 
945 template <class R, class P1, class P2, class P3>
947 NewPermanentTessCallback(R (*function)(P1,P2,P3), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
948  return new _TessFunctionResultCallback_3_0<false,R,P1,P2,P3>(function, p1, p2, p3);
949 }
950 
951 template <bool del, class R, class T, class P1, class P2, class P3, class P4>
953  public:
955  typedef R (T::*MemberSignature)(P1,P2,P3,P4) const;
956 
957  private:
958  const T* object_;
959  MemberSignature member_;
960  typename remove_reference<P1>::type p1_;
961  typename remove_reference<P2>::type p2_;
962  typename remove_reference<P3>::type p3_;
963  typename remove_reference<P4>::type p4_;
964 
965  public:
966  inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
967  : object_(object),
968  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
969 
970  virtual R Run() {
971  if (!del) {
972  R result = (object_->*member_)(p1_,p2_,p3_,p4_);
973  return result;
974  } else {
975  R result = (object_->*member_)(p1_,p2_,p3_,p4_);
976  // zero out the pointer to ensure segfault if used again
977  member_ = NULL;
978  delete this;
979  return result;
980  }
981  }
982 };
983 
984 template <bool del, class T, class P1, class P2, class P3, class P4>
985 class _ConstTessMemberResultCallback_4_0<del, void, T, P1, P2, P3, P4> : public TessClosure {
986  public:
987  typedef TessClosure base;
988  typedef void (T::*MemberSignature)(P1,P2,P3,P4) const;
989 
990  private:
991  const T* object_;
992  MemberSignature member_;
993  typename remove_reference<P1>::type p1_;
994  typename remove_reference<P2>::type p2_;
995  typename remove_reference<P3>::type p3_;
996  typename remove_reference<P4>::type p4_;
997 
998  public:
999  inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
1000  : object_(object),
1001  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
1002 
1003  virtual void Run() {
1004  if (!del) {
1005  (object_->*member_)(p1_,p2_,p3_,p4_);
1006  } else {
1007  (object_->*member_)(p1_,p2_,p3_,p4_);
1008  // zero out the pointer to ensure segfault if used again
1009  member_ = NULL;
1010  delete this;
1011  }
1012  }
1013 };
1014 
1015 #ifndef SWIG
1016 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
1018 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
1019  return new _ConstTessMemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
1020 }
1021 #endif
1022 
1023 #ifndef SWIG
1024 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
1026 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
1027  return new _ConstTessMemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
1028 }
1029 #endif
1030 
1031 template <bool del, class R, class T, class P1, class P2, class P3, class P4>
1033  public:
1035  typedef R (T::*MemberSignature)(P1,P2,P3,P4) ;
1036 
1037  private:
1038  T* object_;
1039  MemberSignature member_;
1040  typename remove_reference<P1>::type p1_;
1041  typename remove_reference<P2>::type p2_;
1042  typename remove_reference<P3>::type p3_;
1043  typename remove_reference<P4>::type p4_;
1044 
1045  public:
1046  inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
1047  : object_(object),
1048  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
1049 
1050  virtual R Run() {
1051  if (!del) {
1052  R result = (object_->*member_)(p1_,p2_,p3_,p4_);
1053  return result;
1054  } else {
1055  R result = (object_->*member_)(p1_,p2_,p3_,p4_);
1056  // zero out the pointer to ensure segfault if used again
1057  member_ = NULL;
1058  delete this;
1059  return result;
1060  }
1061  }
1062 };
1063 
1064 template <bool del, class T, class P1, class P2, class P3, class P4>
1065 class _TessMemberResultCallback_4_0<del, void, T, P1, P2, P3, P4> : public TessClosure {
1066  public:
1068  typedef void (T::*MemberSignature)(P1,P2,P3,P4) ;
1069 
1070  private:
1071  T* object_;
1072  MemberSignature member_;
1073  typename remove_reference<P1>::type p1_;
1074  typename remove_reference<P2>::type p2_;
1075  typename remove_reference<P3>::type p3_;
1076  typename remove_reference<P4>::type p4_;
1077 
1078  public:
1079  inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
1080  : object_(object),
1081  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
1082 
1083  virtual void Run() {
1084  if (!del) {
1085  (object_->*member_)(p1_,p2_,p3_,p4_);
1086  } else {
1087  (object_->*member_)(p1_,p2_,p3_,p4_);
1088  // zero out the pointer to ensure segfault if used again
1089  member_ = NULL;
1090  delete this;
1091  }
1092  }
1093 };
1094 
1095 #ifndef SWIG
1096 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
1098 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
1099  return new _TessMemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
1100 }
1101 #endif
1102 
1103 #ifndef SWIG
1104 template <class T1, class T2, class R, class P1, class P2, class P3, class P4>
1106 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
1107  return new _TessMemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>(obj, member, p1, p2, p3, p4);
1108 }
1109 #endif
1110 
1111 template <bool del, class R, class P1, class P2, class P3, class P4>
1113  public:
1115  typedef R (*FunctionSignature)(P1,P2,P3,P4);
1116 
1117  private:
1118  FunctionSignature function_;
1119  typename remove_reference<P1>::type p1_;
1120  typename remove_reference<P2>::type p2_;
1121  typename remove_reference<P3>::type p3_;
1122  typename remove_reference<P4>::type p4_;
1123 
1124  public:
1125  inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
1126  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
1127 
1128  virtual R Run() {
1129  if (!del) {
1130  R result = (*function_)(p1_,p2_,p3_,p4_);
1131  return result;
1132  } else {
1133  R result = (*function_)(p1_,p2_,p3_,p4_);
1134  // zero out the pointer to ensure segfault if used again
1135  function_ = NULL;
1136  delete this;
1137  return result;
1138  }
1139  }
1140 };
1141 
1142 template <bool del, class P1, class P2, class P3, class P4>
1143 class _TessFunctionResultCallback_4_0<del, void, P1, P2, P3, P4> : public TessClosure {
1144  public:
1146  typedef void (*FunctionSignature)(P1,P2,P3,P4);
1147 
1148  private:
1149  FunctionSignature function_;
1150  typename remove_reference<P1>::type p1_;
1151  typename remove_reference<P2>::type p2_;
1152  typename remove_reference<P3>::type p3_;
1153  typename remove_reference<P4>::type p4_;
1154 
1155  public:
1156  inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
1157  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
1158 
1159  virtual void Run() {
1160  if (!del) {
1161  (*function_)(p1_,p2_,p3_,p4_);
1162  } else {
1163  (*function_)(p1_,p2_,p3_,p4_);
1164  // zero out the pointer to ensure segfault if used again
1165  function_ = NULL;
1166  delete this;
1167  }
1168  }
1169 };
1170 
1171 template <class R, class P1, class P2, class P3, class P4>
1173 NewTessCallback(R (*function)(P1,P2,P3,P4), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
1174  return new _TessFunctionResultCallback_4_0<true,R,P1,P2,P3,P4>(function, p1, p2, p3, p4);
1175 }
1176 
1177 template <class R, class P1, class P2, class P3, class P4>
1179 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
1180  return new _TessFunctionResultCallback_4_0<false,R,P1,P2,P3,P4>(function, p1, p2, p3, p4);
1181 }
1182 
1183 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5>
1185  public:
1187  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) const;
1188 
1189  private:
1190  const T* object_;
1191  MemberSignature member_;
1192  typename remove_reference<P1>::type p1_;
1193  typename remove_reference<P2>::type p2_;
1194  typename remove_reference<P3>::type p3_;
1195  typename remove_reference<P4>::type p4_;
1196  typename remove_reference<P5>::type p5_;
1197 
1198  public:
1199  inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
1200  : object_(object),
1201  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
1202 
1203  virtual R Run() {
1204  if (!del) {
1205  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1206  return result;
1207  } else {
1208  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1209  // zero out the pointer to ensure segfault if used again
1210  member_ = NULL;
1211  delete this;
1212  return result;
1213  }
1214  }
1215 };
1216 
1217 template <bool del, class T, class P1, class P2, class P3, class P4, class P5>
1218 class _ConstTessMemberResultCallback_5_0<del, void, T, P1, P2, P3, P4, P5> : public TessClosure {
1219  public:
1221  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) const;
1222 
1223  private:
1224  const T* object_;
1225  MemberSignature member_;
1226  typename remove_reference<P1>::type p1_;
1227  typename remove_reference<P2>::type p2_;
1228  typename remove_reference<P3>::type p3_;
1229  typename remove_reference<P4>::type p4_;
1230  typename remove_reference<P5>::type p5_;
1231 
1232  public:
1233  inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
1234  : object_(object),
1235  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
1236 
1237  virtual void Run() {
1238  if (!del) {
1239  (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1240  } else {
1241  (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1242  // zero out the pointer to ensure segfault if used again
1243  member_ = NULL;
1244  delete this;
1245  }
1246  }
1247 };
1248 
1249 #ifndef SWIG
1250 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
1252 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
1253  return new _ConstTessMemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
1254 }
1255 #endif
1256 
1257 #ifndef SWIG
1258 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
1260 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
1261  return new _ConstTessMemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
1262 }
1263 #endif
1264 
1265 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5>
1267  public:
1269  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) ;
1270 
1271  private:
1272  T* object_;
1273  MemberSignature member_;
1274  typename remove_reference<P1>::type p1_;
1275  typename remove_reference<P2>::type p2_;
1276  typename remove_reference<P3>::type p3_;
1277  typename remove_reference<P4>::type p4_;
1278  typename remove_reference<P5>::type p5_;
1279 
1280  public:
1281  inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
1282  : object_(object),
1283  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
1284 
1285  virtual R Run() {
1286  if (!del) {
1287  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1288  return result;
1289  } else {
1290  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1291  // zero out the pointer to ensure segfault if used again
1292  member_ = NULL;
1293  delete this;
1294  return result;
1295  }
1296  }
1297 };
1298 
1299 template <bool del, class T, class P1, class P2, class P3, class P4, class P5>
1300 class _TessMemberResultCallback_5_0<del, void, T, P1, P2, P3, P4, P5> : public TessClosure {
1301  public:
1303  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) ;
1304 
1305  private:
1306  T* object_;
1307  MemberSignature member_;
1308  typename remove_reference<P1>::type p1_;
1309  typename remove_reference<P2>::type p2_;
1310  typename remove_reference<P3>::type p3_;
1311  typename remove_reference<P4>::type p4_;
1312  typename remove_reference<P5>::type p5_;
1313 
1314  public:
1315  inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
1316  : object_(object),
1317  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
1318 
1319  virtual void Run() {
1320  if (!del) {
1321  (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1322  } else {
1323  (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
1324  // zero out the pointer to ensure segfault if used again
1325  member_ = NULL;
1326  delete this;
1327  }
1328  }
1329 };
1330 
1331 #ifndef SWIG
1332 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
1334 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
1335  return new _TessMemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
1336 }
1337 #endif
1338 
1339 #ifndef SWIG
1340 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
1342 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
1343  return new _TessMemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>(obj, member, p1, p2, p3, p4, p5);
1344 }
1345 #endif
1346 
1347 template <bool del, class R, class P1, class P2, class P3, class P4, class P5>
1349  public:
1351  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5);
1352 
1353  private:
1354  FunctionSignature function_;
1355  typename remove_reference<P1>::type p1_;
1356  typename remove_reference<P2>::type p2_;
1357  typename remove_reference<P3>::type p3_;
1358  typename remove_reference<P4>::type p4_;
1359  typename remove_reference<P5>::type p5_;
1360 
1361  public:
1362  inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
1363  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
1364 
1365  virtual R Run() {
1366  if (!del) {
1367  R result = (*function_)(p1_,p2_,p3_,p4_,p5_);
1368  return result;
1369  } else {
1370  R result = (*function_)(p1_,p2_,p3_,p4_,p5_);
1371  // zero out the pointer to ensure segfault if used again
1372  function_ = NULL;
1373  delete this;
1374  return result;
1375  }
1376  }
1377 };
1378 
1379 template <bool del, class P1, class P2, class P3, class P4, class P5>
1380 class _TessFunctionResultCallback_5_0<del, void, P1, P2, P3, P4, P5> : public TessClosure {
1381  public:
1383  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5);
1384 
1385  private:
1386  FunctionSignature function_;
1387  typename remove_reference<P1>::type p1_;
1388  typename remove_reference<P2>::type p2_;
1389  typename remove_reference<P3>::type p3_;
1390  typename remove_reference<P4>::type p4_;
1391  typename remove_reference<P5>::type p5_;
1392 
1393  public:
1394  inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
1395  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
1396 
1397  virtual void Run() {
1398  if (!del) {
1399  (*function_)(p1_,p2_,p3_,p4_,p5_);
1400  } else {
1401  (*function_)(p1_,p2_,p3_,p4_,p5_);
1402  // zero out the pointer to ensure segfault if used again
1403  function_ = NULL;
1404  delete this;
1405  }
1406  }
1407 };
1408 
1409 template <class R, class P1, class P2, class P3, class P4, class P5>
1411 NewTessCallback(R (*function)(P1,P2,P3,P4,P5), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
1412  return new _TessFunctionResultCallback_5_0<true,R,P1,P2,P3,P4,P5>(function, p1, p2, p3, p4, p5);
1413 }
1414 
1415 template <class R, class P1, class P2, class P3, class P4, class P5>
1417 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
1418  return new _TessFunctionResultCallback_5_0<false,R,P1,P2,P3,P4,P5>(function, p1, p2, p3, p4, p5);
1419 }
1420 
1421 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6>
1423  public:
1425  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const;
1426 
1427  private:
1428  const T* object_;
1429  MemberSignature member_;
1430  typename remove_reference<P1>::type p1_;
1431  typename remove_reference<P2>::type p2_;
1432  typename remove_reference<P3>::type p3_;
1433  typename remove_reference<P4>::type p4_;
1434  typename remove_reference<P5>::type p5_;
1435  typename remove_reference<P6>::type p6_;
1436 
1437  public:
1438  inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
1439  : object_(object),
1440  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
1441 
1442  virtual R Run() {
1443  if (!del) {
1444  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1445  return result;
1446  } else {
1447  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1448  // zero out the pointer to ensure segfault if used again
1449  member_ = NULL;
1450  delete this;
1451  return result;
1452  }
1453  }
1454 };
1455 
1456 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6>
1457 class _ConstTessMemberResultCallback_6_0<del, void, T, P1, P2, P3, P4, P5, P6> : public TessClosure {
1458  public:
1460  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const;
1461 
1462  private:
1463  const T* object_;
1464  MemberSignature member_;
1465  typename remove_reference<P1>::type p1_;
1466  typename remove_reference<P2>::type p2_;
1467  typename remove_reference<P3>::type p3_;
1468  typename remove_reference<P4>::type p4_;
1469  typename remove_reference<P5>::type p5_;
1470  typename remove_reference<P6>::type p6_;
1471 
1472  public:
1473  inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
1474  : object_(object),
1475  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
1476 
1477  virtual void Run() {
1478  if (!del) {
1479  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1480  } else {
1481  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1482  // zero out the pointer to ensure segfault if used again
1483  member_ = NULL;
1484  delete this;
1485  }
1486  }
1487 };
1488 
1489 #ifndef SWIG
1490 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
1492 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
1493  return new _ConstTessMemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
1494 }
1495 #endif
1496 
1497 #ifndef SWIG
1498 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
1500 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
1501  return new _ConstTessMemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
1502 }
1503 #endif
1504 
1505 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6>
1507  public:
1509  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ;
1510 
1511  private:
1512  T* object_;
1513  MemberSignature member_;
1514  typename remove_reference<P1>::type p1_;
1515  typename remove_reference<P2>::type p2_;
1516  typename remove_reference<P3>::type p3_;
1517  typename remove_reference<P4>::type p4_;
1518  typename remove_reference<P5>::type p5_;
1519  typename remove_reference<P6>::type p6_;
1520 
1521  public:
1522  inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
1523  : object_(object),
1524  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
1525 
1526  virtual R Run() {
1527  if (!del) {
1528  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1529  return result;
1530  } else {
1531  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1532  // zero out the pointer to ensure segfault if used again
1533  member_ = NULL;
1534  delete this;
1535  return result;
1536  }
1537  }
1538 };
1539 
1540 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6>
1541 class _TessMemberResultCallback_6_0<del, void, T, P1, P2, P3, P4, P5, P6> : public TessClosure {
1542  public:
1544  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ;
1545 
1546  private:
1547  T* object_;
1548  MemberSignature member_;
1549  typename remove_reference<P1>::type p1_;
1550  typename remove_reference<P2>::type p2_;
1551  typename remove_reference<P3>::type p3_;
1552  typename remove_reference<P4>::type p4_;
1553  typename remove_reference<P5>::type p5_;
1554  typename remove_reference<P6>::type p6_;
1555 
1556  public:
1557  inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
1558  : object_(object),
1559  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
1560 
1561  virtual void Run() {
1562  if (!del) {
1563  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1564  } else {
1565  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
1566  // zero out the pointer to ensure segfault if used again
1567  member_ = NULL;
1568  delete this;
1569  }
1570  }
1571 };
1572 
1573 #ifndef SWIG
1574 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
1576 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
1577  return new _TessMemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
1578 }
1579 #endif
1580 
1581 #ifndef SWIG
1582 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
1584 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
1585  return new _TessMemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>(obj, member, p1, p2, p3, p4, p5, p6);
1586 }
1587 #endif
1588 
1589 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6>
1591  public:
1593  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6);
1594 
1595  private:
1596  FunctionSignature function_;
1597  typename remove_reference<P1>::type p1_;
1598  typename remove_reference<P2>::type p2_;
1599  typename remove_reference<P3>::type p3_;
1600  typename remove_reference<P4>::type p4_;
1601  typename remove_reference<P5>::type p5_;
1602  typename remove_reference<P6>::type p6_;
1603 
1604  public:
1605  inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
1606  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
1607 
1608  virtual R Run() {
1609  if (!del) {
1610  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
1611  return result;
1612  } else {
1613  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
1614  // zero out the pointer to ensure segfault if used again
1615  function_ = NULL;
1616  delete this;
1617  return result;
1618  }
1619  }
1620 };
1621 
1622 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6>
1623 class _TessFunctionResultCallback_6_0<del, void, P1, P2, P3, P4, P5, P6> : public TessClosure {
1624  public:
1626  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6);
1627 
1628  private:
1629  FunctionSignature function_;
1630  typename remove_reference<P1>::type p1_;
1631  typename remove_reference<P2>::type p2_;
1632  typename remove_reference<P3>::type p3_;
1633  typename remove_reference<P4>::type p4_;
1634  typename remove_reference<P5>::type p5_;
1635  typename remove_reference<P6>::type p6_;
1636 
1637  public:
1638  inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
1639  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
1640 
1641  virtual void Run() {
1642  if (!del) {
1643  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
1644  } else {
1645  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
1646  // zero out the pointer to ensure segfault if used again
1647  function_ = NULL;
1648  delete this;
1649  }
1650  }
1651 };
1652 
1653 template <class R, class P1, class P2, class P3, class P4, class P5, class P6>
1655 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
1656  return new _TessFunctionResultCallback_6_0<true,R,P1,P2,P3,P4,P5,P6>(function, p1, p2, p3, p4, p5, p6);
1657 }
1658 
1659 template <class R, class P1, class P2, class P3, class P4, class P5, class P6>
1661 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
1662  return new _TessFunctionResultCallback_6_0<false,R,P1,P2,P3,P4,P5,P6>(function, p1, p2, p3, p4, p5, p6);
1663 }
1664 
1665 template <class A1>
1667  public:
1668  virtual ~TessCallback1() { }
1669  virtual void Run(A1) = 0;
1670 };
1671 
1672 template <class R, class A1>
1674  public:
1675  virtual ~TessResultCallback1() { }
1676  virtual R Run(A1) = 0;
1677 };
1678 
1679 
1680 template <class A1,class A2>
1682  public:
1683  virtual ~TessCallback2() { }
1684  virtual void Run(A1,A2) = 0;
1685 };
1686 
1687 template <class R, class A1,class A2>
1689  public:
1690  virtual ~TessResultCallback2() { }
1691  virtual R Run(A1,A2) = 0;
1692 };
1693 
1694 template <class A1,class A2,class A3>
1696  public:
1697  virtual ~TessCallback3() { }
1698  virtual void Run(A1,A2,A3) = 0;
1699 };
1700 
1701 template <class R, class A1,class A2,class A3>
1703  public:
1704  virtual ~TessResultCallback3() { }
1705  virtual R Run(A1,A2,A3) = 0;
1706 };
1707 
1708 template <class A1,class A2,class A3,class A4>
1710  public:
1711  virtual ~TessCallback4() { }
1712  virtual void Run(A1,A2,A3,A4) = 0;
1713 };
1714 
1715 template <class R, class A1,class A2,class A3,class A4>
1717  public:
1718  virtual ~TessResultCallback4() { }
1719  virtual R Run(A1,A2,A3,A4) = 0;
1720 };
1721 
1722 template <bool del, class R, class T, class A1>
1724  public:
1726  typedef R (T::*MemberSignature)(A1) const;
1727 
1728  private:
1729  const T* object_;
1730  MemberSignature member_;
1731 
1732  public:
1734  const T* object, MemberSignature member)
1735  : object_(object),
1736  member_(member) {
1737  }
1738 
1739  virtual R Run(A1 a1) {
1740  if (!del) {
1741  R result = (object_->*member_)(a1);
1742  return result;
1743  } else {
1744  R result = (object_->*member_)(a1);
1745  // zero out the pointer to ensure segfault if used again
1746  member_ = NULL;
1747  delete this;
1748  return result;
1749  }
1750  }
1751 };
1752 
1753 template <bool del, class T, class A1>
1754 class _ConstTessMemberResultCallback_0_1<del, void, T, A1>
1755  : public TessCallback1<A1> {
1756  public:
1758  typedef void (T::*MemberSignature)(A1) const;
1759 
1760  private:
1761  const T* object_;
1762  MemberSignature member_;
1763 
1764  public:
1766  const T* object, MemberSignature member)
1767  : object_(object),
1768  member_(member) {
1769  }
1770 
1771  virtual void Run(A1 a1) {
1772  if (!del) {
1773  (object_->*member_)(a1);
1774  } else {
1775  (object_->*member_)(a1);
1776  // zero out the pointer to ensure segfault if used again
1777  member_ = NULL;
1778  delete this;
1779  }
1780  }
1781 };
1782 
1783 #ifndef SWIG
1784 template <class T1, class T2, class R, class A1>
1787  const T1* obj, R (T2::*member)(A1) const) {
1789  obj, member);
1790 }
1791 #endif
1792 
1793 #ifndef SWIG
1794 template <class T1, class T2, class R, class A1>
1797  const T1* obj, R (T2::*member)(A1) const) {
1799  obj, member);
1800 }
1801 #endif
1802 
1803 template <bool del, class R, class T, class A1>
1805  public:
1807  typedef R (T::*MemberSignature)(A1) ;
1808 
1809  private:
1810  T* object_;
1811  MemberSignature member_;
1812 
1813  public:
1815  T* object, MemberSignature member)
1816  : object_(object),
1817  member_(member) {
1818  }
1819 
1820  virtual R Run(A1 a1) {
1821  if (!del) {
1822  R result = (object_->*member_)(a1);
1823  return result;
1824  } else {
1825  R result = (object_->*member_)(a1);
1826  // zero out the pointer to ensure segfault if used again
1827  member_ = NULL;
1828  delete this;
1829  return result;
1830  }
1831  }
1832 };
1833 
1834 template <bool del, class T, class A1>
1835 class _TessMemberResultCallback_0_1<del, void, T, A1>
1836  : public TessCallback1<A1> {
1837  public:
1839  typedef void (T::*MemberSignature)(A1) ;
1840 
1841  private:
1842  T* object_;
1843  MemberSignature member_;
1844 
1845  public:
1847  T* object, MemberSignature member)
1848  : object_(object),
1849  member_(member) {
1850  }
1851 
1852  virtual void Run(A1 a1) {
1853  if (!del) {
1854  (object_->*member_)(a1);
1855  } else {
1856  (object_->*member_)(a1);
1857  // zero out the pointer to ensure segfault if used again
1858  member_ = NULL;
1859  delete this;
1860  }
1861  }
1862 };
1863 
1864 #ifndef SWIG
1865 template <class T1, class T2, class R, class A1>
1868  T1* obj, R (T2::*member)(A1) ) {
1870  obj, member);
1871 }
1872 #endif
1873 
1874 #ifndef SWIG
1875 template <class T1, class T2, class R, class A1>
1878  T1* obj, R (T2::*member)(A1) ) {
1880  obj, member);
1881 }
1882 #endif
1883 
1884 template <bool del, class R, class A1>
1886  public:
1888  typedef R (*FunctionSignature)(A1);
1889 
1890  private:
1891  FunctionSignature function_;
1892 
1893  public:
1895  FunctionSignature function)
1896  : function_(function) {
1897  }
1898 
1899  virtual R Run(A1 a1) {
1900  if (!del) {
1901  R result = (*function_)(a1);
1902  return result;
1903  } else {
1904  R result = (*function_)(a1);
1905  // zero out the pointer to ensure segfault if used again
1906  function_ = NULL;
1907  delete this;
1908  return result;
1909  }
1910  }
1911 };
1912 
1913 template <bool del, class A1>
1915  : public TessCallback1<A1> {
1916  public:
1918  typedef void (*FunctionSignature)(A1);
1919 
1920  private:
1921  FunctionSignature function_;
1922 
1923  public:
1925  FunctionSignature function)
1926  : function_(function) {
1927  }
1928 
1929  virtual void Run(A1 a1) {
1930  if (!del) {
1931  (*function_)(a1);
1932  } else {
1933  (*function_)(a1);
1934  // zero out the pointer to ensure segfault if used again
1935  function_ = NULL;
1936  delete this;
1937  }
1938  }
1939 };
1940 
1941 template <class R, class A1>
1943 NewTessCallback(R (*function)(A1)) {
1944  return new _TessFunctionResultCallback_0_1<true,R,A1>(function);
1945 }
1946 
1947 template <class R, class A1>
1949 NewPermanentTessCallback(R (*function)(A1)) {
1950  return new _TessFunctionResultCallback_0_1<false,R,A1>(function);
1951 }
1952 
1953 template <bool del, class R, class T, class P1, class A1>
1955  public:
1957  typedef R (T::*MemberSignature)(P1,A1) const;
1958 
1959  private:
1960  const T* object_;
1961  MemberSignature member_;
1962  typename remove_reference<P1>::type p1_;
1963 
1964  public:
1965  inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1)
1966  : object_(object),
1967  member_(member), p1_(p1) { }
1968 
1969  virtual R Run(A1 a1) {
1970  if (!del) {
1971  R result = (object_->*member_)(p1_,a1);
1972  return result;
1973  } else {
1974  R result = (object_->*member_)(p1_,a1);
1975  // zero out the pointer to ensure segfault if used again
1976  member_ = NULL;
1977  delete this;
1978  return result;
1979  }
1980  }
1981 };
1982 
1983 template <bool del, class T, class P1, class A1>
1984 class _ConstTessMemberResultCallback_1_1<del, void, T, P1, A1> : public TessCallback1<A1> {
1985  public:
1987  typedef void (T::*MemberSignature)(P1,A1) const;
1988 
1989  private:
1990  const T* object_;
1991  MemberSignature member_;
1992  typename remove_reference<P1>::type p1_;
1993 
1994  public:
1995  inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1)
1996  : object_(object),
1997  member_(member), p1_(p1) { }
1998 
1999  virtual void Run(A1 a1) {
2000  if (!del) {
2001  (object_->*member_)(p1_,a1);
2002  } else {
2003  (object_->*member_)(p1_,a1);
2004  // zero out the pointer to ensure segfault if used again
2005  member_ = NULL;
2006  delete this;
2007  }
2008  }
2009 };
2010 
2011 #ifndef SWIG
2012 template <class T1, class T2, class R, class P1, class A1>
2014 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity<P1>::type p1) {
2015  return new _ConstTessMemberResultCallback_1_1<true,R,T1,P1,A1>(obj, member, p1);
2016 }
2017 #endif
2018 
2019 #ifndef SWIG
2020 template <class T1, class T2, class R, class P1, class A1>
2022 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity<P1>::type p1) {
2023  return new _ConstTessMemberResultCallback_1_1<false,R,T1,P1,A1>(obj, member, p1);
2024 }
2025 #endif
2026 
2027 template <bool del, class R, class T, class P1, class A1>
2029  public:
2031  typedef R (T::*MemberSignature)(P1,A1) ;
2032 
2033  private:
2034  T* object_;
2035  MemberSignature member_;
2036  typename remove_reference<P1>::type p1_;
2037 
2038  public:
2039  inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1)
2040  : object_(object),
2041  member_(member), p1_(p1) { }
2042 
2043  virtual R Run(A1 a1) {
2044  if (!del) {
2045  R result = (object_->*member_)(p1_,a1);
2046  return result;
2047  } else {
2048  R result = (object_->*member_)(p1_,a1);
2049  // zero out the pointer to ensure segfault if used again
2050  member_ = NULL;
2051  delete this;
2052  return result;
2053  }
2054  }
2055 };
2056 
2057 template <bool del, class T, class P1, class A1>
2058 class _TessMemberResultCallback_1_1<del, void, T, P1, A1> : public TessCallback1<A1> {
2059  public:
2061  typedef void (T::*MemberSignature)(P1,A1) ;
2062 
2063  private:
2064  T* object_;
2065  MemberSignature member_;
2066  typename remove_reference<P1>::type p1_;
2067 
2068  public:
2069  inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1)
2070  : object_(object),
2071  member_(member), p1_(p1) { }
2072 
2073  virtual void Run(A1 a1) {
2074  if (!del) {
2075  (object_->*member_)(p1_,a1);
2076  } else {
2077  (object_->*member_)(p1_,a1);
2078  // zero out the pointer to ensure segfault if used again
2079  member_ = NULL;
2080  delete this;
2081  }
2082  }
2083 };
2084 
2085 #ifndef SWIG
2086 template <class T1, class T2, class R, class P1, class A1>
2088 NewTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity<P1>::type p1) {
2089  return new _TessMemberResultCallback_1_1<true,R,T1,P1,A1>(obj, member, p1);
2090 }
2091 #endif
2092 
2093 #ifndef SWIG
2094 template <class T1, class T2, class R, class P1, class A1>
2096 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity<P1>::type p1) {
2097  return new _TessMemberResultCallback_1_1<false,R,T1,P1,A1>(obj, member, p1);
2098 }
2099 #endif
2100 
2101 template <bool del, class R, class P1, class A1>
2103  public:
2105  typedef R (*FunctionSignature)(P1,A1);
2106 
2107  private:
2108  FunctionSignature function_;
2109  typename remove_reference<P1>::type p1_;
2110 
2111  public:
2113  : function_(function), p1_(p1) { }
2114 
2115  virtual R Run(A1 a1) {
2116  if (!del) {
2117  R result = (*function_)(p1_,a1);
2118  return result;
2119  } else {
2120  R result = (*function_)(p1_,a1);
2121  // zero out the pointer to ensure segfault if used again
2122  function_ = NULL;
2123  delete this;
2124  return result;
2125  }
2126  }
2127 };
2128 
2129 template <bool del, class P1, class A1>
2130 class _TessFunctionResultCallback_1_1<del, void, P1, A1> : public TessCallback1<A1> {
2131  public:
2133  typedef void (*FunctionSignature)(P1,A1);
2134 
2135  private:
2136  FunctionSignature function_;
2137  typename remove_reference<P1>::type p1_;
2138 
2139  public:
2141  : function_(function), p1_(p1) { }
2142 
2143  virtual void Run(A1 a1) {
2144  if (!del) {
2145  (*function_)(p1_,a1);
2146  } else {
2147  (*function_)(p1_,a1);
2148  // zero out the pointer to ensure segfault if used again
2149  function_ = NULL;
2150  delete this;
2151  }
2152  }
2153 };
2154 
2155 template <class R, class P1, class A1>
2157 NewTessCallback(R (*function)(P1,A1), typename Identity<P1>::type p1) {
2158  return new _TessFunctionResultCallback_1_1<true,R,P1,A1>(function, p1);
2159 }
2160 
2161 template <class R, class P1, class A1>
2163 NewPermanentTessCallback(R (*function)(P1,A1), typename Identity<P1>::type p1) {
2164  return new _TessFunctionResultCallback_1_1<false,R,P1,A1>(function, p1);
2165 }
2166 
2167 template <bool del, class R, class T, class P1, class P2, class A1>
2169  public:
2171  typedef R (T::*MemberSignature)(P1,P2,A1) const;
2172 
2173  private:
2174  const T* object_;
2175  MemberSignature member_;
2176  typename remove_reference<P1>::type p1_;
2177  typename remove_reference<P2>::type p2_;
2178 
2179  public:
2180  inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2)
2181  : object_(object),
2182  member_(member), p1_(p1), p2_(p2) { }
2183 
2184  virtual R Run(A1 a1) {
2185  if (!del) {
2186  R result = (object_->*member_)(p1_,p2_,a1);
2187  return result;
2188  } else {
2189  R result = (object_->*member_)(p1_,p2_,a1);
2190  // zero out the pointer to ensure segfault if used again
2191  member_ = NULL;
2192  delete this;
2193  return result;
2194  }
2195  }
2196 };
2197 
2198 template <bool del, class T, class P1, class P2, class A1>
2199 class _ConstTessMemberResultCallback_2_1<del, void, T, P1, P2, A1> : public TessCallback1<A1> {
2200  public:
2202  typedef void (T::*MemberSignature)(P1,P2,A1) const;
2203 
2204  private:
2205  const T* object_;
2206  MemberSignature member_;
2207  typename remove_reference<P1>::type p1_;
2208  typename remove_reference<P2>::type p2_;
2209 
2210  public:
2211  inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2)
2212  : object_(object),
2213  member_(member), p1_(p1), p2_(p2) { }
2214 
2215  virtual void Run(A1 a1) {
2216  if (!del) {
2217  (object_->*member_)(p1_,p2_,a1);
2218  } else {
2219  (object_->*member_)(p1_,p2_,a1);
2220  // zero out the pointer to ensure segfault if used again
2221  member_ = NULL;
2222  delete this;
2223  }
2224  }
2225 };
2226 
2227 #ifndef SWIG
2228 template <class T1, class T2, class R, class P1, class P2, class A1>
2230 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
2231  return new _ConstTessMemberResultCallback_2_1<true,R,T1,P1,P2,A1>(obj, member, p1, p2);
2232 }
2233 #endif
2234 
2235 #ifndef SWIG
2236 template <class T1, class T2, class R, class P1, class P2, class A1>
2238 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
2239  return new _ConstTessMemberResultCallback_2_1<false,R,T1,P1,P2,A1>(obj, member, p1, p2);
2240 }
2241 #endif
2242 
2243 template <bool del, class R, class T, class P1, class P2, class A1>
2245  public:
2247  typedef R (T::*MemberSignature)(P1,P2,A1) ;
2248 
2249  private:
2250  T* object_;
2251  MemberSignature member_;
2252  typename remove_reference<P1>::type p1_;
2253  typename remove_reference<P2>::type p2_;
2254 
2255  public:
2256  inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2)
2257  : object_(object),
2258  member_(member), p1_(p1), p2_(p2) { }
2259 
2260  virtual R Run(A1 a1) {
2261  if (!del) {
2262  R result = (object_->*member_)(p1_,p2_,a1);
2263  return result;
2264  } else {
2265  R result = (object_->*member_)(p1_,p2_,a1);
2266  // zero out the pointer to ensure segfault if used again
2267  member_ = NULL;
2268  delete this;
2269  return result;
2270  }
2271  }
2272 };
2273 
2274 template <bool del, class T, class P1, class P2, class A1>
2275 class _TessMemberResultCallback_2_1<del, void, T, P1, P2, A1> : public TessCallback1<A1> {
2276  public:
2278  typedef void (T::*MemberSignature)(P1,P2,A1) ;
2279 
2280  private:
2281  T* object_;
2282  MemberSignature member_;
2283  typename remove_reference<P1>::type p1_;
2284  typename remove_reference<P2>::type p2_;
2285 
2286  public:
2287  inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2)
2288  : object_(object),
2289  member_(member), p1_(p1), p2_(p2) { }
2290 
2291  virtual void Run(A1 a1) {
2292  if (!del) {
2293  (object_->*member_)(p1_,p2_,a1);
2294  } else {
2295  (object_->*member_)(p1_,p2_,a1);
2296  // zero out the pointer to ensure segfault if used again
2297  member_ = NULL;
2298  delete this;
2299  }
2300  }
2301 };
2302 
2303 #ifndef SWIG
2304 template <class T1, class T2, class R, class P1, class P2, class A1>
2306 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
2307  return new _TessMemberResultCallback_2_1<true,R,T1,P1,P2,A1>(obj, member, p1, p2);
2308 }
2309 #endif
2310 
2311 #ifndef SWIG
2312 template <class T1, class T2, class R, class P1, class P2, class A1>
2314 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
2315  return new _TessMemberResultCallback_2_1<false,R,T1,P1,P2,A1>(obj, member, p1, p2);
2316 }
2317 #endif
2318 
2319 template <bool del, class R, class P1, class P2, class A1>
2321  public:
2323  typedef R (*FunctionSignature)(P1,P2,A1);
2324 
2325  private:
2326  FunctionSignature function_;
2327  typename remove_reference<P1>::type p1_;
2328  typename remove_reference<P2>::type p2_;
2329 
2330  public:
2332  : function_(function), p1_(p1), p2_(p2) { }
2333 
2334  virtual R Run(A1 a1) {
2335  if (!del) {
2336  R result = (*function_)(p1_,p2_,a1);
2337  return result;
2338  } else {
2339  R result = (*function_)(p1_,p2_,a1);
2340  // zero out the pointer to ensure segfault if used again
2341  function_ = NULL;
2342  delete this;
2343  return result;
2344  }
2345  }
2346 };
2347 
2348 template <bool del, class P1, class P2, class A1>
2349 class _TessFunctionResultCallback_2_1<del, void, P1, P2, A1> : public TessCallback1<A1> {
2350  public:
2352  typedef void (*FunctionSignature)(P1,P2,A1);
2353 
2354  private:
2355  FunctionSignature function_;
2356  typename remove_reference<P1>::type p1_;
2357  typename remove_reference<P2>::type p2_;
2358 
2359  public:
2361  : function_(function), p1_(p1), p2_(p2) { }
2362 
2363  virtual void Run(A1 a1) {
2364  if (!del) {
2365  (*function_)(p1_,p2_,a1);
2366  } else {
2367  (*function_)(p1_,p2_,a1);
2368  // zero out the pointer to ensure segfault if used again
2369  function_ = NULL;
2370  delete this;
2371  }
2372  }
2373 };
2374 
2375 template <class R, class P1, class P2, class A1>
2377 NewTessCallback(R (*function)(P1,P2,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
2378  return new _TessFunctionResultCallback_2_1<true,R,P1,P2,A1>(function, p1, p2);
2379 }
2380 
2381 template <class R, class P1, class P2, class A1>
2383 NewPermanentTessCallback(R (*function)(P1,P2,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
2384  return new _TessFunctionResultCallback_2_1<false,R,P1,P2,A1>(function, p1, p2);
2385 }
2386 
2387 template <bool del, class R, class T, class P1, class P2, class P3, class A1>
2389  public:
2391  typedef R (T::*MemberSignature)(P1,P2,P3,A1) const;
2392 
2393  private:
2394  const T* object_;
2395  MemberSignature member_;
2396  typename remove_reference<P1>::type p1_;
2397  typename remove_reference<P2>::type p2_;
2398  typename remove_reference<P3>::type p3_;
2399 
2400  public:
2401  inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
2402  : object_(object),
2403  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
2404 
2405  virtual R Run(A1 a1) {
2406  if (!del) {
2407  R result = (object_->*member_)(p1_,p2_,p3_,a1);
2408  return result;
2409  } else {
2410  R result = (object_->*member_)(p1_,p2_,p3_,a1);
2411  // zero out the pointer to ensure segfault if used again
2412  member_ = NULL;
2413  delete this;
2414  return result;
2415  }
2416  }
2417 };
2418 
2419 template <bool del, class T, class P1, class P2, class P3, class A1>
2420 class _ConstTessMemberResultCallback_3_1<del, void, T, P1, P2, P3, A1> : public TessCallback1<A1> {
2421  public:
2423  typedef void (T::*MemberSignature)(P1,P2,P3,A1) const;
2424 
2425  private:
2426  const T* object_;
2427  MemberSignature member_;
2428  typename remove_reference<P1>::type p1_;
2429  typename remove_reference<P2>::type p2_;
2430  typename remove_reference<P3>::type p3_;
2431 
2432  public:
2433  inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
2434  : object_(object),
2435  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
2436 
2437  virtual void Run(A1 a1) {
2438  if (!del) {
2439  (object_->*member_)(p1_,p2_,p3_,a1);
2440  } else {
2441  (object_->*member_)(p1_,p2_,p3_,a1);
2442  // zero out the pointer to ensure segfault if used again
2443  member_ = NULL;
2444  delete this;
2445  }
2446  }
2447 };
2448 
2449 #ifndef SWIG
2450 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
2452 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
2453  return new _ConstTessMemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
2454 }
2455 #endif
2456 
2457 #ifndef SWIG
2458 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
2460 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
2461  return new _ConstTessMemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
2462 }
2463 #endif
2464 
2465 template <bool del, class R, class T, class P1, class P2, class P3, class A1>
2467  public:
2469  typedef R (T::*MemberSignature)(P1,P2,P3,A1) ;
2470 
2471  private:
2472  T* object_;
2473  MemberSignature member_;
2474  typename remove_reference<P1>::type p1_;
2475  typename remove_reference<P2>::type p2_;
2476  typename remove_reference<P3>::type p3_;
2477 
2478  public:
2479  inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
2480  : object_(object),
2481  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
2482 
2483  virtual R Run(A1 a1) {
2484  if (!del) {
2485  R result = (object_->*member_)(p1_,p2_,p3_,a1);
2486  return result;
2487  } else {
2488  R result = (object_->*member_)(p1_,p2_,p3_,a1);
2489  // zero out the pointer to ensure segfault if used again
2490  member_ = NULL;
2491  delete this;
2492  return result;
2493  }
2494  }
2495 };
2496 
2497 template <bool del, class T, class P1, class P2, class P3, class A1>
2498 class _TessMemberResultCallback_3_1<del, void, T, P1, P2, P3, A1> : public TessCallback1<A1> {
2499  public:
2501  typedef void (T::*MemberSignature)(P1,P2,P3,A1) ;
2502 
2503  private:
2504  T* object_;
2505  MemberSignature member_;
2506  typename remove_reference<P1>::type p1_;
2507  typename remove_reference<P2>::type p2_;
2508  typename remove_reference<P3>::type p3_;
2509 
2510  public:
2511  inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
2512  : object_(object),
2513  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
2514 
2515  virtual void Run(A1 a1) {
2516  if (!del) {
2517  (object_->*member_)(p1_,p2_,p3_,a1);
2518  } else {
2519  (object_->*member_)(p1_,p2_,p3_,a1);
2520  // zero out the pointer to ensure segfault if used again
2521  member_ = NULL;
2522  delete this;
2523  }
2524  }
2525 };
2526 
2527 #ifndef SWIG
2528 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
2530 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
2531  return new _TessMemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
2532 }
2533 #endif
2534 
2535 #ifndef SWIG
2536 template <class T1, class T2, class R, class P1, class P2, class P3, class A1>
2538 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
2539  return new _TessMemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>(obj, member, p1, p2, p3);
2540 }
2541 #endif
2542 
2543 template <bool del, class R, class P1, class P2, class P3, class A1>
2545  public:
2547  typedef R (*FunctionSignature)(P1,P2,P3,A1);
2548 
2549  private:
2550  FunctionSignature function_;
2551  typename remove_reference<P1>::type p1_;
2552  typename remove_reference<P2>::type p2_;
2553  typename remove_reference<P3>::type p3_;
2554 
2555  public:
2556  inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
2557  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
2558 
2559  virtual R Run(A1 a1) {
2560  if (!del) {
2561  R result = (*function_)(p1_,p2_,p3_,a1);
2562  return result;
2563  } else {
2564  R result = (*function_)(p1_,p2_,p3_,a1);
2565  // zero out the pointer to ensure segfault if used again
2566  function_ = NULL;
2567  delete this;
2568  return result;
2569  }
2570  }
2571 };
2572 
2573 template <bool del, class P1, class P2, class P3, class A1>
2574 class _TessFunctionResultCallback_3_1<del, void, P1, P2, P3, A1> : public TessCallback1<A1> {
2575  public:
2577  typedef void (*FunctionSignature)(P1,P2,P3,A1);
2578 
2579  private:
2580  FunctionSignature function_;
2581  typename remove_reference<P1>::type p1_;
2582  typename remove_reference<P2>::type p2_;
2583  typename remove_reference<P3>::type p3_;
2584 
2585  public:
2586  inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
2587  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
2588 
2589  virtual void Run(A1 a1) {
2590  if (!del) {
2591  (*function_)(p1_,p2_,p3_,a1);
2592  } else {
2593  (*function_)(p1_,p2_,p3_,a1);
2594  // zero out the pointer to ensure segfault if used again
2595  function_ = NULL;
2596  delete this;
2597  }
2598  }
2599 };
2600 
2601 template <class R, class P1, class P2, class P3, class A1>
2603 NewTessCallback(R (*function)(P1,P2,P3,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
2604  return new _TessFunctionResultCallback_3_1<true,R,P1,P2,P3,A1>(function, p1, p2, p3);
2605 }
2606 
2607 template <class R, class P1, class P2, class P3, class A1>
2609 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
2610  return new _TessFunctionResultCallback_3_1<false,R,P1,P2,P3,A1>(function, p1, p2, p3);
2611 }
2612 
2613 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1>
2615  public:
2617  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) const;
2618 
2619  private:
2620  const T* object_;
2621  MemberSignature member_;
2622  typename remove_reference<P1>::type p1_;
2623  typename remove_reference<P2>::type p2_;
2624  typename remove_reference<P3>::type p3_;
2625  typename remove_reference<P4>::type p4_;
2626 
2627  public:
2628  inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
2629  : object_(object),
2630  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
2631 
2632  virtual R Run(A1 a1) {
2633  if (!del) {
2634  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2635  return result;
2636  } else {
2637  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2638  // zero out the pointer to ensure segfault if used again
2639  member_ = NULL;
2640  delete this;
2641  return result;
2642  }
2643  }
2644 };
2645 
2646 template <bool del, class T, class P1, class P2, class P3, class P4, class A1>
2647 class _ConstTessMemberResultCallback_4_1<del, void, T, P1, P2, P3, P4, A1> : public TessCallback1<A1> {
2648  public:
2650  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) const;
2651 
2652  private:
2653  const T* object_;
2654  MemberSignature member_;
2655  typename remove_reference<P1>::type p1_;
2656  typename remove_reference<P2>::type p2_;
2657  typename remove_reference<P3>::type p3_;
2658  typename remove_reference<P4>::type p4_;
2659 
2660  public:
2661  inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
2662  : object_(object),
2663  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
2664 
2665  virtual void Run(A1 a1) {
2666  if (!del) {
2667  (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2668  } else {
2669  (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2670  // zero out the pointer to ensure segfault if used again
2671  member_ = NULL;
2672  delete this;
2673  }
2674  }
2675 };
2676 
2677 #ifndef SWIG
2678 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
2680 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
2681  return new _ConstTessMemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
2682 }
2683 #endif
2684 
2685 #ifndef SWIG
2686 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
2688 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
2689  return new _ConstTessMemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
2690 }
2691 #endif
2692 
2693 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1>
2695  public:
2697  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) ;
2698 
2699  private:
2700  T* object_;
2701  MemberSignature member_;
2702  typename remove_reference<P1>::type p1_;
2703  typename remove_reference<P2>::type p2_;
2704  typename remove_reference<P3>::type p3_;
2705  typename remove_reference<P4>::type p4_;
2706 
2707  public:
2708  inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
2709  : object_(object),
2710  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
2711 
2712  virtual R Run(A1 a1) {
2713  if (!del) {
2714  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2715  return result;
2716  } else {
2717  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2718  // zero out the pointer to ensure segfault if used again
2719  member_ = NULL;
2720  delete this;
2721  return result;
2722  }
2723  }
2724 };
2725 
2726 template <bool del, class T, class P1, class P2, class P3, class P4, class A1>
2727 class _TessMemberResultCallback_4_1<del, void, T, P1, P2, P3, P4, A1> : public TessCallback1<A1> {
2728  public:
2730  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) ;
2731 
2732  private:
2733  T* object_;
2734  MemberSignature member_;
2735  typename remove_reference<P1>::type p1_;
2736  typename remove_reference<P2>::type p2_;
2737  typename remove_reference<P3>::type p3_;
2738  typename remove_reference<P4>::type p4_;
2739 
2740  public:
2741  inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
2742  : object_(object),
2743  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
2744 
2745  virtual void Run(A1 a1) {
2746  if (!del) {
2747  (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2748  } else {
2749  (object_->*member_)(p1_,p2_,p3_,p4_,a1);
2750  // zero out the pointer to ensure segfault if used again
2751  member_ = NULL;
2752  delete this;
2753  }
2754  }
2755 };
2756 
2757 #ifndef SWIG
2758 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
2760 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
2761  return new _TessMemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
2762 }
2763 #endif
2764 
2765 #ifndef SWIG
2766 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
2768 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
2769  return new _TessMemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>(obj, member, p1, p2, p3, p4);
2770 }
2771 #endif
2772 
2773 template <bool del, class R, class P1, class P2, class P3, class P4, class A1>
2775  public:
2777  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1);
2778 
2779  private:
2780  FunctionSignature function_;
2781  typename remove_reference<P1>::type p1_;
2782  typename remove_reference<P2>::type p2_;
2783  typename remove_reference<P3>::type p3_;
2784  typename remove_reference<P4>::type p4_;
2785 
2786  public:
2787  inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
2788  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
2789 
2790  virtual R Run(A1 a1) {
2791  if (!del) {
2792  R result = (*function_)(p1_,p2_,p3_,p4_,a1);
2793  return result;
2794  } else {
2795  R result = (*function_)(p1_,p2_,p3_,p4_,a1);
2796  // zero out the pointer to ensure segfault if used again
2797  function_ = NULL;
2798  delete this;
2799  return result;
2800  }
2801  }
2802 };
2803 
2804 template <bool del, class P1, class P2, class P3, class P4, class A1>
2805 class _TessFunctionResultCallback_4_1<del, void, P1, P2, P3, P4, A1> : public TessCallback1<A1> {
2806  public:
2808  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1);
2809 
2810  private:
2811  FunctionSignature function_;
2812  typename remove_reference<P1>::type p1_;
2813  typename remove_reference<P2>::type p2_;
2814  typename remove_reference<P3>::type p3_;
2815  typename remove_reference<P4>::type p4_;
2816 
2817  public:
2818  inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
2819  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
2820 
2821  virtual void Run(A1 a1) {
2822  if (!del) {
2823  (*function_)(p1_,p2_,p3_,p4_,a1);
2824  } else {
2825  (*function_)(p1_,p2_,p3_,p4_,a1);
2826  // zero out the pointer to ensure segfault if used again
2827  function_ = NULL;
2828  delete this;
2829  }
2830  }
2831 };
2832 
2833 template <class R, class P1, class P2, class P3, class P4, class A1>
2835 NewTessCallback(R (*function)(P1,P2,P3,P4,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
2836  return new _TessFunctionResultCallback_4_1<true,R,P1,P2,P3,P4,A1>(function, p1, p2, p3, p4);
2837 }
2838 
2839 template <class R, class P1, class P2, class P3, class P4, class A1>
2841 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
2842  return new _TessFunctionResultCallback_4_1<false,R,P1,P2,P3,P4,A1>(function, p1, p2, p3, p4);
2843 }
2844 
2845 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1>
2847  public:
2849  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const;
2850 
2851  private:
2852  const T* object_;
2853  MemberSignature member_;
2854  typename remove_reference<P1>::type p1_;
2855  typename remove_reference<P2>::type p2_;
2856  typename remove_reference<P3>::type p3_;
2857  typename remove_reference<P4>::type p4_;
2858  typename remove_reference<P5>::type p5_;
2859 
2860  public:
2861  inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
2862  : object_(object),
2863  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
2864 
2865  virtual R Run(A1 a1) {
2866  if (!del) {
2867  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2868  return result;
2869  } else {
2870  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2871  // zero out the pointer to ensure segfault if used again
2872  member_ = NULL;
2873  delete this;
2874  return result;
2875  }
2876  }
2877 };
2878 
2879 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1>
2880 class _ConstTessMemberResultCallback_5_1<del, void, T, P1, P2, P3, P4, P5, A1> : public TessCallback1<A1> {
2881  public:
2883  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const;
2884 
2885  private:
2886  const T* object_;
2887  MemberSignature member_;
2888  typename remove_reference<P1>::type p1_;
2889  typename remove_reference<P2>::type p2_;
2890  typename remove_reference<P3>::type p3_;
2891  typename remove_reference<P4>::type p4_;
2892  typename remove_reference<P5>::type p5_;
2893 
2894  public:
2895  inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
2896  : object_(object),
2897  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
2898 
2899  virtual void Run(A1 a1) {
2900  if (!del) {
2901  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2902  } else {
2903  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2904  // zero out the pointer to ensure segfault if used again
2905  member_ = NULL;
2906  delete this;
2907  }
2908  }
2909 };
2910 
2911 #ifndef SWIG
2912 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
2914 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
2915  return new _ConstTessMemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
2916 }
2917 #endif
2918 
2919 #ifndef SWIG
2920 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
2922 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
2923  return new _ConstTessMemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
2924 }
2925 #endif
2926 
2927 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1>
2929  public:
2931  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ;
2932 
2933  private:
2934  T* object_;
2935  MemberSignature member_;
2936  typename remove_reference<P1>::type p1_;
2937  typename remove_reference<P2>::type p2_;
2938  typename remove_reference<P3>::type p3_;
2939  typename remove_reference<P4>::type p4_;
2940  typename remove_reference<P5>::type p5_;
2941 
2942  public:
2943  inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
2944  : object_(object),
2945  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
2946 
2947  virtual R Run(A1 a1) {
2948  if (!del) {
2949  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2950  return result;
2951  } else {
2952  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2953  // zero out the pointer to ensure segfault if used again
2954  member_ = NULL;
2955  delete this;
2956  return result;
2957  }
2958  }
2959 };
2960 
2961 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1>
2962 class _TessMemberResultCallback_5_1<del, void, T, P1, P2, P3, P4, P5, A1> : public TessCallback1<A1> {
2963  public:
2965  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ;
2966 
2967  private:
2968  T* object_;
2969  MemberSignature member_;
2970  typename remove_reference<P1>::type p1_;
2971  typename remove_reference<P2>::type p2_;
2972  typename remove_reference<P3>::type p3_;
2973  typename remove_reference<P4>::type p4_;
2974  typename remove_reference<P5>::type p5_;
2975 
2976  public:
2977  inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
2978  : object_(object),
2979  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
2980 
2981  virtual void Run(A1 a1) {
2982  if (!del) {
2983  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2984  } else {
2985  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
2986  // zero out the pointer to ensure segfault if used again
2987  member_ = NULL;
2988  delete this;
2989  }
2990  }
2991 };
2992 
2993 #ifndef SWIG
2994 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
2996 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
2997  return new _TessMemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
2998 }
2999 #endif
3000 
3001 #ifndef SWIG
3002 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
3004 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
3005  return new _TessMemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>(obj, member, p1, p2, p3, p4, p5);
3006 }
3007 #endif
3008 
3009 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1>
3011  public:
3013  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1);
3014 
3015  private:
3016  FunctionSignature function_;
3017  typename remove_reference<P1>::type p1_;
3018  typename remove_reference<P2>::type p2_;
3019  typename remove_reference<P3>::type p3_;
3020  typename remove_reference<P4>::type p4_;
3021  typename remove_reference<P5>::type p5_;
3022 
3023  public:
3024  inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
3025  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
3026 
3027  virtual R Run(A1 a1) {
3028  if (!del) {
3029  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
3030  return result;
3031  } else {
3032  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
3033  // zero out the pointer to ensure segfault if used again
3034  function_ = NULL;
3035  delete this;
3036  return result;
3037  }
3038  }
3039 };
3040 
3041 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1>
3042 class _TessFunctionResultCallback_5_1<del, void, P1, P2, P3, P4, P5, A1> : public TessCallback1<A1> {
3043  public:
3045  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1);
3046 
3047  private:
3048  FunctionSignature function_;
3049  typename remove_reference<P1>::type p1_;
3050  typename remove_reference<P2>::type p2_;
3051  typename remove_reference<P3>::type p3_;
3052  typename remove_reference<P4>::type p4_;
3053  typename remove_reference<P5>::type p5_;
3054 
3055  public:
3056  inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
3057  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
3058 
3059  virtual void Run(A1 a1) {
3060  if (!del) {
3061  (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
3062  } else {
3063  (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
3064  // zero out the pointer to ensure segfault if used again
3065  function_ = NULL;
3066  delete this;
3067  }
3068  }
3069 };
3070 
3071 template <class R, class P1, class P2, class P3, class P4, class P5, class A1>
3073 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
3074  return new _TessFunctionResultCallback_5_1<true,R,P1,P2,P3,P4,P5,A1>(function, p1, p2, p3, p4, p5);
3075 }
3076 
3077 template <class R, class P1, class P2, class P3, class P4, class P5, class A1>
3079 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
3080  return new _TessFunctionResultCallback_5_1<false,R,P1,P2,P3,P4,P5,A1>(function, p1, p2, p3, p4, p5);
3081 }
3082 
3083 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3085  public:
3087  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const;
3088 
3089  private:
3090  const T* object_;
3091  MemberSignature member_;
3092  typename remove_reference<P1>::type p1_;
3093  typename remove_reference<P2>::type p2_;
3094  typename remove_reference<P3>::type p3_;
3095  typename remove_reference<P4>::type p4_;
3096  typename remove_reference<P5>::type p5_;
3097  typename remove_reference<P6>::type p6_;
3098 
3099  public:
3100  inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
3101  : object_(object),
3102  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
3103 
3104  virtual R Run(A1 a1) {
3105  if (!del) {
3106  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3107  return result;
3108  } else {
3109  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3110  // zero out the pointer to ensure segfault if used again
3111  member_ = NULL;
3112  delete this;
3113  return result;
3114  }
3115  }
3116 };
3117 
3118 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3119 class _ConstTessMemberResultCallback_6_1<del, void, T, P1, P2, P3, P4, P5, P6, A1> : public TessCallback1<A1> {
3120  public:
3122  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const;
3123 
3124  private:
3125  const T* object_;
3126  MemberSignature member_;
3127  typename remove_reference<P1>::type p1_;
3128  typename remove_reference<P2>::type p2_;
3129  typename remove_reference<P3>::type p3_;
3130  typename remove_reference<P4>::type p4_;
3131  typename remove_reference<P5>::type p5_;
3132  typename remove_reference<P6>::type p6_;
3133 
3134  public:
3135  inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
3136  : object_(object),
3137  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
3138 
3139  virtual void Run(A1 a1) {
3140  if (!del) {
3141  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3142  } else {
3143  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3144  // zero out the pointer to ensure segfault if used again
3145  member_ = NULL;
3146  delete this;
3147  }
3148  }
3149 };
3150 
3151 #ifndef SWIG
3152 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3154 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
3155  return new _ConstTessMemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
3156 }
3157 #endif
3158 
3159 #ifndef SWIG
3160 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3162 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
3163  return new _ConstTessMemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
3164 }
3165 #endif
3166 
3167 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3169  public:
3171  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ;
3172 
3173  private:
3174  T* object_;
3175  MemberSignature member_;
3176  typename remove_reference<P1>::type p1_;
3177  typename remove_reference<P2>::type p2_;
3178  typename remove_reference<P3>::type p3_;
3179  typename remove_reference<P4>::type p4_;
3180  typename remove_reference<P5>::type p5_;
3181  typename remove_reference<P6>::type p6_;
3182 
3183  public:
3184  inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
3185  : object_(object),
3186  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
3187 
3188  virtual R Run(A1 a1) {
3189  if (!del) {
3190  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3191  return result;
3192  } else {
3193  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3194  // zero out the pointer to ensure segfault if used again
3195  member_ = NULL;
3196  delete this;
3197  return result;
3198  }
3199  }
3200 };
3201 
3202 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3203 class _TessMemberResultCallback_6_1<del, void, T, P1, P2, P3, P4, P5, P6, A1> : public TessCallback1<A1> {
3204  public:
3206  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ;
3207 
3208  private:
3209  T* object_;
3210  MemberSignature member_;
3211  typename remove_reference<P1>::type p1_;
3212  typename remove_reference<P2>::type p2_;
3213  typename remove_reference<P3>::type p3_;
3214  typename remove_reference<P4>::type p4_;
3215  typename remove_reference<P5>::type p5_;
3216  typename remove_reference<P6>::type p6_;
3217 
3218  public:
3219  inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
3220  : object_(object),
3221  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
3222 
3223  virtual void Run(A1 a1) {
3224  if (!del) {
3225  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3226  } else {
3227  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3228  // zero out the pointer to ensure segfault if used again
3229  member_ = NULL;
3230  delete this;
3231  }
3232  }
3233 };
3234 
3235 #ifndef SWIG
3236 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3238 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
3239  return new _TessMemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
3240 }
3241 #endif
3242 
3243 #ifndef SWIG
3244 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3246 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
3247  return new _TessMemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>(obj, member, p1, p2, p3, p4, p5, p6);
3248 }
3249 #endif
3250 
3251 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3253  public:
3255  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1);
3256 
3257  private:
3258  FunctionSignature function_;
3259  typename remove_reference<P1>::type p1_;
3260  typename remove_reference<P2>::type p2_;
3261  typename remove_reference<P3>::type p3_;
3262  typename remove_reference<P4>::type p4_;
3263  typename remove_reference<P5>::type p5_;
3264  typename remove_reference<P6>::type p6_;
3265 
3266  public:
3267  inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
3268  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
3269 
3270  virtual R Run(A1 a1) {
3271  if (!del) {
3272  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3273  return result;
3274  } else {
3275  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3276  // zero out the pointer to ensure segfault if used again
3277  function_ = NULL;
3278  delete this;
3279  return result;
3280  }
3281  }
3282 };
3283 
3284 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3285 class _TessFunctionResultCallback_6_1<del, void, P1, P2, P3, P4, P5, P6, A1> : public TessCallback1<A1> {
3286  public:
3288  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1);
3289 
3290  private:
3291  FunctionSignature function_;
3292  typename remove_reference<P1>::type p1_;
3293  typename remove_reference<P2>::type p2_;
3294  typename remove_reference<P3>::type p3_;
3295  typename remove_reference<P4>::type p4_;
3296  typename remove_reference<P5>::type p5_;
3297  typename remove_reference<P6>::type p6_;
3298 
3299  public:
3300  inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
3301  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
3302 
3303  virtual void Run(A1 a1) {
3304  if (!del) {
3305  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3306  } else {
3307  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
3308  // zero out the pointer to ensure segfault if used again
3309  function_ = NULL;
3310  delete this;
3311  }
3312  }
3313 };
3314 
3315 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3317 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
3318  return new _TessFunctionResultCallback_6_1<true,R,P1,P2,P3,P4,P5,P6,A1>(function, p1, p2, p3, p4, p5, p6);
3319 }
3320 
3321 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
3323 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
3324  return new _TessFunctionResultCallback_6_1<false,R,P1,P2,P3,P4,P5,P6,A1>(function, p1, p2, p3, p4, p5, p6);
3325 }
3326 
3327 template <bool del, class R, class T, class A1, class A2>
3329  public:
3331  typedef R (T::*MemberSignature)(A1,A2) const;
3332 
3333  private:
3334  const T* object_;
3335  MemberSignature member_;
3336 
3337  public:
3339  const T* object, MemberSignature member)
3340  : object_(object),
3341  member_(member) {
3342  }
3343 
3344  virtual R Run(A1 a1,A2 a2) {
3345  if (!del) {
3346  R result = (object_->*member_)(a1,a2);
3347  return result;
3348  } else {
3349  R result = (object_->*member_)(a1,a2);
3350  // zero out the pointer to ensure segfault if used again
3351  member_ = NULL;
3352  delete this;
3353  return result;
3354  }
3355  }
3356 };
3357 
3358 template <bool del, class T, class A1, class A2>
3359 class _ConstTessMemberResultCallback_0_2<del, void, T, A1, A2>
3360  : public TessCallback2<A1,A2> {
3361  public:
3363  typedef void (T::*MemberSignature)(A1,A2) const;
3364 
3365  private:
3366  const T* object_;
3367  MemberSignature member_;
3368 
3369  public:
3371  const T* object, MemberSignature member)
3372  : object_(object),
3373  member_(member) {
3374  }
3375 
3376  virtual void Run(A1 a1,A2 a2) {
3377  if (!del) {
3378  (object_->*member_)(a1,a2);
3379  } else {
3380  (object_->*member_)(a1,a2);
3381  // zero out the pointer to ensure segfault if used again
3382  member_ = NULL;
3383  delete this;
3384  }
3385  }
3386 };
3387 
3388 #ifndef SWIG
3389 template <class T1, class T2, class R, class A1, class A2>
3392  const T1* obj, R (T2::*member)(A1,A2) const) {
3394  obj, member);
3395 }
3396 #endif
3397 
3398 #ifndef SWIG
3399 template <class T1, class T2, class R, class A1, class A2>
3402  const T1* obj, R (T2::*member)(A1,A2) const) {
3404  obj, member);
3405 }
3406 #endif
3407 
3408 template <bool del, class R, class T, class A1, class A2>
3410  public:
3412  typedef R (T::*MemberSignature)(A1,A2) ;
3413 
3414  private:
3415  T* object_;
3416  MemberSignature member_;
3417 
3418  public:
3420  T* object, MemberSignature member)
3421  : object_(object),
3422  member_(member) {
3423  }
3424 
3425  virtual R Run(A1 a1,A2 a2) {
3426  if (!del) {
3427  R result = (object_->*member_)(a1,a2);
3428  return result;
3429  } else {
3430  R result = (object_->*member_)(a1,a2);
3431  // zero out the pointer to ensure segfault if used again
3432  member_ = NULL;
3433  delete this;
3434  return result;
3435  }
3436  }
3437 };
3438 
3439 template <bool del, class T, class A1, class A2>
3440 class _TessMemberResultCallback_0_2<del, void, T, A1, A2>
3441  : public TessCallback2<A1,A2> {
3442  public:
3444  typedef void (T::*MemberSignature)(A1,A2) ;
3445 
3446  private:
3447  T* object_;
3448  MemberSignature member_;
3449 
3450  public:
3452  T* object, MemberSignature member)
3453  : object_(object),
3454  member_(member) {
3455  }
3456 
3457  virtual void Run(A1 a1,A2 a2) {
3458  if (!del) {
3459  (object_->*member_)(a1,a2);
3460  } else {
3461  (object_->*member_)(a1,a2);
3462  // zero out the pointer to ensure segfault if used again
3463  member_ = NULL;
3464  delete this;
3465  }
3466  }
3467 };
3468 
3469 #ifndef SWIG
3470 template <class T1, class T2, class R, class A1, class A2>
3473  T1* obj, R (T2::*member)(A1,A2) ) {
3475  obj, member);
3476 }
3477 #endif
3478 
3479 #ifndef SWIG
3480 template <class T1, class T2, class R, class A1, class A2>
3483  T1* obj, R (T2::*member)(A1,A2) ) {
3485  obj, member);
3486 }
3487 #endif
3488 
3489 template <bool del, class R, class A1, class A2>
3491  public:
3493  typedef R (*FunctionSignature)(A1,A2);
3494 
3495  private:
3496  FunctionSignature function_;
3497 
3498  public:
3500  FunctionSignature function)
3501  : function_(function) {
3502  }
3503 
3504  virtual R Run(A1 a1,A2 a2) {
3505  if (!del) {
3506  R result = (*function_)(a1,a2);
3507  return result;
3508  } else {
3509  R result = (*function_)(a1,a2);
3510  // zero out the pointer to ensure segfault if used again
3511  function_ = NULL;
3512  delete this;
3513  return result;
3514  }
3515  }
3516 };
3517 
3518 template <bool del, class A1, class A2>
3519 class _TessFunctionResultCallback_0_2<del, void, A1, A2>
3520  : public TessCallback2<A1,A2> {
3521  public:
3523  typedef void (*FunctionSignature)(A1,A2);
3524 
3525  private:
3526  FunctionSignature function_;
3527 
3528  public:
3530  FunctionSignature function)
3531  : function_(function) {
3532  }
3533 
3534  virtual void Run(A1 a1,A2 a2) {
3535  if (!del) {
3536  (*function_)(a1,a2);
3537  } else {
3538  (*function_)(a1,a2);
3539  // zero out the pointer to ensure segfault if used again
3540  function_ = NULL;
3541  delete this;
3542  }
3543  }
3544 };
3545 
3546 template <class R, class A1, class A2>
3548 NewTessCallback(R (*function)(A1,A2)) {
3549  return new _TessFunctionResultCallback_0_2<true,R,A1,A2>(function);
3550 }
3551 
3552 template <class R, class A1, class A2>
3554 NewPermanentTessCallback(R (*function)(A1,A2)) {
3556 }
3557 
3558 template <bool del, class R, class T, class P1, class A1, class A2>
3560  public:
3562  typedef R (T::*MemberSignature)(P1,A1,A2) const;
3563 
3564  private:
3565  const T* object_;
3566  MemberSignature member_;
3567  typename remove_reference<P1>::type p1_;
3568 
3569  public:
3570  inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1)
3571  : object_(object),
3572  member_(member), p1_(p1) { }
3573 
3574  virtual R Run(A1 a1,A2 a2) {
3575  if (!del) {
3576  R result = (object_->*member_)(p1_,a1,a2);
3577  return result;
3578  } else {
3579  R result = (object_->*member_)(p1_,a1,a2);
3580  // zero out the pointer to ensure segfault if used again
3581  member_ = NULL;
3582  delete this;
3583  return result;
3584  }
3585  }
3586 };
3587 
3588 template <bool del, class T, class P1, class A1, class A2>
3589 class _ConstTessMemberResultCallback_1_2<del, void, T, P1, A1, A2> : public TessCallback2<A1,A2> {
3590  public:
3592  typedef void (T::*MemberSignature)(P1,A1,A2) const;
3593 
3594  private:
3595  const T* object_;
3596  MemberSignature member_;
3597  typename remove_reference<P1>::type p1_;
3598 
3599  public:
3600  inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1)
3601  : object_(object),
3602  member_(member), p1_(p1) { }
3603 
3604  virtual void Run(A1 a1,A2 a2) {
3605  if (!del) {
3606  (object_->*member_)(p1_,a1,a2);
3607  } else {
3608  (object_->*member_)(p1_,a1,a2);
3609  // zero out the pointer to ensure segfault if used again
3610  member_ = NULL;
3611  delete this;
3612  }
3613  }
3614 };
3615 
3616 #ifndef SWIG
3617 template <class T1, class T2, class R, class P1, class A1, class A2>
3619 NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity<P1>::type p1) {
3620  return new _ConstTessMemberResultCallback_1_2<true,R,T1,P1,A1,A2>(obj, member, p1);
3621 }
3622 #endif
3623 
3624 #ifndef SWIG
3625 template <class T1, class T2, class R, class P1, class A1, class A2>
3627 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity<P1>::type p1) {
3628  return new _ConstTessMemberResultCallback_1_2<false,R,T1,P1,A1,A2>(obj, member, p1);
3629 }
3630 #endif
3631 
3632 template <bool del, class R, class T, class P1, class A1, class A2>
3634  public:
3636  typedef R (T::*MemberSignature)(P1,A1,A2) ;
3637 
3638  private:
3639  T* object_;
3640  MemberSignature member_;
3641  typename remove_reference<P1>::type p1_;
3642 
3643  public:
3644  inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1)
3645  : object_(object),
3646  member_(member), p1_(p1) { }
3647 
3648  virtual R Run(A1 a1,A2 a2) {
3649  if (!del) {
3650  R result = (object_->*member_)(p1_,a1,a2);
3651  return result;
3652  } else {
3653  R result = (object_->*member_)(p1_,a1,a2);
3654  // zero out the pointer to ensure segfault if used again
3655  member_ = NULL;
3656  delete this;
3657  return result;
3658  }
3659  }
3660 };
3661 
3662 template <bool del, class T, class P1, class A1, class A2>
3663 class _TessMemberResultCallback_1_2<del, void, T, P1, A1, A2> : public TessCallback2<A1,A2> {
3664  public:
3666  typedef void (T::*MemberSignature)(P1,A1,A2) ;
3667 
3668  private:
3669  T* object_;
3670  MemberSignature member_;
3671  typename remove_reference<P1>::type p1_;
3672 
3673  public:
3674  inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1)
3675  : object_(object),
3676  member_(member), p1_(p1) { }
3677 
3678  virtual void Run(A1 a1,A2 a2) {
3679  if (!del) {
3680  (object_->*member_)(p1_,a1,a2);
3681  } else {
3682  (object_->*member_)(p1_,a1,a2);
3683  // zero out the pointer to ensure segfault if used again
3684  member_ = NULL;
3685  delete this;
3686  }
3687  }
3688 };
3689 
3690 #ifndef SWIG
3691 template <class T1, class T2, class R, class P1, class A1, class A2>
3693 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity<P1>::type p1) {
3694  return new _TessMemberResultCallback_1_2<true,R,T1,P1,A1,A2>(obj, member, p1);
3695 }
3696 #endif
3697 
3698 #ifndef SWIG
3699 template <class T1, class T2, class R, class P1, class A1, class A2>
3701 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity<P1>::type p1) {
3702  return new _TessMemberResultCallback_1_2<false,R,T1,P1,A1,A2>(obj, member, p1);
3703 }
3704 #endif
3705 
3706 template <bool del, class R, class P1, class A1, class A2>
3708  public:
3710  typedef R (*FunctionSignature)(P1,A1,A2);
3711 
3712  private:
3713  FunctionSignature function_;
3714  typename remove_reference<P1>::type p1_;
3715 
3716  public:
3718  : function_(function), p1_(p1) { }
3719 
3720  virtual R Run(A1 a1,A2 a2) {
3721  if (!del) {
3722  R result = (*function_)(p1_,a1,a2);
3723  return result;
3724  } else {
3725  R result = (*function_)(p1_,a1,a2);
3726  // zero out the pointer to ensure segfault if used again
3727  function_ = NULL;
3728  delete this;
3729  return result;
3730  }
3731  }
3732 };
3733 
3734 template <bool del, class P1, class A1, class A2>
3735 class _TessFunctionResultCallback_1_2<del, void, P1, A1, A2> : public TessCallback2<A1,A2> {
3736  public:
3738  typedef void (*FunctionSignature)(P1,A1,A2);
3739 
3740  private:
3741  FunctionSignature function_;
3742  typename remove_reference<P1>::type p1_;
3743 
3744  public:
3746  : function_(function), p1_(p1) { }
3747 
3748  virtual void Run(A1 a1,A2 a2) {
3749  if (!del) {
3750  (*function_)(p1_,a1,a2);
3751  } else {
3752  (*function_)(p1_,a1,a2);
3753  // zero out the pointer to ensure segfault if used again
3754  function_ = NULL;
3755  delete this;
3756  }
3757  }
3758 };
3759 
3760 template <class R, class P1, class A1, class A2>
3762 NewTessCallback(R (*function)(P1,A1,A2), typename Identity<P1>::type p1) {
3763  return new _TessFunctionResultCallback_1_2<true,R,P1,A1,A2>(function, p1);
3764 }
3765 
3766 template <class R, class P1, class A1, class A2>
3768 NewPermanentTessCallback(R (*function)(P1,A1,A2), typename Identity<P1>::type p1) {
3769  return new _TessFunctionResultCallback_1_2<false,R,P1,A1,A2>(function, p1);
3770 }
3771 
3772 template <bool del, class R, class T, class P1, class P2, class A1, class A2>
3774  public:
3776  typedef R (T::*MemberSignature)(P1,P2,A1,A2) const;
3777 
3778  private:
3779  const T* object_;
3780  MemberSignature member_;
3781  typename remove_reference<P1>::type p1_;
3782  typename remove_reference<P2>::type p2_;
3783 
3784  public:
3785  inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2)
3786  : object_(object),
3787  member_(member), p1_(p1), p2_(p2) { }
3788 
3789  virtual R Run(A1 a1,A2 a2) {
3790  if (!del) {
3791  R result = (object_->*member_)(p1_,p2_,a1,a2);
3792  return result;
3793  } else {
3794  R result = (object_->*member_)(p1_,p2_,a1,a2);
3795  // zero out the pointer to ensure segfault if used again
3796  member_ = NULL;
3797  delete this;
3798  return result;
3799  }
3800  }
3801 };
3802 
3803 template <bool del, class T, class P1, class P2, class A1, class A2>
3804 class _ConstTessMemberResultCallback_2_2<del, void, T, P1, P2, A1, A2> : public TessCallback2<A1,A2> {
3805  public:
3807  typedef void (T::*MemberSignature)(P1,P2,A1,A2) const;
3808 
3809  private:
3810  const T* object_;
3811  MemberSignature member_;
3812  typename remove_reference<P1>::type p1_;
3813  typename remove_reference<P2>::type p2_;
3814 
3815  public:
3816  inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2)
3817  : object_(object),
3818  member_(member), p1_(p1), p2_(p2) { }
3819 
3820  virtual void Run(A1 a1,A2 a2) {
3821  if (!del) {
3822  (object_->*member_)(p1_,p2_,a1,a2);
3823  } else {
3824  (object_->*member_)(p1_,p2_,a1,a2);
3825  // zero out the pointer to ensure segfault if used again
3826  member_ = NULL;
3827  delete this;
3828  }
3829  }
3830 };
3831 
3832 #ifndef SWIG
3833 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
3835 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
3836  return new _ConstTessMemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
3837 }
3838 #endif
3839 
3840 #ifndef SWIG
3841 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
3843 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
3844  return new _ConstTessMemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
3845 }
3846 #endif
3847 
3848 template <bool del, class R, class T, class P1, class P2, class A1, class A2>
3850  public:
3852  typedef R (T::*MemberSignature)(P1,P2,A1,A2) ;
3853 
3854  private:
3855  T* object_;
3856  MemberSignature member_;
3857  typename remove_reference<P1>::type p1_;
3858  typename remove_reference<P2>::type p2_;
3859 
3860  public:
3861  inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2)
3862  : object_(object),
3863  member_(member), p1_(p1), p2_(p2) { }
3864 
3865  virtual R Run(A1 a1,A2 a2) {
3866  if (!del) {
3867  R result = (object_->*member_)(p1_,p2_,a1,a2);
3868  return result;
3869  } else {
3870  R result = (object_->*member_)(p1_,p2_,a1,a2);
3871  // zero out the pointer to ensure segfault if used again
3872  member_ = NULL;
3873  delete this;
3874  return result;
3875  }
3876  }
3877 };
3878 
3879 template <bool del, class T, class P1, class P2, class A1, class A2>
3880 class _TessMemberResultCallback_2_2<del, void, T, P1, P2, A1, A2> : public TessCallback2<A1,A2> {
3881  public:
3883  typedef void (T::*MemberSignature)(P1,P2,A1,A2) ;
3884 
3885  private:
3886  T* object_;
3887  MemberSignature member_;
3888  typename remove_reference<P1>::type p1_;
3889  typename remove_reference<P2>::type p2_;
3890 
3891  public:
3892  inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2)
3893  : object_(object),
3894  member_(member), p1_(p1), p2_(p2) { }
3895 
3896  virtual void Run(A1 a1,A2 a2) {
3897  if (!del) {
3898  (object_->*member_)(p1_,p2_,a1,a2);
3899  } else {
3900  (object_->*member_)(p1_,p2_,a1,a2);
3901  // zero out the pointer to ensure segfault if used again
3902  member_ = NULL;
3903  delete this;
3904  }
3905  }
3906 };
3907 
3908 #ifndef SWIG
3909 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
3911 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
3912  return new _TessMemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
3913 }
3914 #endif
3915 
3916 #ifndef SWIG
3917 template <class T1, class T2, class R, class P1, class P2, class A1, class A2>
3919 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
3920  return new _TessMemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>(obj, member, p1, p2);
3921 }
3922 #endif
3923 
3924 template <bool del, class R, class P1, class P2, class A1, class A2>
3926  public:
3928  typedef R (*FunctionSignature)(P1,P2,A1,A2);
3929 
3930  private:
3931  FunctionSignature function_;
3932  typename remove_reference<P1>::type p1_;
3933  typename remove_reference<P2>::type p2_;
3934 
3935  public:
3937  : function_(function), p1_(p1), p2_(p2) { }
3938 
3939  virtual R Run(A1 a1,A2 a2) {
3940  if (!del) {
3941  R result = (*function_)(p1_,p2_,a1,a2);
3942  return result;
3943  } else {
3944  R result = (*function_)(p1_,p2_,a1,a2);
3945  // zero out the pointer to ensure segfault if used again
3946  function_ = NULL;
3947  delete this;
3948  return result;
3949  }
3950  }
3951 };
3952 
3953 template <bool del, class P1, class P2, class A1, class A2>
3954 class _TessFunctionResultCallback_2_2<del, void, P1, P2, A1, A2> : public TessCallback2<A1,A2> {
3955  public:
3957  typedef void (*FunctionSignature)(P1,P2,A1,A2);
3958 
3959  private:
3960  FunctionSignature function_;
3961  typename remove_reference<P1>::type p1_;
3962  typename remove_reference<P2>::type p2_;
3963 
3964  public:
3966  : function_(function), p1_(p1), p2_(p2) { }
3967 
3968  virtual void Run(A1 a1,A2 a2) {
3969  if (!del) {
3970  (*function_)(p1_,p2_,a1,a2);
3971  } else {
3972  (*function_)(p1_,p2_,a1,a2);
3973  // zero out the pointer to ensure segfault if used again
3974  function_ = NULL;
3975  delete this;
3976  }
3977  }
3978 };
3979 
3980 template <class R, class P1, class P2, class A1, class A2>
3982 NewTessCallback(R (*function)(P1,P2,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
3983  return new _TessFunctionResultCallback_2_2<true,R,P1,P2,A1,A2>(function, p1, p2);
3984 }
3985 
3986 template <class R, class P1, class P2, class A1, class A2>
3988 NewPermanentTessCallback(R (*function)(P1,P2,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2) {
3989  return new _TessFunctionResultCallback_2_2<false,R,P1,P2,A1,A2>(function, p1, p2);
3990 }
3991 
3992 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2>
3994  public:
3996  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) const;
3997 
3998  private:
3999  const T* object_;
4000  MemberSignature member_;
4001  typename remove_reference<P1>::type p1_;
4002  typename remove_reference<P2>::type p2_;
4003  typename remove_reference<P3>::type p3_;
4004 
4005  public:
4006  inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
4007  : object_(object),
4008  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
4009 
4010  virtual R Run(A1 a1,A2 a2) {
4011  if (!del) {
4012  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
4013  return result;
4014  } else {
4015  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
4016  // zero out the pointer to ensure segfault if used again
4017  member_ = NULL;
4018  delete this;
4019  return result;
4020  }
4021  }
4022 };
4023 
4024 template <bool del, class T, class P1, class P2, class P3, class A1, class A2>
4025 class _ConstTessMemberResultCallback_3_2<del, void, T, P1, P2, P3, A1, A2> : public TessCallback2<A1,A2> {
4026  public:
4028  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) const;
4029 
4030  private:
4031  const T* object_;
4032  MemberSignature member_;
4033  typename remove_reference<P1>::type p1_;
4034  typename remove_reference<P2>::type p2_;
4035  typename remove_reference<P3>::type p3_;
4036 
4037  public:
4038  inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
4039  : object_(object),
4040  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
4041 
4042  virtual void Run(A1 a1,A2 a2) {
4043  if (!del) {
4044  (object_->*member_)(p1_,p2_,p3_,a1,a2);
4045  } else {
4046  (object_->*member_)(p1_,p2_,p3_,a1,a2);
4047  // zero out the pointer to ensure segfault if used again
4048  member_ = NULL;
4049  delete this;
4050  }
4051  }
4052 };
4053 
4054 #ifndef SWIG
4055 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
4057 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
4058  return new _ConstTessMemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
4059 }
4060 #endif
4061 
4062 #ifndef SWIG
4063 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
4065 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
4066  return new _ConstTessMemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
4067 }
4068 #endif
4069 
4070 template <bool del, class R, class T, class P1, class P2, class P3, class A1, class A2>
4072  public:
4074  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) ;
4075 
4076  private:
4077  T* object_;
4078  MemberSignature member_;
4079  typename remove_reference<P1>::type p1_;
4080  typename remove_reference<P2>::type p2_;
4081  typename remove_reference<P3>::type p3_;
4082 
4083  public:
4084  inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
4085  : object_(object),
4086  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
4087 
4088  virtual R Run(A1 a1,A2 a2) {
4089  if (!del) {
4090  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
4091  return result;
4092  } else {
4093  R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
4094  // zero out the pointer to ensure segfault if used again
4095  member_ = NULL;
4096  delete this;
4097  return result;
4098  }
4099  }
4100 };
4101 
4102 template <bool del, class T, class P1, class P2, class P3, class A1, class A2>
4103 class _TessMemberResultCallback_3_2<del, void, T, P1, P2, P3, A1, A2> : public TessCallback2<A1,A2> {
4104  public:
4106  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) ;
4107 
4108  private:
4109  T* object_;
4110  MemberSignature member_;
4111  typename remove_reference<P1>::type p1_;
4112  typename remove_reference<P2>::type p2_;
4113  typename remove_reference<P3>::type p3_;
4114 
4115  public:
4116  inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
4117  : object_(object),
4118  member_(member), p1_(p1), p2_(p2), p3_(p3) { }
4119 
4120  virtual void Run(A1 a1,A2 a2) {
4121  if (!del) {
4122  (object_->*member_)(p1_,p2_,p3_,a1,a2);
4123  } else {
4124  (object_->*member_)(p1_,p2_,p3_,a1,a2);
4125  // zero out the pointer to ensure segfault if used again
4126  member_ = NULL;
4127  delete this;
4128  }
4129  }
4130 };
4131 
4132 #ifndef SWIG
4133 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
4135 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
4136  return new _TessMemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
4137 }
4138 #endif
4139 
4140 #ifndef SWIG
4141 template <class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
4143 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
4144  return new _TessMemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>(obj, member, p1, p2, p3);
4145 }
4146 #endif
4147 
4148 template <bool del, class R, class P1, class P2, class P3, class A1, class A2>
4150  public:
4152  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2);
4153 
4154  private:
4155  FunctionSignature function_;
4156  typename remove_reference<P1>::type p1_;
4157  typename remove_reference<P2>::type p2_;
4158  typename remove_reference<P3>::type p3_;
4159 
4160  public:
4161  inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
4162  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
4163 
4164  virtual R Run(A1 a1,A2 a2) {
4165  if (!del) {
4166  R result = (*function_)(p1_,p2_,p3_,a1,a2);
4167  return result;
4168  } else {
4169  R result = (*function_)(p1_,p2_,p3_,a1,a2);
4170  // zero out the pointer to ensure segfault if used again
4171  function_ = NULL;
4172  delete this;
4173  return result;
4174  }
4175  }
4176 };
4177 
4178 template <bool del, class P1, class P2, class P3, class A1, class A2>
4179 class _TessFunctionResultCallback_3_2<del, void, P1, P2, P3, A1, A2> : public TessCallback2<A1,A2> {
4180  public:
4182  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2);
4183 
4184  private:
4185  FunctionSignature function_;
4186  typename remove_reference<P1>::type p1_;
4187  typename remove_reference<P2>::type p2_;
4188  typename remove_reference<P3>::type p3_;
4189 
4190  public:
4191  inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
4192  : function_(function), p1_(p1), p2_(p2), p3_(p3) { }
4193 
4194  virtual void Run(A1 a1,A2 a2) {
4195  if (!del) {
4196  (*function_)(p1_,p2_,p3_,a1,a2);
4197  } else {
4198  (*function_)(p1_,p2_,p3_,a1,a2);
4199  // zero out the pointer to ensure segfault if used again
4200  function_ = NULL;
4201  delete this;
4202  }
4203  }
4204 };
4205 
4206 template <class R, class P1, class P2, class P3, class A1, class A2>
4208 NewTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
4209  return new _TessFunctionResultCallback_3_2<true,R,P1,P2,P3,A1,A2>(function, p1, p2, p3);
4210 }
4211 
4212 template <class R, class P1, class P2, class P3, class A1, class A2>
4214 NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3) {
4215  return new _TessFunctionResultCallback_3_2<false,R,P1,P2,P3,A1,A2>(function, p1, p2, p3);
4216 }
4217 
4218 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2>
4220  public:
4222  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const;
4223 
4224  private:
4225  const T* object_;
4226  MemberSignature member_;
4227  typename remove_reference<P1>::type p1_;
4228  typename remove_reference<P2>::type p2_;
4229  typename remove_reference<P3>::type p3_;
4230  typename remove_reference<P4>::type p4_;
4231 
4232  public:
4233  inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
4234  : object_(object),
4235  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
4236 
4237  virtual R Run(A1 a1,A2 a2) {
4238  if (!del) {
4239  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4240  return result;
4241  } else {
4242  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4243  // zero out the pointer to ensure segfault if used again
4244  member_ = NULL;
4245  delete this;
4246  return result;
4247  }
4248  }
4249 };
4250 
4251 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2>
4252 class _ConstTessMemberResultCallback_4_2<del, void, T, P1, P2, P3, P4, A1, A2> : public TessCallback2<A1,A2> {
4253  public:
4255  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const;
4256 
4257  private:
4258  const T* object_;
4259  MemberSignature member_;
4260  typename remove_reference<P1>::type p1_;
4261  typename remove_reference<P2>::type p2_;
4262  typename remove_reference<P3>::type p3_;
4263  typename remove_reference<P4>::type p4_;
4264 
4265  public:
4266  inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
4267  : object_(object),
4268  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
4269 
4270  virtual void Run(A1 a1,A2 a2) {
4271  if (!del) {
4272  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4273  } else {
4274  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4275  // zero out the pointer to ensure segfault if used again
4276  member_ = NULL;
4277  delete this;
4278  }
4279  }
4280 };
4281 
4282 #ifndef SWIG
4283 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
4285 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
4286  return new _ConstTessMemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
4287 }
4288 #endif
4289 
4290 #ifndef SWIG
4291 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
4293 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
4294  return new _ConstTessMemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
4295 }
4296 #endif
4297 
4298 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class A1, class A2>
4300  public:
4302  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ;
4303 
4304  private:
4305  T* object_;
4306  MemberSignature member_;
4307  typename remove_reference<P1>::type p1_;
4308  typename remove_reference<P2>::type p2_;
4309  typename remove_reference<P3>::type p3_;
4310  typename remove_reference<P4>::type p4_;
4311 
4312  public:
4313  inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
4314  : object_(object),
4315  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
4316 
4317  virtual R Run(A1 a1,A2 a2) {
4318  if (!del) {
4319  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4320  return result;
4321  } else {
4322  R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4323  // zero out the pointer to ensure segfault if used again
4324  member_ = NULL;
4325  delete this;
4326  return result;
4327  }
4328  }
4329 };
4330 
4331 template <bool del, class T, class P1, class P2, class P3, class P4, class A1, class A2>
4332 class _TessMemberResultCallback_4_2<del, void, T, P1, P2, P3, P4, A1, A2> : public TessCallback2<A1,A2> {
4333  public:
4335  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ;
4336 
4337  private:
4338  T* object_;
4339  MemberSignature member_;
4340  typename remove_reference<P1>::type p1_;
4341  typename remove_reference<P2>::type p2_;
4342  typename remove_reference<P3>::type p3_;
4343  typename remove_reference<P4>::type p4_;
4344 
4345  public:
4346  inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
4347  : object_(object),
4348  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
4349 
4350  virtual void Run(A1 a1,A2 a2) {
4351  if (!del) {
4352  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4353  } else {
4354  (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
4355  // zero out the pointer to ensure segfault if used again
4356  member_ = NULL;
4357  delete this;
4358  }
4359  }
4360 };
4361 
4362 #ifndef SWIG
4363 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
4365 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
4366  return new _TessMemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
4367 }
4368 #endif
4369 
4370 #ifndef SWIG
4371 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
4373 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
4374  return new _TessMemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>(obj, member, p1, p2, p3, p4);
4375 }
4376 #endif
4377 
4378 template <bool del, class R, class P1, class P2, class P3, class P4, class A1, class A2>
4380  public:
4382  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2);
4383 
4384  private:
4385  FunctionSignature function_;
4386  typename remove_reference<P1>::type p1_;
4387  typename remove_reference<P2>::type p2_;
4388  typename remove_reference<P3>::type p3_;
4389  typename remove_reference<P4>::type p4_;
4390 
4391  public:
4392  inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
4393  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
4394 
4395  virtual R Run(A1 a1,A2 a2) {
4396  if (!del) {
4397  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2);
4398  return result;
4399  } else {
4400  R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2);
4401  // zero out the pointer to ensure segfault if used again
4402  function_ = NULL;
4403  delete this;
4404  return result;
4405  }
4406  }
4407 };
4408 
4409 template <bool del, class P1, class P2, class P3, class P4, class A1, class A2>
4410 class _TessFunctionResultCallback_4_2<del, void, P1, P2, P3, P4, A1, A2> : public TessCallback2<A1,A2> {
4411  public:
4413  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2);
4414 
4415  private:
4416  FunctionSignature function_;
4417  typename remove_reference<P1>::type p1_;
4418  typename remove_reference<P2>::type p2_;
4419  typename remove_reference<P3>::type p3_;
4420  typename remove_reference<P4>::type p4_;
4421 
4422  public:
4423  inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
4424  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4) { }
4425 
4426  virtual void Run(A1 a1,A2 a2) {
4427  if (!del) {
4428  (*function_)(p1_,p2_,p3_,p4_,a1,a2);
4429  } else {
4430  (*function_)(p1_,p2_,p3_,p4_,a1,a2);
4431  // zero out the pointer to ensure segfault if used again
4432  function_ = NULL;
4433  delete this;
4434  }
4435  }
4436 };
4437 
4438 template <class R, class P1, class P2, class P3, class P4, class A1, class A2>
4440 NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
4441  return new _TessFunctionResultCallback_4_2<true,R,P1,P2,P3,P4,A1,A2>(function, p1, p2, p3, p4);
4442 }
4443 
4444 template <class R, class P1, class P2, class P3, class P4, class A1, class A2>
4446 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4) {
4447  return new _TessFunctionResultCallback_4_2<false,R,P1,P2,P3,P4,A1,A2>(function, p1, p2, p3, p4);
4448 }
4449 
4450 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4452  public:
4454  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const;
4455 
4456  private:
4457  const T* object_;
4458  MemberSignature member_;
4459  typename remove_reference<P1>::type p1_;
4460  typename remove_reference<P2>::type p2_;
4461  typename remove_reference<P3>::type p3_;
4462  typename remove_reference<P4>::type p4_;
4463  typename remove_reference<P5>::type p5_;
4464 
4465  public:
4466  inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
4467  : object_(object),
4468  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
4469 
4470  virtual R Run(A1 a1,A2 a2) {
4471  if (!del) {
4472  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4473  return result;
4474  } else {
4475  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4476  // zero out the pointer to ensure segfault if used again
4477  member_ = NULL;
4478  delete this;
4479  return result;
4480  }
4481  }
4482 };
4483 
4484 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4485 class _ConstTessMemberResultCallback_5_2<del, void, T, P1, P2, P3, P4, P5, A1, A2> : public TessCallback2<A1,A2> {
4486  public:
4488  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const;
4489 
4490  private:
4491  const T* object_;
4492  MemberSignature member_;
4493  typename remove_reference<P1>::type p1_;
4494  typename remove_reference<P2>::type p2_;
4495  typename remove_reference<P3>::type p3_;
4496  typename remove_reference<P4>::type p4_;
4497  typename remove_reference<P5>::type p5_;
4498 
4499  public:
4500  inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
4501  : object_(object),
4502  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
4503 
4504  virtual void Run(A1 a1,A2 a2) {
4505  if (!del) {
4506  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4507  } else {
4508  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4509  // zero out the pointer to ensure segfault if used again
4510  member_ = NULL;
4511  delete this;
4512  }
4513  }
4514 };
4515 
4516 #ifndef SWIG
4517 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4519 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
4520  return new _ConstTessMemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
4521 }
4522 #endif
4523 
4524 #ifndef SWIG
4525 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4527 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
4528  return new _ConstTessMemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
4529 }
4530 #endif
4531 
4532 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4534  public:
4536  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ;
4537 
4538  private:
4539  T* object_;
4540  MemberSignature member_;
4541  typename remove_reference<P1>::type p1_;
4542  typename remove_reference<P2>::type p2_;
4543  typename remove_reference<P3>::type p3_;
4544  typename remove_reference<P4>::type p4_;
4545  typename remove_reference<P5>::type p5_;
4546 
4547  public:
4548  inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
4549  : object_(object),
4550  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
4551 
4552  virtual R Run(A1 a1,A2 a2) {
4553  if (!del) {
4554  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4555  return result;
4556  } else {
4557  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4558  // zero out the pointer to ensure segfault if used again
4559  member_ = NULL;
4560  delete this;
4561  return result;
4562  }
4563  }
4564 };
4565 
4566 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4567 class _TessMemberResultCallback_5_2<del, void, T, P1, P2, P3, P4, P5, A1, A2> : public TessCallback2<A1,A2> {
4568  public:
4570  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ;
4571 
4572  private:
4573  T* object_;
4574  MemberSignature member_;
4575  typename remove_reference<P1>::type p1_;
4576  typename remove_reference<P2>::type p2_;
4577  typename remove_reference<P3>::type p3_;
4578  typename remove_reference<P4>::type p4_;
4579  typename remove_reference<P5>::type p5_;
4580 
4581  public:
4582  inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
4583  : object_(object),
4584  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
4585 
4586  virtual void Run(A1 a1,A2 a2) {
4587  if (!del) {
4588  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4589  } else {
4590  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4591  // zero out the pointer to ensure segfault if used again
4592  member_ = NULL;
4593  delete this;
4594  }
4595  }
4596 };
4597 
4598 #ifndef SWIG
4599 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4601 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
4602  return new _TessMemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
4603 }
4604 #endif
4605 
4606 #ifndef SWIG
4607 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4609 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
4610  return new _TessMemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>(obj, member, p1, p2, p3, p4, p5);
4611 }
4612 #endif
4613 
4614 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4616  public:
4618  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2);
4619 
4620  private:
4621  FunctionSignature function_;
4622  typename remove_reference<P1>::type p1_;
4623  typename remove_reference<P2>::type p2_;
4624  typename remove_reference<P3>::type p3_;
4625  typename remove_reference<P4>::type p4_;
4626  typename remove_reference<P5>::type p5_;
4627 
4628  public:
4629  inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
4630  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
4631 
4632  virtual R Run(A1 a1,A2 a2) {
4633  if (!del) {
4634  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4635  return result;
4636  } else {
4637  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4638  // zero out the pointer to ensure segfault if used again
4639  function_ = NULL;
4640  delete this;
4641  return result;
4642  }
4643  }
4644 };
4645 
4646 template <bool del, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4647 class _TessFunctionResultCallback_5_2<del, void, P1, P2, P3, P4, P5, A1, A2> : public TessCallback2<A1,A2> {
4648  public:
4650  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2);
4651 
4652  private:
4653  FunctionSignature function_;
4654  typename remove_reference<P1>::type p1_;
4655  typename remove_reference<P2>::type p2_;
4656  typename remove_reference<P3>::type p3_;
4657  typename remove_reference<P4>::type p4_;
4658  typename remove_reference<P5>::type p5_;
4659 
4660  public:
4661  inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
4662  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5) { }
4663 
4664  virtual void Run(A1 a1,A2 a2) {
4665  if (!del) {
4666  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4667  } else {
4668  (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
4669  // zero out the pointer to ensure segfault if used again
4670  function_ = NULL;
4671  delete this;
4672  }
4673  }
4674 };
4675 
4676 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4678 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
4679  return new _TessFunctionResultCallback_5_2<true,R,P1,P2,P3,P4,P5,A1,A2>(function, p1, p2, p3, p4, p5);
4680 }
4681 
4682 template <class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
4684 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5) {
4685  return new _TessFunctionResultCallback_5_2<false,R,P1,P2,P3,P4,P5,A1,A2>(function, p1, p2, p3, p4, p5);
4686 }
4687 
4688 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4690  public:
4692  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const;
4693 
4694  private:
4695  const T* object_;
4696  MemberSignature member_;
4697  typename remove_reference<P1>::type p1_;
4698  typename remove_reference<P2>::type p2_;
4699  typename remove_reference<P3>::type p3_;
4700  typename remove_reference<P4>::type p4_;
4701  typename remove_reference<P5>::type p5_;
4702  typename remove_reference<P6>::type p6_;
4703 
4704  public:
4705  inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
4706  : object_(object),
4707  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
4708 
4709  virtual R Run(A1 a1,A2 a2) {
4710  if (!del) {
4711  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4712  return result;
4713  } else {
4714  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4715  // zero out the pointer to ensure segfault if used again
4716  member_ = NULL;
4717  delete this;
4718  return result;
4719  }
4720  }
4721 };
4722 
4723 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4724 class _ConstTessMemberResultCallback_6_2<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2> : public TessCallback2<A1,A2> {
4725  public:
4727  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const;
4728 
4729  private:
4730  const T* object_;
4731  MemberSignature member_;
4732  typename remove_reference<P1>::type p1_;
4733  typename remove_reference<P2>::type p2_;
4734  typename remove_reference<P3>::type p3_;
4735  typename remove_reference<P4>::type p4_;
4736  typename remove_reference<P5>::type p5_;
4737  typename remove_reference<P6>::type p6_;
4738 
4739  public:
4740  inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
4741  : object_(object),
4742  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
4743 
4744  virtual void Run(A1 a1,A2 a2) {
4745  if (!del) {
4746  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4747  } else {
4748  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4749  // zero out the pointer to ensure segfault if used again
4750  member_ = NULL;
4751  delete this;
4752  }
4753  }
4754 };
4755 
4756 #ifndef SWIG
4757 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4759 NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
4760  return new _ConstTessMemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
4761 }
4762 #endif
4763 
4764 #ifndef SWIG
4765 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4767 NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) const, typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
4768  return new _ConstTessMemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
4769 }
4770 #endif
4771 
4772 template <bool del, class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4774  public:
4776  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ;
4777 
4778  private:
4779  T* object_;
4780  MemberSignature member_;
4781  typename remove_reference<P1>::type p1_;
4782  typename remove_reference<P2>::type p2_;
4783  typename remove_reference<P3>::type p3_;
4784  typename remove_reference<P4>::type p4_;
4785  typename remove_reference<P5>::type p5_;
4786  typename remove_reference<P6>::type p6_;
4787 
4788  public:
4789  inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
4790  : object_(object),
4791  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
4792 
4793  virtual R Run(A1 a1,A2 a2) {
4794  if (!del) {
4795  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4796  return result;
4797  } else {
4798  R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4799  // zero out the pointer to ensure segfault if used again
4800  member_ = NULL;
4801  delete this;
4802  return result;
4803  }
4804  }
4805 };
4806 
4807 template <bool del, class T, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4808 class _TessMemberResultCallback_6_2<del, void, T, P1, P2, P3, P4, P5, P6, A1, A2> : public TessCallback2<A1,A2> {
4809  public:
4811  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ;
4812 
4813  private:
4814  T* object_;
4815  MemberSignature member_;
4816  typename remove_reference<P1>::type p1_;
4817  typename remove_reference<P2>::type p2_;
4818  typename remove_reference<P3>::type p3_;
4819  typename remove_reference<P4>::type p4_;
4820  typename remove_reference<P5>::type p5_;
4821  typename remove_reference<P6>::type p6_;
4822 
4823  public:
4824  inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
4825  : object_(object),
4826  member_(member), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
4827 
4828  virtual void Run(A1 a1,A2 a2) {
4829  if (!del) {
4830  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4831  } else {
4832  (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4833  // zero out the pointer to ensure segfault if used again
4834  member_ = NULL;
4835  delete this;
4836  }
4837  }
4838 };
4839 
4840 #ifndef SWIG
4841 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4843 NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
4844  return new _TessMemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
4845 }
4846 #endif
4847 
4848 #ifndef SWIG
4849 template <class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4851 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) , typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
4852  return new _TessMemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>(obj, member, p1, p2, p3, p4, p5, p6);
4853 }
4854 #endif
4855 
4856 template <bool del, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4858  public:
4860  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2);
4861 
4862  private:
4863  FunctionSignature function_;
4864  typename remove_reference<P1>::type p1_;
4865  typename remove_reference<P2>::type p2_;
4866  typename remove_reference<P3>::type p3_;
4867  typename remove_reference<P4>::type p4_;
4868  typename remove_reference<P5>::type p5_;
4869  typename remove_reference<P6>::type p6_;
4870 
4871  public:
4872  inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
4873  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
4874 
4875  virtual R Run(A1 a1,A2 a2) {
4876  if (!del) {
4877  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4878  return result;
4879  } else {
4880  R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4881  // zero out the pointer to ensure segfault if used again
4882  function_ = NULL;
4883  delete this;
4884  return result;
4885  }
4886  }
4887 };
4888 
4889 template <bool del, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4890 class _TessFunctionResultCallback_6_2<del, void, P1, P2, P3, P4, P5, P6, A1, A2> : public TessCallback2<A1,A2> {
4891  public:
4893  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2);
4894 
4895  private:
4896  FunctionSignature function_;
4897  typename remove_reference<P1>::type p1_;
4898  typename remove_reference<P2>::type p2_;
4899  typename remove_reference<P3>::type p3_;
4900  typename remove_reference<P4>::type p4_;
4901  typename remove_reference<P5>::type p5_;
4902  typename remove_reference<P6>::type p6_;
4903 
4904  public:
4905  inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
4906  : function_(function), p1_(p1), p2_(p2), p3_(p3), p4_(p4), p5_(p5), p6_(p6) { }
4907 
4908  virtual void Run(A1 a1,A2 a2) {
4909  if (!del) {
4910  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4911  } else {
4912  (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
4913  // zero out the pointer to ensure segfault if used again
4914  function_ = NULL;
4915  delete this;
4916  }
4917  }
4918 };
4919 
4920 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4922 NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
4923  return new _TessFunctionResultCallback_6_2<true,R,P1,P2,P3,P4,P5,P6,A1,A2>(function, p1, p2, p3, p4, p5, p6);
4924 }
4925 
4926 template <class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
4928 NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2), typename Identity<P1>::type p1, typename Identity<P2>::type p2, typename Identity<P3>::type p3, typename Identity<P4>::type p4, typename Identity<P5>::type p5, typename Identity<P6>::type p6) {
4929  return new _TessFunctionResultCallback_6_2<false,R,P1,P2,P3,P4,P5,P6,A1,A2>(function, p1, p2, p3, p4, p5, p6);
4930 }
4931 
4932 template <bool del, class R, class T, class A1, class A2, class A3>
4934  public:
4936  typedef R (T::*MemberSignature)(A1,A2,A3) const;
4937 
4938  private:
4939  const T* object_;
4940  MemberSignature member_;
4941 
4942  public:
4944  const T* object, MemberSignature member)
4945  : object_(object),
4946  member_(member) {
4947  }
4948 
4949  virtual R Run(A1 a1,A2 a2,A3 a3) {
4950  if (!del) {
4951  R result = (object_->*member_)(a1,a2,a3);
4952  return result;
4953  } else {
4954  R result = (object_->*member_)(a1,a2,a3);
4955  // zero out the pointer to ensure segfault if used again
4956  member_ = NULL;
4957  delete this;
4958  return result;
4959  }
4960  }
4961 };
4962 
4963 template <bool del, class T, class A1, class A2, class A3>
4964 class _ConstTessMemberResultCallback_0_3<del, void, T, A1, A2, A3>
4965  : public TessCallback3<A1,A2,A3> {
4966  public:
4968  typedef void (T::*MemberSignature)(A1,A2,A3) const;
4969 
4970  private:
4971  const T* object_;
4972  MemberSignature member_;
4973 
4974  public:
4976  const T* object, MemberSignature member)
4977  : object_(object),
4978  member_(member) {
4979  }
4980 
4981  virtual void Run(A1 a1,A2 a2,A3 a3) {
4982  if (!del) {
4983  (object_->*member_)(a1,a2,a3);
4984  } else {
4985  (object_->*member_)(a1,a2,a3);
4986  // zero out the pointer to ensure segfault if used again
4987  member_ = NULL;
4988  delete this;
4989  }
4990  }
4991 };
4992 
4993 #ifndef SWIG
4994 template <class T1, class T2, class R, class A1, class A2, class A3>
4997  const T1* obj, R (T2::*member)(A1,A2,A3) const) {
4999  obj, member);
5000 }
5001 #endif
5002 
5003 #ifndef SWIG
5004 template <class T1, class T2, class R, class A1, class A2, class A3>
5007  const T1* obj, R (T2::*member)(A1,A2,A3) const) {
5009  obj, member);
5010 }
5011 #endif
5012 
5013 template <bool del, class R, class T, class A1, class A2, class A3>
5015  public:
5017  typedef R (T::*MemberSignature)(A1,A2,A3) ;
5018 
5019  private:
5020  T* object_;
5021  MemberSignature member_;
5022 
5023  public:
5025  T* object, MemberSignature member)
5026  : object_(object),
5027  member_(member) {
5028  }
5029 
5030  virtual R Run(A1 a1,A2 a2,A3 a3) {
5031  if (!del) {
5032  R result = (object_->*member_)(a1,a2,a3);
5033  return result;
5034  } else {
5035  R result = (object_->*member_)(a1,a2,a3);
5036  // zero out the pointer to ensure segfault if used again
5037  member_ = NULL;
5038  delete this;
5039  return result;
5040  }
5041  }
5042 };
5043 
5044 template <bool del, class T, class A1, class A2, class A3>
5045 class _TessMemberResultCallback_0_3<del, void, T, A1, A2, A3>
5046  : public TessCallback3<A1,A2,A3> {
5047  public:
5049  typedef void (T::*MemberSignature)(A1,A2,A3) ;
5050 
5051  private:
5052  T* object_;
5053  MemberSignature member_;
5054 
5055  public:
5057  T* object, MemberSignature member)
5058  : object_(object),
5059  member_(member) {
5060  }
5061 
5062  virtual void Run(A1 a1,A2 a2,A3 a3) {
5063  if (!del) {
5064  (object_->*member_)(a1,a2,a3);
5065  } else {
5066  (object_->*member_)(a1,a2,a3);
5067  // zero out the pointer to ensure segfault if used again
5068  member_ = NULL;
5069  delete this;
5070  }
5071  }
5072 };
5073 
5074 #ifndef SWIG
5075 template <class T1, class T2, class R, class A1, class A2, class A3>
5078  T1* obj, R (T2::*member)(A1,A2,A3) ) {
5080  obj, member);
5081 }
5082 #endif
5083 
5084 #ifndef SWIG
5085 template <class T1, class T2, class R, class A1, class A2, class A3>
5088  T1* obj, R (T2::*member)(A1,A2,A3) ) {
5090  obj, member);
5091 }
5092 #endif
5093 
5094 template <bool del, class R, class A1, class A2, class A3>
5096  public:
5098  typedef R (*FunctionSignature)(A1,A2,A3);
5099 
5100  private:
5101  FunctionSignature function_;
5102 
5103  public:
5105  FunctionSignature function)
5106  : function_(function) {
5107  }
5108 
5109  virtual R Run(A1 a1,A2 a2,A3 a3) {
5110  if (!del) {
5111  R result = (*function_)(a1,a2,a3);
5112  return result;
5113  } else {
5114  R result = (*function_)(a1,a2,a3);
5115  // zero out the pointer to ensure segfault if used again
5116  function_ = NULL;
5117  delete this;
5118  return result;
5119  }
5120  }
5121 };
5122 
5123 template <bool del, class A1, class A2, class A3>
5124 class _TessFunctionResultCallback_0_3<del, void, A1, A2, A3>
5125  : public TessCallback3<A1,A2,A3> {
5126  public:
5128  typedef void (*FunctionSignature)(A1,A2,A3);
5129 
5130  private:
5131  FunctionSignature function_;
5132 
5133  public:
5135  FunctionSignature function)
5136  : function_(function) {
5137  }
5138 
5139  virtual void Run(A1 a1,A2 a2,A3 a3) {
5140  if (!del) {
5141  (*function_)(a1,a2,a3);
5142  } else {
5143  (*function_)(a1,a2,a3);
5144  // zero out the pointer to ensure segfault if used again
5145  function_ = NULL;
5146  delete this;
5147  }
5148  }
5149 };
5150 
5151 template <class R, class A1, class A2, class A3>
5153 NewTessCallback(R (*function)(A1,A2,A3)) {
5155 }
5156 
5157 template <class R, class A1, class A2, class A3>
5159 NewPermanentTessCallback(R (*function)(A1,A2,A3)) {
5161 }
5162 
5163 template <bool del, class R, class T, class P1, class A1, class A2, class A3>
5165  : public TessResultCallback3<R,A1,A2,A3> {
5166  public:
5168  typedef R (T::*MemberSignature)(P1,A1,A2,A3) const;
5169 
5170  private:
5171  T* object_;
5172  MemberSignature member_;
5173  typename remove_reference<P1>::type p1_;
5174 
5175  public:
5177  MemberSignature member, P1 p1)
5178  : object_(object), member_(member), p1_(p1) { }
5179 
5180  virtual R Run(A1 a1, A2 a2, A3 a3) {
5181  if (!del) {
5182  R result = (object_->*member_)(p1_,a1,a2,a3);
5183  return result;
5184  } else {
5185  R result = (object_->*member_)(p1_,a1,a2,a3);
5186  // zero out the pointer to ensure segfault if used again
5187  member_ = NULL;
5188  delete this;
5189  return result;
5190  }
5191  }
5192 };
5193 
5194 template <bool del, class T, class P1, class A1, class A2, class A3>
5195 class _ConstTessMemberResultCallback_1_3<del, void, T, P1, A1, A2, A3>
5196  : public TessCallback3<A1,A2,A3> {
5197  public:
5199  typedef void (T::*MemberSignature)(P1,A1,A2,A3) const;
5200 
5201  private:
5202  T* object_;
5203  MemberSignature member_;
5204  typename remove_reference<P1>::type p1_;
5205 
5206  public:
5208  MemberSignature member, P1 p1)
5209  : object_(object), member_(member), p1_(p1) { }
5210 
5211  virtual void Run(A1 a1, A2 a2, A3 a3) {
5212  if (!del) {
5213  (object_->*member_)(p1_,a1,a2,a3);
5214  } else {
5215  (object_->*member_)(p1_,a1,a2,a3);
5216  // zero out the pointer to ensure segfault if used again
5217  member_ = NULL;
5218  delete this;
5219  }
5220  }
5221 };
5222 
5223 #ifndef SWIG
5224 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
5226 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
5228 }
5229 #endif
5230 
5231 #ifndef SWIG
5232 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
5234 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
5236 }
5237 #endif
5238 
5239 template <bool del, class R, class T, class P1, class A1, class A2, class A3>
5241  public:
5243  typedef R (T::*MemberSignature)(P1,A1,A2,A3) ;
5244 
5245  private:
5246  T* object_;
5247  MemberSignature member_;
5248  typename remove_reference<P1>::type p1_;
5249 
5250  public:
5252  MemberSignature member, P1 p1)
5253  : object_(object), member_(member), p1_(p1) { }
5254 
5255  virtual R Run(A1 a1, A2 a2, A3 a3) {
5256  if (!del) {
5257  R result = (object_->*member_)(p1_,a1,a2,a3);
5258  return result;
5259  } else {
5260  R result = (object_->*member_)(p1_,a1,a2,a3);
5261  // zero out the pointer to ensure segfault if used again
5262  member_ = NULL;
5263  delete this;
5264  return result;
5265  }
5266  }
5267 };
5268 
5269 template <bool del, class T, class P1, class A1, class A2, class A3>
5270 class _TessMemberResultCallback_1_3<del, void, T, P1, A1, A2, A3>
5271  : public TessCallback3<A1,A2,A3> {
5272  public:
5274  typedef void (T::*MemberSignature)(P1,A1,A2,A3) ;
5275 
5276  private:
5277  T* object_;
5278  MemberSignature member_;
5279  typename remove_reference<P1>::type p1_;
5280 
5281  public:
5283  MemberSignature member, P1 p1)
5284  : object_(object), member_(member), p1_(p1) { }
5285 
5286  virtual void Run(A1 a1, A2 a2, A3 a3) {
5287  if (!del) {
5288  (object_->*member_)(p1_,a1,a2,a3);
5289  } else {
5290  (object_->*member_)(p1_,a1,a2,a3);
5291  // zero out the pointer to ensure segfault if used again
5292  member_ = NULL;
5293  delete this;
5294  }
5295  }
5296 };
5297 
5298 #ifndef SWIG
5299 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
5301 NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
5302  return new _TessMemberResultCallback_1_3<true,R,T1,P1,A1,A2,A3>(obj, member, p1);
5303 }
5304 #endif
5305 
5306 #ifndef SWIG
5307 template <class T1, class T2, class R, class P1, class A1, class A2, class A3>
5309 NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity<P1>::type p1) {
5310  return new _TessMemberResultCallback_1_3<false,R,T1,P1,A1,A2,A3>(obj, member, p1);
5311 }
5312 #endif
5313 
5314 template <bool del, class R, class P1, class A1, class A2, class A3>
5316  public:
5318  typedef R (*FunctionSignature)(P1,A1,A2,A3);
5319 
5320  private:
5321  FunctionSignature function_;
5322  typename remove_reference<P1>::type p1_;
5323 
5324  public:
5326  : function_(function), p1_(p1) { }
5327 
5328  virtual R Run(A1 a1, A2 a2, A3 a3) {
5329  if (!del) {
5330  R result = (*function_)(p1_,a1,a2,a3);
5331  return result;
5332  } else {
5333  R result = (*function_)(p1_,a1,a2,a3);
5334  // zero out the pointer to ensure segfault if used again
5335  function_ = NULL;
5336  delete this;
5337  return result;
5338  }
5339  }
5340 };
5341 
5342 template <bool del, class P1, class A1, class A2, class A3>
5343 class _TessFunctionResultCallback_1_3<del, void, P1, A1, A2, A3>
5344  : public TessCallback3<A1,A2,A3> {
5345  public:
5347  typedef void (*FunctionSignature)(P1,A1,A2,A3);
5348 
5349  private:
5350  FunctionSignature function_;
5351  typename remove_reference<P1>::type p1_;
5352 
5353  public:
5355  : function_(function), p1_(p1) { }
5356 
5357  virtual void Run(A1 a1, A2 a2, A3 a3) {
5358  if (!del) {
5359  (*function_)(p1_,a1,a2,a3);
5360  } else {
5361  (*function_)(p1_,a1,a2,a3);
5362  // zero out the pointer to ensure segfault if used again
5363  function_ = NULL;
5364  delete this;
5365  }
5366  }
5367 };
5368 
5369 template <class R, class P1, class A1, class A2, class A3>
5371 NewTessCallback(R (*function)(P1,A1,A2,A3), typename Identity<P1>::type p1) {
5372  return new _TessFunctionResultCallback_1_3<true,R,P1,A1,A2,A3>(function, p1);
5373 }
5374 
5375 template <class R, class P1, class A1, class A2, class A3>
5377 NewPermanentTessCallback(R (*function)(P1,A1,A2,A3), typename Identity<P1>::type p1) {
5379 }
5380 
5381 template <bool del, class R, class T, class P1, class P2, class A1, class A2, class A3>
5383  public:
5385  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) const;
5386 
5387  private: